Awars III/FieldScene.m

   1 //
   2 //  FieldScene.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 "FieldScene.h"
  10
  11 @implementation FieldScene
  12
  13 -(void)awakeFromNib{
  14
  15     [CAttackListTV setTarget:self];
  16     [CAttackListTV setDoubleAction:@selector(doubleClickCAL:)];
  17     [CAttackListTV setTarget:self];
  18     [CAttackListTV setAction:@selector(clickCAL:)];
  19
  20     [CResearchListTV setTarget:self];
  21     [CResearchListTV setDoubleAction:@selector(doubleClickCRL:)];
  22     [CResearchListTV setTarget:self];
  23     [CResearchListTV setAction:@selector(clickCRL:)];
  24
  25     [BCreateListTV setTarget:self];
  26     [BCreateListTV setDoubleAction:@selector(doubleClickBCL:)];
  27     [BCreateListTV setTarget:self];
  28     [BCreateListTV setAction:@selector(clickBCL:)];
  29
  30     [CSummonListTV setTarget:self];
  31     [CSummonListTV setDoubleAction:@selector(doubleClickCSL:)];
  32     [CSummonListTV setTarget:self];
  33     [CSummonListTV setAction:@selector(clickCSL:)];
  34
  35     [loadFileOutputListTV setTarget:self];
  36     [loadFileOutputListTV setAction:@selector(clickLFOL:)];
  37
  38     [saveGameListTV setTarget:self];
  39     [saveGameListTV setAction:@selector(clickSGL)];
  40
  41
  42
  43     CAttackListMA = [NSMutableArray new];
  44     CResearchListMA = [NSMutableArray new];
  45     BCreateListMA = [NSMutableArray new];
  46     CSummonListMA = [NSMutableArray new];
  47     saveFileInputListMA = [NSMutableArray new];
  48     loadFileOutputListMA = [NSMutableArray new];
  49     saveGameListMA = [NSMutableArray new];
  50
  51     SAV = [NSMutableArray new];
  52
  53     [IVimage setHidden:YES];
  54     [TFname setHidden:YES];
  55     [TFmessage setHidden:YES];
  56     [BXname setHidden:YES];
  57     [BXmessage setHidden:YES];
  58     [IVimage setEnabled:NO];
  59     [TFname setEnabled:NO];
  60     [TFmessage setEnabled:NO];
  61
  62 }
  63
  64 -(id)init{
  65
  66     if(self){
  67         time  = [NSTimer
  68                  scheduledTimerWithTimeInterval:1.0/30
  69                  target:self
  70                  selector:@selector(EventLoopFS:)
  71                  userInfo:nil
  72                  repeats:YES
  73                  ];
  74
  75         fieldScene = self;
  76         fieldSceneSelfFlag = true;
  77         openingAVP = NULL;
  78
  79         P[0].name = [@"青軍" retain];
  80         P[0].type = 0;
  81         P[0].resource = 500;
  82         P[0].food = 500;
  83         P[0].money = 500;
  84
  85         P[1].name = [@"赤軍" retain];
  86         P[1].type = 0;
  87         P[1].resource = 500;
  88         P[1].food = 500;
  89         P[1].money = 500;
  90
  91         P[2].name = [@"黄軍" retain];
  92         P[2].type = 0;
  93         P[2].resource = 500;
  94         P[2].food = 500;
  95         P[2].money = 500;
  96
  97         eventTime = 0;
  98
  99
 100     }
 101
 102
 103     return self;
 104 }
 105
 106 -(void)writeInt:(FILE*)fp val:(int)val{
 107     int counter;
 108
 109     for(counter = INT_MAX;counter > 0;counter>>=8){
 110         unsigned char nowData = val&0xFF;
 111         val >>= 8;
 112         fwrite(&nowData, sizeof(unsigned char), 1, fp);
 113     }
 114 }
 115
 116 -(void)writeNSString:(FILE*)fp str:(NSString*)str{
 117     int length = (int)[str length];
 118     [self writeInt:fp val:length];
 119     fwrite([str UTF8String], sizeof(str), length, fp);
 120 }
 121
 122 -(void)writeNSImage:(FILE*)fp str:(NSImage*)img adCnt:(int*)adCnt adFix:(int*)adFix{
 123     FILE *fpx;
 124
 125     NSString *directoryPath;
 126
 127     directoryPath = [[NSBundle mainBundle] bundlePath];
 128     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
 129
 130     NSString* Cpath = @"Contents/Resources/";
 131     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
 132
 133     if(1){
 134         NSData *imgData = [img TIFFRepresentation];
 135         NSBitmapImageRep *brep = [NSBitmapImageRep imageRepWithData:imgData];
 136         imgData = [brep representationUsingType:NSPNGFileType properties:nil];
 137         [imgData writeToFile:@INSTANT_IMG atomically:YES];
 138
 139         fpx = fopen(INSTANT_IMG, "rb");
 140         [self fcopy:fpx wfp:fp adCnt:adCnt adFix:adFix];
 141         fclose(fpx);
 142     }
 143
 144     routeCnt++;
 145 }
 146
 147
 148 -(int)fcopy:(FILE *)rfp wfp:(FILE *)wfp adCnt:(int*)adCnt adFix:(int*)adFix{
 149
 150     unsigned char in_buf[1024], out_buf[1024];
 151     int rinf;
 152
 153     *adCnt = 0;
 154     *adFix = 0;
 155
 156     fpos_t fpt = 0;
 157     while (!feof(rfp)) {
 158         fgetpos(wfp, &fpt);
 159         rinf = (int)fread((void*)in_buf, 1, 1024, rfp);
 160         if(rinf < 0){
 161             return (-1);
 162         }
 163         memcpy((void*)out_buf, (void*)in_buf, 1024);
 164         rinf = (int)fwrite((void*)out_buf, 1, rinf, wfp);
 165         if(rinf < 0){
 166             return (-1);
 167         }
 168         (*adCnt)++;
 169         *adFix = rinf;
 170     }
 171
 172     fpt -= ((*adCnt)-1)*1024;
 173     fsetpos(wfp, &fpt);
 174     [self writeInt:wfp val:*adCnt];
 175     [self writeInt:wfp val:*adFix];
 176
 177     fpt = 0;
 178     fsetpos(rfp, &fpt);
 179     while (!feof(rfp)) {
 180         rinf = (int)fread((void*)in_buf, 1, 1024, rfp);
 181         if(rinf < 0){
 182             return (-1);
 183         }
 184         memcpy((void*)out_buf, (void*)in_buf, 1024);
 185         rinf = (int)fwrite((void*)out_buf, 1, rinf, wfp);
 186         if(rinf < 0){
 187             return (-1);
 188         }
 189     }
 190
 191     return(0);
 192 }
 193
 194 -(void)writeMapScript:(FILE*)fp{
 195
 196     [self writeInt:fp val:(int)sdd.MS.EGClight.endType1];
 197     [self writeInt:fp val:(int)sdd.MS.EGClight.endType2];
 198
 199     for(int i = 0;i < 64;i++)
 200         [self writeNSString:fp str:sdd.MS.EGClight.etValue1[i]];
 201     for(int i = 0;i < 64;i++)
 202         [self writeNSString:fp str:sdd.MS.EGClight.etValue2[i]];
 203
 204     [self writeInt:fp val:(int)sdd.MS.EGCdark.endType1];
 205     [self writeInt:fp val:(int)sdd.MS.EGCdark.endType2];
 206
 207     for(int i = 0;i < 64;i++)
 208         [self writeNSString:fp str:sdd.MS.EGCdark.etValue1[i]];
 209     for(int i = 0;i < 64;i++)
 210         [self writeNSString:fp str:sdd.MS.EGCdark.etValue2[i]];
 211
 212
 213     [self writeInt:fp val:(int)sdd.MS.playerSet1];
 214     [self writeInt:fp val:(int)sdd.MS.playerSet2];
 215     [self writeInt:fp val:(int)sdd.MS.battleSetMode];
 216     [self writeInt:fp val:(int)sdd.MS.employAllowedFlag];
 217     [self writeInt:fp val:(int)sdd.MS.buildAllowedFlag];
 218     [self writeInt:fp val:(int)sdd.MS.summonAllowedFlag];
 219
 220     [self writeInt:fp val:(int)sdd.MS.scenarioSetMode];
 221     [self writeInt:fp val:(int)sdd.MS.scenarioNumbCrnt];
 222     [self writeInt:fp val:(int)sdd.MS.scenarioNumbNext];
 223
 224     for(int i = 0;i < 4096;i++)
 225         [self writeInt:fp val:sdd.MS.guildListRegist[i]];
 226     [self writeInt:fp val:(int)sdd.MS.guildListRegistNum11];
 227     [self writeInt:fp val:(int)sdd.MS.guildListRegistNum12];
 228
 229     for(int i = 0;i < 4096;i++)
 230         [self writeInt:fp val:sdd.MS.guildListRegist2[i]];
 231     [self writeInt:fp val:(int)sdd.MS.guildListRegistNum21];
 232     [self writeInt:fp val:(int)sdd.MS.guildListRegistNum22];
 233
 234
 235     sdd.MS.SCRPTnameCnt = (int)[sdd.MS.SCRPTname count];
 236
 237     [self writeInt:fp val:(int)sdd.MS.SCRPTnameCnt];
 238     for(int i = 0;i < sdd.MS.SCRPTnameCnt;i++)
 239         [self writeNSString:fp str:sdd.MS.SCRPTname[i]];
 240
 241     MAPSCRIPTD *SMSDtop = sdd.MS.D;
 242
 243     sdd.MS.Dcnt = 0;
 244     while (sdd.MS.D) {
 245         sdd.MS.Dcnt++;
 246         sdd.MS.D = sdd.MS.D->next;
 247     }sdd.MS.D = SMSDtop;
 248     [self writeInt:fp val:(int)sdd.MS.Dcnt];
 249
 250     for (int i = 0;i < sdd.MS.Dcnt;i++) {
 251
 252         sdd.MS.D->SCRPTcnt = (int)[sdd.MS.D->SCRPT count];
 253         [self writeInt:fp val:(int)sdd.MS.D->SCRPTcnt];
 254         for(int j = 0;j < sdd.MS.D->SCRPTcnt;j++)
 255             [self writeNSString:fp str:sdd.MS.D->SCRPT[j]];
 256
 257         [self writeInt:fp val:(int)sdd.MS.D->endFlag];
 258         [self writeInt:fp val:(int)sdd.MS.D->index];
 259         [self writeInt:fp val:(int)sdd.MS.D->x];
 260         [self writeInt:fp val:(int)sdd.MS.D->y];
 261         [self writeInt:fp val:(int)sdd.MS.D->type];
 262         [self writeInt:fp val:(int)sdd.MS.D->ET1];
 263         [self writeInt:fp val:(int)sdd.MS.D->ET2];
 264         [self writeInt:fp val:(int)sdd.MS.D->ET3];
 265         [self writeInt:fp val:(int)sdd.MS.D->ET4];
 266         [self writeInt:fp val:(int)sdd.MS.D->ETtype];
 267         [self writeInt:fp val:(int)sdd.MS.D->onlyInitialDeley];
 268         [self writeInt:fp val:(int)sdd.MS.D->initialDeleyedFlag];
 269         [self writeInt:fp val:(int)sdd.MS.D->switch1f];
 270         [self writeInt:fp val:(int)sdd.MS.D->switch2f];
 271
 272         sdd.MS.D->switch1cnt = 0;
 273         if(sdd.MS.D->switch1)
 274         for(int j = 0;*(sdd.MS.D->switch1 + j) > 0;j++) {
 275             sdd.MS.D->switch1cnt++;
 276         }[self writeInt:fp val:(int)sdd.MS.D->switch1cnt];
 277
 278         sdd.MS.D->switch2cnt = 0;
 279         if(sdd.MS.D->switch2)
 280         for(int j = 0;*(sdd.MS.D->switch2 + j) > 0;j++) {
 281             sdd.MS.D->switch2cnt++;
 282         }[self writeInt:fp val:(int)sdd.MS.D->switch2cnt];
 283
 284         for(int j = 0;j < sdd.MS.D->switch1cnt;j++) {
 285             [self writeInt:fp val:(int)*(sdd.MS.D->switch1 + j)];
 286         }
 287
 288         for(int j = 0;j < sdd.MS.D->switch2cnt;j++) {
 289             [self writeInt:fp val:(int)*(sdd.MS.D->switch2 + j)];
 290         }
 291
 292
 293         MAPSCRIPT0 *SMSPtop = sdd.MS.D->P;
 294
 295         sdd.MS.D->Pcnt = 0;
 296         while (sdd.MS.D->P) {
 297             sdd.MS.D->Pcnt++;
 298             sdd.MS.D->P = sdd.MS.D->P->next;
 299         }sdd.MS.D->P = SMSPtop;
 300         [self writeInt:fp val:(int)sdd.MS.D->Pcnt];
 301
 302         for (int j = 0;j < sdd.MS.D->Pcnt;j++) {
 303
 304             [self writeInt:fp val:sdd.MS.D->P->endFlag];
 305             [self writeInt:fp val:sdd.MS.D->P->succeessfulFlag];
 306             [self writeInt:fp val:sdd.MS.D->P->indent];
 307             [self writeInt:fp val:sdd.MS.D->P->val];
 308             [self writeInt:fp val:sdd.MS.D->P->valCnt];
 309             [self writeInt:fp val:sdd.MS.D->P->timerMin];
 310             [self writeInt:fp val:sdd.MS.D->P->timerSec];
 311             [self writeInt:fp val:sdd.MS.D->P->timerEntire];
 312
 313             [self writeInt:fp val:sdd.MS.D->P->timerFlag];
 314             [self writeInt:fp val:sdd.MS.D->P->timerVisible];
 315             [self writeInt:fp val:sdd.MS.D->P->timerRun];
 316             [self writeInt:fp val:sdd.MS.D->P->timerMode];
 317             [self writeInt:fp val:sdd.MS.D->P->wait];
 318             [self writeInt:fp val:sdd.MS.D->P->titleBack];
 319
 320             [self writeNSString:fp str:sdd.MS.D->P->label];
 321             [self writeNSString:fp str:sdd.MS.D->P->labelJump];
 322             [self writeNSString:fp str:sdd.MS.D->P->memo];
 323
 324
 325
 326             sdd.MS.D->P->switch1cnt = 0;
 327             if(sdd.MS.D->P->switch1)
 328             for(int k = 0;*(sdd.MS.D->P->switch1 + k) > 0;k++) {
 329                 sdd.MS.D->P->switch1cnt++;
 330             }[self writeInt:fp val:(int)sdd.MS.D->P->switch1cnt];
 331
 332             sdd.MS.D->P->switch2cnt = 0;
 333             if(sdd.MS.D->P->switch2)
 334             for(int k = 0;*(sdd.MS.D->P->switch2 + k) > 0;k++) {
 335                 sdd.MS.D->P->switch2cnt++;
 336             }[self writeInt:fp val:(int)sdd.MS.D->P->switch2cnt];
 337
 338             for(int k = 0;k < sdd.MS.D->P->switch1cnt;k++) {
 339                 [self writeInt:fp val:(int)*(sdd.MS.D->P->switch1 + k)];
 340             }
 341
 342             for(int k = 0;k < sdd.MS.D->P->switch2cnt;k++) {
 343                 [self writeInt:fp val:(int)*(sdd.MS.D->P->switch2 + k)];
 344             }
 345
 346             [self writeMapScriptBGM:fp];
 347             [self writeMapScriptSE:fp];
 348             [self writeMapScriptSC:fp];
 349             [self writeMapScriptGAOV:fp];
 350
 351             [self writeInt:fp val:sdd.MS.D->P->type];
 352
 353             if(sdd.MS.D->P->type == 0)
 354             [self writeMapScript1:fp];
 355
 356             if(sdd.MS.D->P->type == 1){
 357             MAPSCRIPT2 *SMSP2top = sdd.MS.D->P->S2;
 358
 359             sdd.MS.D->P->S2cnt = 0;
 360             while (sdd.MS.D->P->S2) {
 361                 sdd.MS.D->P->S2cnt++;
 362                 sdd.MS.D->P->S2 = sdd.MS.D->P->S2->next;
 363             }sdd.MS.D->P->S2 = SMSP2top;
 364             [self writeInt:fp val:sdd.MS.D->P->S2cnt];
 365
 366
 367             for (int k = 0;k < sdd.MS.D->P->S2cnt;k++) {
 368                 [self writeMapScript2:fp];
 369                 sdd.MS.D->P->S2 = sdd.MS.D->P->S2->next;
 370             }sdd.MS.D->P->S2 = SMSP2top;
 371             }
 372
 373             if(sdd.MS.D->P->type == 22){
 374             MAPSCRIPT3 *SMSP3top = sdd.MS.D->P->S3;
 375
 376             sdd.MS.D->P->S3cnt = 0;
 377             while (sdd.MS.D->P->S3) {
 378                 sdd.MS.D->P->S3cnt++;
 379                 sdd.MS.D->P->S3 = sdd.MS.D->P->S3->next;
 380             }sdd.MS.D->P->S3 = SMSP3top;
 381             [self writeInt:fp val:sdd.MS.D->P->S3cnt];
 382
 383
 384             for (int k = 0;k < sdd.MS.D->P->S3cnt;k++) {
 385                 [self writeMapScript3:fp];
 386                 sdd.MS.D->P->S3 = sdd.MS.D->P->S3->next;
 387             }sdd.MS.D->P->S3 = SMSP3top;
 388             }
 389
 390
 391             if(sdd.MS.D->P->type == 6)
 392                 [self writeMapScript4:fp];
 393
 394             if(sdd.MS.D->P->type == 23){
 395             MAPSCRIPT5 *SMSP5top = sdd.MS.D->P->S5;
 396
 397             sdd.MS.D->P->S5cnt = 0;
 398             while (sdd.MS.D->P->S5) {
 399                 sdd.MS.D->P->S5cnt++;
 400                 sdd.MS.D->P->S5 = sdd.MS.D->P->S5->next;
 401             }sdd.MS.D->P->S5 = SMSP5top;
 402             [self writeInt:fp val:sdd.MS.D->P->S5cnt];
 403
 404             for (int k = 0;k < sdd.MS.D->P->S5cnt;k++) {
 405                 [self writeMapScript5:fp];
 406                 sdd.MS.D->P->S5 = sdd.MS.D->P->S5->next;
 407             }sdd.MS.D->P->S5 = SMSP5top;
 408
 409             }
 410
 411             if(sdd.MS.D->P->type == 10)
 412                 [self writeMapScript6:fp];
 413
 414
 415
 416             sdd.MS.D->P = sdd.MS.D->P->next;
 417         }sdd.MS.D->P = SMSPtop;
 418
 419
 420         sdd.MS.D = sdd.MS.D->next;
 421     }sdd.MS.D = SMSDtop;
 422
 423 }
 424
 425 -(void)writeMapScript1:(FILE*)fp{
 426
 427     if(!sdd.MS.D->P->S1.name)
 428         sdd.MS.D->P->S1.name = [@"" retain];
 429     if(!sdd.MS.D->P->S1.str)
 430         sdd.MS.D->P->S1.str = [@"" retain];
 431     if(!sdd.MS.D->P->S1.iName)
 432         sdd.MS.D->P->S1.iName = [@"" retain];
 433     if(!sdd.MS.D->P->S1.nameID)
 434         sdd.MS.D->P->S1.nameID = [@"" retain];
 435
 436     [self writeNSString:fp str:sdd.MS.D->P->S1.name];
 437     [self writeNSString:fp str:sdd.MS.D->P->S1.str];
 438     [self writeNSString:fp str:sdd.MS.D->P->S1.iName];
 439     [self writeNSString:fp str:sdd.MS.D->P->S1.nameID];
 440
 441     /*
 442      NSString *name;
 443      NSString *str;
 444      //NSImage *img;
 445      NSString *iName;
 446      NSString *nameID;
 447      */
 448 }
 449
 450 -(void)writeMapScript2:(FILE*)fp{
 451
 452     [self writeNSString:fp str:sdd.MS.D->P->S2->selection];
 453     [self writeNSString:fp str:sdd.MS.D->P->S2->labelJump];
 454
 455     /*
 456      //struct _MAPSCRIPT2 *next;
 457
 458      NSString *selection;
 459      NSString *labelJump;
 460      */
 461 }
 462
 463 -(void)writeMapScript3:(FILE*)fp{
 464
 465     [self writeInt:fp val:sdd.MS.D->P->S3->x];
 466     [self writeInt:fp val:sdd.MS.D->P->S3->y];
 467     [self writeInt:fp val:sdd.MS.D->P->S3->flag];
 468
 469     [self writeInt:fp val:sdd.MS.D->P->S3->type];
 470     [self writeInt:fp val:sdd.MS.D->P->S3->team];
 471
 472     [self writeInt:fp val:sdd.MS.D->P->S3->unitNum];
 473     [self writeInt:fp val:sdd.MS.D->P->S3->loadInt];
 474
 475     /*
 476      //struct _MAPSCRIPT3 *next;
 477
 478      int x;
 479      int y;
 480      bool flag;
 481
 482      int type;
 483      int team;
 484
 485      //UNITCHIP U;
 486      int unitNum;
 487
 488      int loadInt;
 489      */
 490 }
 491
 492 -(void)writeMapScript4:(FILE*)fp{
 493
 494     [self writeInt:fp val:sdd.MS.D->P->S4.lagFixFlag];
 495     [self writeNSString:fp str:sdd.MS.D->P->S4.COMPrabel];
 496     [self writeNSString:fp str:sdd.MS.D->P->S4.FAILrabel];
 497
 498     [self writeInt:fp val:sdd.MS.D->P->S4.suicchiFlag];
 499
 500     sdd.MS.D->P->S4.suicchiCnt = 0;
 501     if(sdd.MS.D->P->S4.suicchi)
 502     for(int l = 0;*(sdd.MS.D->P->S4.suicchi + l) > 0;l++) {
 503         sdd.MS.D->P->S4.suicchiCnt++;
 504     }[self writeInt:fp val:(int)sdd.MS.D->P->S4.suicchiCnt];
 505
 506     for(int l = 0;l < sdd.MS.D->P->S4.suicchiCnt;l++) {
 507         [self writeInt:fp val:(int)*(sdd.MS.D->P->S4.suicchi + l)];
 508     }
 509
 510     [self writeInt:fp val:sdd.MS.D->P->S4.suicchiONOFF];
 511
 512
 513     [self writeInt:fp val:sdd.MS.D->P->S4.hensuFlag];
 514     [self writeInt:fp val:sdd.MS.D->P->S4.hensu1];
 515     [self writeInt:fp val:sdd.MS.D->P->S4.teisuFlag];
 516     [self writeInt:fp val:sdd.MS.D->P->S4.teisuValue];
 517     [self writeInt:fp val:sdd.MS.D->P->S4.hensu2flag];
 518     [self writeInt:fp val:sdd.MS.D->P->S4.hensu2];
 519     [self writeInt:fp val:sdd.MS.D->P->S4.hensuType];
 520
 521     [self writeInt:fp val:sdd.MS.D->P->S4.timerFlag];
 522     [self writeInt:fp val:sdd.MS.D->P->S4.timerMin];
 523     [self writeInt:fp val:sdd.MS.D->P->S4.timerSec];
 524     [self writeInt:fp val:sdd.MS.D->P->S4.timerType];
 525
 526     [self writeInt:fp val:sdd.MS.D->P->S4.unitNumFlag];
 527     [self writeInt:fp val:sdd.MS.D->P->S4.team];
 528     [self writeInt:fp val:sdd.MS.D->P->S4.unitNum];
 529     [self writeInt:fp val:sdd.MS.D->P->S4.unitType];
 530     [self writeInt:fp val:sdd.MS.D->P->S4.unitTypeFlag];
 531
 532
 533     UNIT2 *subjTop = sdd.MS.D->P->S4.subj;
 534
 535     sdd.MS.D->P->S4.subjCnt = 0;
 536     while (sdd.MS.D->P->S4.subj) {
 537         sdd.MS.D->P->S4.subjCnt++;
 538         sdd.MS.D->P->S4.subj = sdd.MS.D->P->S4.subj->next;
 539     }sdd.MS.D->P->S4.subj = subjTop;
 540     [self writeInt:fp val:sdd.MS.D->P->S4.subjCnt];
 541
 542     for (int k = 0;k < sdd.MS.D->P->S4.subjCnt;k++) {
 543         [self writeMapScript4subj:fp];
 544         sdd.MS.D->P->S4.subj = sdd.MS.D->P->S4.subj->next;
 545     }sdd.MS.D->P->S4.subj = subjTop;
 546
 547
 548
 549
 550     [self writeInt:fp val:sdd.MS.D->P->S4.placeFlag];
 551     PLACEMENT *waypTop = sdd.MS.D->P->S4.wayp;
 552
 553     sdd.MS.D->P->S4.waypCnt = 0;
 554     while (sdd.MS.D->P->S4.wayp) {
 555         sdd.MS.D->P->S4.waypCnt++;
 556         sdd.MS.D->P->S4.wayp = sdd.MS.D->P->S4.wayp->next;
 557     }sdd.MS.D->P->S4.wayp = waypTop;
 558     [self writeInt:fp val:sdd.MS.D->P->S4.waypCnt];
 559
 560     for (int k = 0;k < sdd.MS.D->P->S4.waypCnt;k++) {
 561         [self writeMapScript4wayp:fp];
 562         sdd.MS.D->P->S4.wayp = sdd.MS.D->P->S4.wayp->next;
 563     }sdd.MS.D->P->S4.wayp = waypTop;
 564
 565     [self writeInt:fp val:sdd.MS.D->P->S4.unitCMDflag];
 566     [self writeInt:fp val:sdd.MS.D->P->S4.unitCMD];
 567
 568
 569     [self writeInt:fp val:sdd.MS.D->P->S4.objeFlag];
 570     UNIT2 *objeTop = sdd.MS.D->P->S4.obje;
 571
 572     sdd.MS.D->P->S4.objeCnt = 0;
 573     while (sdd.MS.D->P->S4.obje) {
 574         sdd.MS.D->P->S4.objeCnt++;
 575         sdd.MS.D->P->S4.obje = sdd.MS.D->P->S4.obje->next;
 576     }sdd.MS.D->P->S4.obje = objeTop;
 577     [self writeInt:fp val:sdd.MS.D->P->S4.objeCnt];
 578
 579     for (int k = 0;k < sdd.MS.D->P->S4.objeCnt;k++) {
 580         [self writeMapScript4obje:fp];
 581         sdd.MS.D->P->S4.obje = sdd.MS.D->P->S4.obje->next;
 582     }sdd.MS.D->P->S4.obje = objeTop;
 583
 584     [self writeInt:fp val:sdd.MS.D->P->S4.objeRange];
 585
 586
 587
 588     [self writeInt:fp val:sdd.MS.D->P->S4.buildFlag];
 589     BUILD2 *buildTop = sdd.MS.D->P->S4.build;
 590
 591     sdd.MS.D->P->S4.buildCnt = 0;
 592     while (sdd.MS.D->P->S4.build) {
 593         sdd.MS.D->P->S4.buildCnt++;
 594         sdd.MS.D->P->S4.build = sdd.MS.D->P->S4.build->next;
 595     }sdd.MS.D->P->S4.build = buildTop;
 596     [self writeInt:fp val:sdd.MS.D->P->S4.buildCnt];
 597
 598     for (int k = 0;k < sdd.MS.D->P->S4.buildCnt;k++) {
 599         [self writeMapScript4build:fp];
 600         sdd.MS.D->P->S4.build = sdd.MS.D->P->S4.build->next;
 601     }sdd.MS.D->P->S4.build = buildTop;
 602
 603
 604 }
 605
 606 -(void)writeMapScript4subj:(FILE*)fp{
 607
 608     [self writeInt:fp val:sdd.MS.D->P->S4.subj->team];
 609     [self writeInt:fp val:sdd.MS.D->P->S4.subj->x];
 610     [self writeInt:fp val:sdd.MS.D->P->S4.subj->y];
 611
 612     /*
 613      //struct _UNIT2 *next;
 614      //UNITCHIP C;
 615
 616      int team;
 617      int x;
 618      int y;
 619      */
 620 }
 621
 622 -(void)writeMapScript4wayp:(FILE*)fp{
 623
 624     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->type];
 625     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->x];
 626     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->y];
 627     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->z];
 628     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->x2];
 629     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->y2];
 630
 631     /*
 632      //struct _PLACEMENT *next;
 633
 634      int type;
 635      int x;
 636      int y;
 637      int z;
 638      int x2;
 639      int y2;
 640      */
 641 }
 642
 643 -(void)writeMapScript4obje:(FILE*)fp{
 644
 645     [self writeInt:fp val:sdd.MS.D->P->S4.obje->team];
 646     [self writeInt:fp val:sdd.MS.D->P->S4.obje->x];
 647     [self writeInt:fp val:sdd.MS.D->P->S4.obje->y];
 648
 649     /*
 650      //struct _UNIT2 *next;
 651      //UNITCHIP C;
 652
 653      int team;
 654      int x;
 655      int y;
 656      */
 657 }
 658
 659 -(void)writeMapScript4build:(FILE*)fp{
 660
 661     [self writeInt:fp val:sdd.MS.D->P->S4.build->team];
 662     [self writeInt:fp val:sdd.MS.D->P->S4.build->x];
 663     [self writeInt:fp val:sdd.MS.D->P->S4.build->y];
 664
 665     /*
 666      //struct _BUILD2 *next;
 667      //struct _BUILDCHIP *C;
 668
 669      int team;
 670      int x;
 671      int y;
 672      */
 673 }
 674
 675 -(void)writeMapScript5:(FILE*)fp{
 676
 677     [self writeInt:fp val:sdd.MS.D->P->S5->x];
 678     [self writeInt:fp val:sdd.MS.D->P->S5->y];
 679     [self writeInt:fp val:sdd.MS.D->P->S5->type];
 680     [self writeInt:fp val:sdd.MS.D->P->S5->team];
 681     [self writeInt:fp val:sdd.MS.D->P->S5->unitNum];
 682     [self writeInt:fp val:sdd.MS.D->P->S5->saveInt];
 683
 684     /*
 685      //struct _MAPSCRIPT5 *next;
 686
 687      int x;
 688      int y;
 689
 690      int type;
 691      int team;
 692
 693      //UNITCHIP U;
 694      int unitNum;
 695
 696      int saveInt;
 697      */
 698 }
 699
 700
 701 -(void)writeMapScript6:(FILE*)fp{
 702
 703     [self writeInt:fp val:sdd.MS.D->P->S6.team];
 704
 705     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupply];
 706     [self writeInt:fp val:sdd.MS.D->P->S6.RCfood];
 707     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoney];
 708
 709     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyAdd];
 710     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodAdd];
 711     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyAdd];
 712
 713     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyValue];
 714     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodValue];
 715     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyValue];
 716
 717     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplySelect];
 718     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodSelect];
 719     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneySelect];
 720
 721     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyS];
 722     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodS];
 723     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyS];
 724
 725     /*
 726      int team;
 727
 728      bool RCsupply;
 729      bool RCfood;
 730      bool RCmoney;
 731
 732      bool RCsupplyAdd;
 733      bool RCfoodAdd;
 734      bool RCmoneyAdd;
 735
 736      int RCsupplyValue;
 737      int RCfoodValue;
 738      int RCmoneyValue;
 739
 740      int RCsupplySelect;
 741      int RCfoodSelect;
 742      int RCmoneySelect;
 743
 744      bool RCsupplyS;
 745      bool RCfoodS;
 746      bool RCmoneyS;
 747      */
 748 }
 749
 750 -(void)writeMapScriptBGM:(FILE*)fp{
 751
 752     [self writeNSString:fp str:sdd.MS.D->P->BGM.name];
 753     [self writeNSString:fp str:sdd.MS.D->P->BGM.fName];
 754
 755     /*
 756     NSString *name;
 757     NSString *fName;
 758     //NSSound *snd;
 759      */
 760 }
 761
 762 -(void)writeMapScriptSE:(FILE*)fp{
 763
 764     [self writeNSString:fp str:sdd.MS.D->P->SE.name];
 765     [self writeNSString:fp str:sdd.MS.D->P->SE.fName];
 766
 767     /*
 768      NSString *name;
 769      NSString *fName;
 770      //NSSound *snd;
 771      */
 772 }
 773
 774 -(void)writeMapScriptSC:(FILE*)fp{
 775
 776     [self writeInt:fp val:sdd.MS.D->P->sc.scFlag];
 777     [self writeInt:fp val:sdd.MS.D->P->sc.edcdFlag];
 778
 779     /*
 780      bool scFlag;
 781      bool edcdFlag;
 782      */
 783 }
 784
 785 -(void)writeMapScriptGAOV:(FILE*)fp{
 786
 787     [self writeNSString:fp str:sdd.MS.D->P->gaov.fNname];
 788     [self writeInt:fp val:sdd.MS.D->P->gaov.gaovFlag];
 789     [self writeInt:fp val:sdd.MS.D->P->gaov.edcdFlag];
 790
 791     /*
 792      NSString *fNname;
 793      //NSImage *img;
 794      bool gaovFlag;
 795      bool edcdFlag;
 796      */
 797 }
 798
 799 -(int)readInt:(FILE*)fp{
 800     int counter;
 801     int result = 0;
 802     int shiftLen = 0;
 803
 804     for(counter= INT_MAX;counter > 0;counter >>= 8){
 805         unsigned char nowData = 0;
 806         fread(&nowData, sizeof(unsigned char), 1, fp);
 807         result |= (int)nowData << shiftLen;
 808         shiftLen += 8;
 809     }
 810
 811     return result;
 812 }
 813
 814 -(NSString*)readNSString:(FILE*)fp strOut:(NSString*)strOut{
 815     int length = [self readInt:fp];
 816     char strOutcc[1024];
 817     fread(strOutcc, sizeof(strOut), length, fp);
 818     strOut = [[NSString stringWithUTF8String:strOutcc] retain];
 819
 820     return strOut;
 821 }
 822
 823 -(NSImage*)readNSImage:(FILE*)fp imgOut:(NSImage*)imgOut dcnt:(int)dcnt dfix:(int)dfix{
 824     unsigned char idat[1024];
 825     int size = 0;
 826
 827     NSMutableData *binaryData = [NSMutableData dataWithCapacity:sizeof(idat)];
 828
 829     fpos_t fpt = 0;
 830     for(int i = 0;i < dcnt;i++){
 831         size += fread(idat, 1, 1024, fp);
 832
 833         if(dcnt-1 == i){
 834             fpt += dfix;
 835             fsetpos(fp, &fpt);
 836         }
 837
 838         fgetpos(fp, &fpt);
 839
 840         NSMutableData* data = [NSMutableData dataWithBytes:idat length:sizeof(unsigned char)*1024];
 841         [binaryData appendData:data];
 842     }
 843
 844
 845     imgOut = [[[NSImage alloc] initWithData:binaryData] retain];
 846
 847     return imgOut;
 848 }
 849
 850 -(void)readBiuldD:(FILE*)fp row:(int)r{
 851
 852     sdd2[datRow].dB[r].number = (int)[self readInt:fp];
 853     sdd2[datRow].dB[r].team = (int)[self readInt:fp];
 854     sdd2[datRow].dB[r].chipNumber = (int)[self readInt:fp];
 855     sdd2[datRow].dB[r].makeLv = (int)[self readInt:fp];
 856
 857     sdd2[datRow].dB[r].x = (int)[self readInt:fp];
 858     sdd2[datRow].dB[r].y = (int)[self readInt:fp];
 859     sdd2[datRow].dB[r].z = (int)[self readInt:fp];
 860
 861     sdd2[datRow].dB[r].dead = (int)[self readInt:fp];
 862     /*
 863     sdd2[datRow].dB[r].imgAdCnt = (int)[self readInt:fp];
 864     sdd2[datRow].dB[r].imgAdFix = (int)[self readInt:fp];
 865     sdd2[datRow].dB[r].img = [self readNSImage:fp imgOut:sdd2[datRow].dB[r].img dcnt:sdd2[datRow].dB[r].imgAdCnt dfix:sdd2[datRow].dB[r].imgAdFix];
 866     */
 867     [self readBuildChipD:fp val:&sdd2[datRow].dB[r].C];
 868 }
 869
 870 -(void)readBuildChipD:(FILE*)fp val:(BUILDCHIPD*)val{
 871
 872     val->chipNumb = (int)[self readInt:fp];
 873     val->name = [[self readNSString:fp strOut:val->name] retain];
 874     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 875
 876     fread(&val->S_C, sizeof(BSTATUS), 1, fp);
 877
 878     //NSLog(@"awww man...");
 879 }
 880
 881
 882
 883 -(void)readUnitD:(FILE*)fp row:(int)r{
 884
 885     sdd2[datRow].dU[r].CPU = (int)[self readInt:fp];
 886     sdd2[datRow].dU[r].number = (int)[self readInt:fp];
 887     sdd2[datRow].dU[r].team = (int)[self readInt:fp];
 888     sdd2[datRow].dU[r].chipNumber = (int)[self readInt:fp];
 889     sdd2[datRow].dU[r].chipNumberL = (int)[self readInt:fp];
 890
 891     sdd2[datRow].dU[r].x = (int)[self readInt:fp];
 892     sdd2[datRow].dU[r].y = (int)[self readInt:fp];
 893     sdd2[datRow].dU[r].z = (int)[self readInt:fp];
 894
 895     sdd2[datRow].dU[r].ix = (int)[self readInt:fp];
 896     sdd2[datRow].dU[r].iy = (int)[self readInt:fp];
 897     sdd2[datRow].dU[r].iz = (int)[self readInt:fp];
 898
 899     sdd2[datRow].dU[r].dead = (int)[self readInt:fp];
 900
 901     sdd2[datRow].dU[r].loadChipFlag = (int)[self readInt:fp];
 902
 903     sdd2[datRow].dU[r].unControlable = (int)[self readInt:fp];
 904     sdd2[datRow].dU[r].joinArmyFromNext = (int)[self readInt:fp];
 905     sdd2[datRow].dU[r].persuasion = (int)[self readInt:fp];
 906
 907     sdd2[datRow].dU[r].targType1L = (int)[self readInt:fp];
 908     sdd2[datRow].dU[r].targType2L = (int)[self readInt:fp];
 909     sdd2[datRow].dU[r].targType1D = (int)[self readInt:fp];
 910     sdd2[datRow].dU[r].targType2D = (int)[self readInt:fp];
 911
 912     sdd2[datRow].dU[r].army = [[self readNSString:fp strOut:sdd2[datRow].dU[r].army] retain];
 913
 914     /*
 915     sdd2[datRow].dU[r].imgAdCnt = (int)[self readInt:fp];
 916     sdd2[datRow].dU[r].imgAdFix = (int)[self readInt:fp];
 917     sdd2[datRow].dU[r].img = [self readNSImage:fp imgOut:sdd2[datRow].dU[r].img dcnt:sdd2[datRow].dU[r].imgAdCnt dfix:sdd2[datRow].dU[r].imgAdFix];
 918     */
 919
 920     [self readUnitChipD:fp val:&sdd2[datRow].dU[r].C];
 921     [self readUnitChipLD:fp val:&sdd2[datRow].dU[r].CL];
 922
 923 }
 924
 925 -(void)readUnitChipD:(FILE*)fp val:(UNITCHIPD*)val{
 926
 927     val->chipNumb = (int)[self readInt:fp];
 928     val->name = [[self readNSString:fp strOut:val->name] retain];
 929     val->nameNick = [[self readNSString:fp strOut:val->nameNick] retain];
 930     val->nameClass = [[self readNSString:fp strOut:val->nameClass] retain];
 931     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 932
 933
 934
 935     fread(&val->R_C, sizeof(RESIST), 1, fp);
 936     fread(&val->S_C, sizeof(STATUS), 1, fp);
 937
 938     //NSLog(@"creepy jude...");
 939 }
 940
 941 -(void)readUnitChipLD:(FILE*)fp val:(LOADCHIPD*)val{
 942
 943     val->chipNumb = (int)[self readInt:fp];
 944     val->name = [[self readNSString:fp strOut:val->name] retain];
 945     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 946
 947
 948
 949     fread(&val->R_C, sizeof(RESIST), 1, fp);
 950     fread(&val->S_C, sizeof(STATUS2), 1, fp);
 951
 952     //NSLog(@"creepy jude...2");
 953 }
 954
 955 -(void)readMapScript:(FILE*)fp{
 956
 957     sdd2[datRow].MS.EGClight.endType1 = (int)[self readInt:fp];
 958     sdd2[datRow].MS.EGClight.endType2 = (int)[self readInt:fp];
 959     for(int i = 0;i < 64;i++)
 960         sdd2[datRow].MS.EGClight.etValue1[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGClight.etValue1[i]] retain];
 961     for(int i = 0;i < 64;i++)
 962         sdd2[datRow].MS.EGClight.etValue2[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGClight.etValue2[i]] retain];
 963
 964     sdd2[datRow].MS.EGCdark.endType1 = (int)[self readInt:fp];
 965     sdd2[datRow].MS.EGCdark.endType2 = (int)[self readInt:fp];
 966     for(int i = 0;i < 64;i++)
 967         sdd2[datRow].MS.EGCdark.etValue1[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGCdark.etValue1[i]] retain];
 968     for(int i = 0;i < 64;i++)
 969         sdd2[datRow].MS.EGCdark.etValue2[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGCdark.etValue2[i]] retain];
 970
 971     sdd2[datRow].MS.playerSet1 = (int)[self readInt:fp];
 972     sdd2[datRow].MS.playerSet2 = (int)[self readInt:fp];
 973     sdd2[datRow].MS.battleSetMode = (int)[self readInt:fp];
 974     sdd2[datRow].MS.employAllowedFlag = (int)[self readInt:fp];
 975     sdd2[datRow].MS.buildAllowedFlag = (int)[self readInt:fp];
 976     sdd2[datRow].MS.summonAllowedFlag = (int)[self readInt:fp];
 977
 978     sdd2[datRow].MS.scenarioSetMode = (int)[self readInt:fp];
 979     sdd2[datRow].MS.scenarioNumbCrnt = (int)[self readInt:fp];
 980     sdd2[datRow].MS.scenarioNumbNext = (int)[self readInt:fp];
 981
 982     for(int i = 0;i < 4096;i++)
 983         sdd2[datRow].MS.guildListRegist[i] = (int)[self readInt:fp];
 984     sdd2[datRow].MS.guildListRegistNum11 = (int)[self readInt:fp];
 985     sdd2[datRow].MS.guildListRegistNum12 = (int)[self readInt:fp];
 986
 987     for(int i = 0;i < 4096;i++)
 988         sdd2[datRow].MS.guildListRegist2[i] = (int)[self readInt:fp];
 989     sdd2[datRow].MS.guildListRegistNum21 = (int)[self readInt:fp];
 990     sdd2[datRow].MS.guildListRegistNum22 = (int)[self readInt:fp];
 991
 992
 993     sdd2[datRow].MS.SCRPTnameCnt = (int)[self readInt:fp];
 994     sdd2[datRow].MS.SCRPTname = [NSMutableArray new];
 995     for(int j = 0;j < sdd2[datRow].MS.SCRPTnameCnt;j++)
 996         [sdd2[datRow].MS.SCRPTname addObject:@""];
 997     for(int i = 0;i < sdd2[datRow].MS.SCRPTnameCnt;i++)
 998         sdd2[datRow].MS.SCRPTname[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.SCRPTname[i]] retain];
 999
1000
1001     MAPSCRIPTD *SMSDtop = sdd2[datRow].MS.D;
1002
1003     sdd2[datRow].MS.Dcnt = (int)[self readInt:fp];
1004
1005     for (int i = 0;i < sdd2[datRow].MS.Dcnt;i++) {
1006
1007         if(i == 0){
1008             sdd2[datRow].MS.D = calloc(1, sizeof(MAPSCRIPTD));
1009             if(i + 1 < sdd2[datRow].MS.Dcnt)
1010                 sdd2[datRow].MS.D->next = calloc(1, sizeof(MAPSCRIPTD));
1011             SMSDtop = sdd2[datRow].MS.D;
1012
1013         }else if(i + 1 < sdd2[datRow].MS.Dcnt)
1014             sdd2[datRow].MS.D->next = calloc(1, sizeof(MAPSCRIPTD));
1015
1016         sdd2[datRow].MS.D->SCRPTcnt = (int)[self readInt:fp];
1017         sdd2[datRow].MS.D->SCRPT = [NSMutableArray new];
1018         for(int j = 0;j < sdd2[datRow].MS.D->SCRPTcnt;j++)
1019             [sdd2[datRow].MS.D->SCRPT addObject:@""];
1020         for(int j = 0;j < sdd2[datRow].MS.D->SCRPTcnt;j++)
1021             sdd2[datRow].MS.D->SCRPT[j] = [[self readNSString:fp strOut:sdd2[datRow].MS.D->SCRPT[j]] retain];
1022
1023
1024         sdd2[datRow].MS.D->endFlag = (int)[self readInt:fp];
1025         sdd2[datRow].MS.D->index = (int)[self readInt:fp];
1026         sdd2[datRow].MS.D->x = (int)[self readInt:fp];
1027         sdd2[datRow].MS.D->y = (int)[self readInt:fp];
1028         sdd2[datRow].MS.D->type = (int)[self readInt:fp];
1029         sdd2[datRow].MS.D->ET1 = (int)[self readInt:fp];
1030         sdd2[datRow].MS.D->ET2 = (int)[self readInt:fp];
1031         sdd2[datRow].MS.D->ET3 = (int)[self readInt:fp];
1032         sdd2[datRow].MS.D->ET4 = (int)[self readInt:fp];
1033         sdd2[datRow].MS.D->ETtype = (int)[self readInt:fp];
1034         sdd2[datRow].MS.D->onlyInitialDeley = (int)[self readInt:fp];
1035         sdd2[datRow].MS.D->initialDeleyedFlag = (int)[self readInt:fp];
1036         sdd2[datRow].MS.D->switch1f = (int)[self readInt:fp];
1037         sdd2[datRow].MS.D->switch2f = (int)[self readInt:fp];
1038
1039         sdd2[datRow].MS.D->switch1cnt = (int)[self readInt:fp];
1040         sdd2[datRow].MS.D->switch2cnt = (int)[self readInt:fp];
1041
1042         if(sdd2[datRow].MS.D->switch1cnt > 0)
1043             sdd2[datRow].MS.D->switch1 = calloc(sdd2[datRow].MS.D->switch1cnt, sizeof(int));
1044         for(int j = 0;j < sdd2[datRow].MS.D->switch1cnt;j++) {
1045             *(sdd2[datRow].MS.D->switch1 + j) = (int)[self readInt:fp];
1046         }
1047         if(sdd2[datRow].MS.D->switch2cnt > 0)
1048             sdd2[datRow].MS.D->switch2 = calloc(sdd2[datRow].MS.D->switch2cnt, sizeof(int));
1049         for(int j = 0;j < sdd2[datRow].MS.D->switch2cnt;j++) {
1050             *(sdd2[datRow].MS.D->switch2 + j) = (int)[self readInt:fp];
1051         }
1052
1053
1054         MAPSCRIPT0 *SMSPtop = sdd2[datRow].MS.D->P;
1055
1056         sdd2[datRow].MS.D->Pcnt = (int)[self readInt:fp];
1057
1058         for (int j = 0;j < sdd2[datRow].MS.D->Pcnt;j++) {
1059
1060             if(j == 0){
1061                 sdd2[datRow].MS.D->P = calloc(1, sizeof(MAPSCRIPT0));
1062                 if(j + 1 < sdd2[datRow].MS.D->Pcnt)
1063                     sdd2[datRow].MS.D->P->next = calloc(1, sizeof(MAPSCRIPT0));
1064                 SMSPtop = sdd2[datRow].MS.D->P;
1065             }else if(j + 1 < sdd2[datRow].MS.D->Pcnt)
1066                 sdd2[datRow].MS.D->P->next = calloc(1, sizeof(MAPSCRIPT0));
1067
1068             sdd2[datRow].MS.D->P->endFlag = (int)[self readInt:fp];
1069             sdd2[datRow].MS.D->P->succeessfulFlag = (int)[self readInt:fp];
1070             sdd2[datRow].MS.D->P->indent = (int)[self readInt:fp];
1071             sdd2[datRow].MS.D->P->val = (int)[self readInt:fp];
1072             sdd2[datRow].MS.D->P->valCnt = (int)[self readInt:fp];
1073             sdd2[datRow].MS.D->P->timerMin = (int)[self readInt:fp];
1074             sdd2[datRow].MS.D->P->timerSec = (int)[self readInt:fp];
1075             sdd2[datRow].MS.D->P->timerEntire = (int)[self readInt:fp];
1076
1077             sdd2[datRow].MS.D->P->timerFlag = (int)[self readInt:fp];
1078             sdd2[datRow].MS.D->P->timerVisible = (int)[self readInt:fp];
1079             sdd2[datRow].MS.D->P->timerRun = (int)[self readInt:fp];
1080             sdd2[datRow].MS.D->P->timerMode = (int)[self readInt:fp];
1081             sdd2[datRow].MS.D->P->wait = (int)[self readInt:fp];
1082             sdd2[datRow].MS.D->P->titleBack = (int)[self readInt:fp];
1083
1084             sdd2[datRow].MS.D->P->label = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->label] retain];
1085             sdd2[datRow].MS.D->P->labelJump = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->labelJump] retain];
1086             sdd2[datRow].MS.D->P->memo = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->memo] retain];
1087
1088             sdd2[datRow].MS.D->P->switch1cnt = (int)[self readInt:fp];
1089             sdd2[datRow].MS.D->P->switch2cnt = (int)[self readInt:fp];
1090
1091             if(sdd2[datRow].MS.D->P->switch1cnt > 0)
1092                 sdd2[datRow].MS.D->P->switch1 = calloc(sdd2[datRow].MS.D->P->switch1cnt, sizeof(int));
1093             for(int k = 0;k < sdd2[datRow].MS.D->P->switch1cnt;k++) {
1094                 *(sdd2[datRow].MS.D->P->switch1 + k) = (int)[self readInt:fp];
1095             }
1096
1097             if(sdd2[datRow].MS.D->P->switch2cnt > 0)
1098                 sdd2[datRow].MS.D->P->switch2 = calloc(sdd2[datRow].MS.D->P->switch2cnt, sizeof(int));
1099             for(int k = 0;k < sdd2[datRow].MS.D->P->switch2cnt;k++) {
1100                 *(sdd2[datRow].MS.D->P->switch2 + k) = (int)[self readInt:fp];
1101             }
1102
1103             [self readMapScriptBGM:fp];
1104             [self readMapScriptSE:fp];
1105             [self readMapScriptSC:fp];
1106             [self readMapScriptGAOV:fp];
1107
1108             sdd2[datRow].MS.D->P->type = (int)[self readInt:fp];
1109
1110             //なぜかゴミ文字列が入ったから処置
1111             if(sdd2[datRow].MS.D->P->type != 7)
1112                 sdd2[datRow].MS.D->P->label = NULL;
1113             if(sdd2[datRow].MS.D->P->type != 8)
1114                 sdd2[datRow].MS.D->P->labelJump = NULL;
1115             if(sdd2[datRow].MS.D->P->type != 9)
1116                 sdd2[datRow].MS.D->P->memo = NULL;
1117
1118             if(sdd2[datRow].MS.D->P->type == 0)
1119                 [self readMapScript1:fp];
1120
1121             if(sdd2[datRow].MS.D->P->type == 1){
1122             MAPSCRIPT2 *SMSP2top = sdd2[datRow].MS.D->P->S2;
1123
1124             sdd2[datRow].MS.D->P->S2cnt = (int)[self readInt:fp];
1125
1126             for (int k = 0;k < sdd2[datRow].MS.D->P->S2cnt;k++) {
1127                 if(k == 0){
1128                     sdd2[datRow].MS.D->P->S2 = calloc(1, sizeof(MAPSCRIPT2));
1129                     if(k + 1 < sdd2[datRow].MS.D->P->S2cnt)
1130                         sdd2[datRow].MS.D->P->S2->next = calloc(1, sizeof(MAPSCRIPT2));
1131                     SMSP2top = sdd2[datRow].MS.D->P->S2;
1132                 }else if(k + 1 < sdd2[datRow].MS.D->P->S2cnt)
1133                     sdd2[datRow].MS.D->P->S2->next = calloc(1, sizeof(MAPSCRIPT2));
1134                 [self readMapScript2:fp];
1135                 sdd2[datRow].MS.D->P->S2 = sdd2[datRow].MS.D->P->S2->next;
1136             }
1137             if(sdd2[datRow].MS.D->P->S2)
1138                 sdd2[datRow].MS.D->P->S2->next = NULL;
1139             sdd2[datRow].MS.D->P->S2 = SMSP2top;
1140             }
1141
1142
1143             if(sdd2[datRow].MS.D->P->type == 22){
1144             MAPSCRIPT3 *SMSP3top = sdd2[datRow].MS.D->P->S3;
1145
1146             sdd2[datRow].MS.D->P->S3cnt = (int)[self readInt:fp];
1147
1148             for (int k = 0;k < sdd2[datRow].MS.D->P->S3cnt;k++) {
1149                 if(k == 0){
1150                     sdd2[datRow].MS.D->P->S3 = calloc(1, sizeof(MAPSCRIPT3));
1151                     if(k + 1 < sdd2[datRow].MS.D->P->S3cnt)
1152                         sdd2[datRow].MS.D->P->S3->next = calloc(1, sizeof(MAPSCRIPT3));
1153                     SMSP3top = sdd2[datRow].MS.D->P->S3;
1154                 }else if(k + 1 < sdd2[datRow].MS.D->P->S3cnt)
1155                     sdd2[datRow].MS.D->P->S3->next = calloc(1, sizeof(MAPSCRIPT3));
1156                 [self readMapScript3:fp];
1157                 sdd2[datRow].MS.D->P->S3 = sdd2[datRow].MS.D->P->S3->next;
1158             }sdd2[datRow].MS.D->P->S3 = SMSP3top;
1159             }
1160             if(sdd2[datRow].MS.D->P->type == 6)
1161                 [self readMapScript4:fp];
1162
1163             if(sdd2[datRow].MS.D->P->type == 23){
1164             MAPSCRIPT5 *SMSP5top = sdd2[datRow].MS.D->P->S5;
1165
1166             sdd2[datRow].MS.D->P->S5cnt = (int)[self readInt:fp];
1167
1168             for (int k = 0;k < sdd2[datRow].MS.D->P->S5cnt;k++) {
1169                 if(k == 0){
1170                     sdd2[datRow].MS.D->P->S5 = calloc(1, sizeof(MAPSCRIPT5));
1171                     if(k + 1 < sdd2[datRow].MS.D->P->S5cnt)
1172                         sdd2[datRow].MS.D->P->S5->next = calloc(1, sizeof(MAPSCRIPT5));
1173                     SMSP5top = sdd2[datRow].MS.D->P->S5;
1174                 }else if(k + 1 < sdd2[datRow].MS.D->P->S5cnt)
1175                     sdd2[datRow].MS.D->P->S5->next = calloc(1, sizeof(MAPSCRIPT5));
1176                 [self readMapScript5:fp];
1177                 sdd2[datRow].MS.D->P->S5 = sdd2[datRow].MS.D->P->S5->next;
1178             }sdd2[datRow].MS.D->P->S5 = SMSP5top;
1179             }
1180
1181             if(sdd2[datRow].MS.D->P->type == 10)
1182                 [self readMapScript6:fp];
1183
1184
1185
1186             sdd2[datRow].MS.D->P = sdd2[datRow].MS.D->P->next;
1187         }
1188         if(sdd2[datRow].MS.D->P)
1189             sdd2[datRow].MS.D->P->next = NULL;
1190
1191         sdd2[datRow].MS.D->P = SMSPtop;
1192
1193
1194         sdd2[datRow].MS.D = sdd2[datRow].MS.D->next;
1195     }
1196     if(sdd2[datRow].MS.D)
1197         sdd2[datRow].MS.D->next = NULL;
1198
1199     sdd2[datRow].MS.D = SMSDtop;
1200
1201
1202
1203
1204 }
1205
1206 -(void)readMapScript1:(FILE*)fp{
1207
1208     sdd2[datRow].MS.D->P->S1.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.name] retain];
1209     sdd2[datRow].MS.D->P->S1.str = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.str] retain];
1210     sdd2[datRow].MS.D->P->S1.iName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.iName] retain];
1211     sdd2[datRow].MS.D->P->S1.nameID = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.nameID] retain];
1212
1213     for(int k = 0; k < UCN;k++){
1214         if(sdd2[datRow].MS.D->P->S1.nameID)
1215             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:UC[k].nameID]){
1216                 sdd2[datRow].MS.D->P->S1.img = [UC[k].imgb retain];
1217                 break;
1218             }
1219     }
1220     for(int k = 0; k < LCN;k++){
1221         if(sdd2[datRow].MS.D->P->S1.nameID)
1222             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:LC[k].nameID]){
1223                 sdd2[datRow].MS.D->P->S1.img = [LC[k].imgb retain];
1224                 break;
1225             }
1226     }
1227     EIMG = EIMGtop;
1228     while (EIMG) {
1229         if(sdd2[datRow].MS.D->P->S1.nameID)
1230             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:EIMG->name]){
1231                 sdd2[datRow].MS.D->P->S1.img = [EIMG->img retain];
1232                 break;
1233             }
1234         EIMG = EIMG->next;
1235     }EIMG = EIMGtop;
1236
1237     /*
1238      NSString *name;
1239      NSString *str;
1240      //NSImage *img;
1241      NSString *iName;
1242      NSString *nameID;
1243      */
1244 }
1245
1246 -(void)readMapScript2:(FILE*)fp{
1247
1248     sdd2[datRow].MS.D->P->S2->selection = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S2->selection] retain];
1249     sdd2[datRow].MS.D->P->S2->labelJump = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S2->labelJump] retain];
1250
1251     /*
1252      //struct _MAPSCRIPT2 *next;
1253
1254      NSString *selection;
1255      NSString *labelJump;
1256      */
1257 }
1258
1259 -(void)readMapScript3:(FILE*)fp{
1260
1261     sdd2[datRow].MS.D->P->S3->x = (int)[self readInt:fp];
1262     sdd2[datRow].MS.D->P->S3->y = (int)[self readInt:fp];
1263     sdd2[datRow].MS.D->P->S3->flag = (int)[self readInt:fp];
1264
1265     sdd2[datRow].MS.D->P->S3->type = (int)[self readInt:fp];
1266     sdd2[datRow].MS.D->P->S3->team = (int)[self readInt:fp];
1267
1268     sdd2[datRow].MS.D->P->S3->unitNum = (int)[self readInt:fp];
1269     sdd2[datRow].MS.D->P->S3->loadInt = (int)[self readInt:fp];
1270
1271     sdd2[datRow].MS.D->P->S3->U = UC[sdd2[datRow].MS.D->P->S3->unitNum];
1272
1273     /*
1274      //struct _MAPSCRIPT3 *next;
1275
1276      int x;
1277      int y;
1278      bool flag;
1279
1280      int type;
1281      int team;
1282
1283      //UNITCHIP U;
1284      int unitNum;
1285
1286      int loadInt;
1287      */
1288 }
1289
1290 -(void)readMapScript4:(FILE*)fp{
1291
1292     sdd2[datRow].MS.D->P->S4.lagFixFlag = (int)[self readInt:fp];
1293     sdd2[datRow].MS.D->P->S4.COMPrabel = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S4.COMPrabel] retain];
1294     sdd2[datRow].MS.D->P->S4.FAILrabel = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S4.FAILrabel] retain];
1295
1296     sdd2[datRow].MS.D->P->S4.suicchiFlag = (int)[self readInt:fp];
1297
1298     sdd2[datRow].MS.D->P->S4.suicchiCnt = (int)[self readInt:fp];
1299
1300     if(sdd2[datRow].MS.D->P->S4.suicchiCnt > 0)
1301         sdd2[datRow].MS.D->P->S4.suicchi = calloc(sdd2[datRow].MS.D->P->S4.suicchiCnt, sizeof(int));
1302     for(int l = 0;l < sdd2[datRow].MS.D->P->S4.suicchiCnt;l++) {
1303         *(sdd2[datRow].MS.D->P->S4.suicchi + l) = (int)[self readInt:fp];
1304     }
1305
1306     sdd2[datRow].MS.D->P->S4.suicchiONOFF = (int)[self readInt:fp];
1307
1308     sdd2[datRow].MS.D->P->S4.hensuFlag = (int)[self readInt:fp];
1309     sdd2[datRow].MS.D->P->S4.hensu1 = (int)[self readInt:fp];
1310     sdd2[datRow].MS.D->P->S4.teisuFlag = (int)[self readInt:fp];
1311     sdd2[datRow].MS.D->P->S4.teisuValue = (int)[self readInt:fp];
1312     sdd2[datRow].MS.D->P->S4.hensu2flag = (int)[self readInt:fp];
1313     sdd2[datRow].MS.D->P->S4.hensu2 = (int)[self readInt:fp];
1314     sdd2[datRow].MS.D->P->S4.hensuType = (int)[self readInt:fp];
1315
1316     sdd2[datRow].MS.D->P->S4.timerFlag = (int)[self readInt:fp];
1317     sdd2[datRow].MS.D->P->S4.timerMin = (int)[self readInt:fp];
1318     sdd2[datRow].MS.D->P->S4.timerSec = (int)[self readInt:fp];
1319     sdd2[datRow].MS.D->P->S4.timerType = (int)[self readInt:fp];
1320
1321     sdd2[datRow].MS.D->P->S4.unitNumFlag = (int)[self readInt:fp];
1322     sdd2[datRow].MS.D->P->S4.team = (int)[self readInt:fp];
1323     sdd2[datRow].MS.D->P->S4.unitNum = (int)[self readInt:fp];
1324     sdd2[datRow].MS.D->P->S4.unitType = (int)[self readInt:fp];
1325     sdd2[datRow].MS.D->P->S4.unitTypeFlag = (int)[self readInt:fp];
1326
1327
1328
1329     UNIT2 *subjTop = sdd2[datRow].MS.D->P->S4.subj;
1330
1331     sdd2[datRow].MS.D->P->S4.subjCnt = (int)[self readInt:fp];
1332
1333     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.subjCnt;k++) {
1334         if(k == 0){
1335             sdd2[datRow].MS.D->P->S4.subj = calloc(1, sizeof(UNIT2));
1336             if(k + 1 < sdd2[datRow].MS.D->P->S4.subjCnt)
1337                 sdd2[datRow].MS.D->P->S4.subj->next = calloc(1, sizeof(UNIT2));
1338             subjTop = sdd2[datRow].MS.D->P->S4.subj;
1339         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.subjCnt)
1340             sdd2[datRow].MS.D->P->S4.subj->next = calloc(1, sizeof(UNIT2));
1341         [self readMapScript4subj:fp];
1342         sdd2[datRow].MS.D->P->S4.subj = sdd2[datRow].MS.D->P->S4.subj->next;
1343     }sdd2[datRow].MS.D->P->S4.subj = subjTop;
1344
1345
1346
1347     sdd2[datRow].MS.D->P->S4.placeFlag = (int)[self readInt:fp];
1348     PLACEMENT *waypTop = sdd2[datRow].MS.D->P->S4.wayp;
1349
1350     sdd2[datRow].MS.D->P->S4.waypCnt = (int)[self readInt:fp];
1351
1352     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.waypCnt;k++) {
1353         if(k == 0){
1354             sdd2[datRow].MS.D->P->S4.wayp = calloc(1, sizeof(PLACEMENT));
1355             if(k + 1 < sdd2[datRow].MS.D->P->S4.waypCnt)
1356                 sdd2[datRow].MS.D->P->S4.wayp->next = calloc(1, sizeof(PLACEMENT));
1357             waypTop = sdd2[datRow].MS.D->P->S4.wayp;
1358         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.waypCnt)
1359             sdd2[datRow].MS.D->P->S4.wayp->next = calloc(1, sizeof(PLACEMENT));
1360         [self readMapScript4wayp:fp];
1361         sdd2[datRow].MS.D->P->S4.wayp = sdd2[datRow].MS.D->P->S4.wayp->next;
1362     }sdd2[datRow].MS.D->P->S4.wayp = waypTop;
1363
1364     sdd2[datRow].MS.D->P->S4.unitCMDflag = (int)[self readInt:fp];
1365     sdd2[datRow].MS.D->P->S4.unitCMD = (int)[self readInt:fp];
1366
1367
1368     sdd2[datRow].MS.D->P->S4.objeFlag = (int)[self readInt:fp];
1369     UNIT2 *objeTop = sdd2[datRow].MS.D->P->S4.obje;
1370
1371     sdd2[datRow].MS.D->P->S4.objeCnt = (int)[self readInt:fp];
1372
1373     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.objeCnt;k++) {
1374         if(k == 0){
1375             sdd2[datRow].MS.D->P->S4.obje = calloc(1, sizeof(UNIT2));
1376             if(k + 1 < sdd2[datRow].MS.D->P->S4.objeCnt)
1377                 sdd2[datRow].MS.D->P->S4.obje->next = calloc(1, sizeof(UNIT2));
1378             objeTop = sdd2[datRow].MS.D->P->S4.obje;
1379         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.objeCnt)
1380             sdd2[datRow].MS.D->P->S4.obje->next = calloc(1, sizeof(UNIT2));
1381         [self readMapScript4obje:fp];
1382         sdd2[datRow].MS.D->P->S4.obje = sdd2[datRow].MS.D->P->S4.obje->next;
1383     }sdd2[datRow].MS.D->P->S4.obje = objeTop;
1384
1385
1386     sdd2[datRow].MS.D->P->S4.objeRange = (int)[self readInt:fp];
1387
1388
1389     sdd2[datRow].MS.D->P->S4.buildFlag = (int)[self readInt:fp];
1390     BUILD2 *buildTop = sdd2[datRow].MS.D->P->S4.build;
1391
1392     sdd2[datRow].MS.D->P->S4.buildCnt = (int)[self readInt:fp];
1393
1394     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.buildCnt;k++) {
1395         if(k == 0){
1396             sdd2[datRow].MS.D->P->S4.build = calloc(1, sizeof(BUILD2));
1397             if(k + 1 < sdd2[datRow].MS.D->P->S4.buildCnt)
1398                 sdd2[datRow].MS.D->P->S4.build->next = calloc(1, sizeof(BUILD2));
1399             buildTop = sdd2[datRow].MS.D->P->S4.build;
1400         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.buildCnt)
1401             sdd2[datRow].MS.D->P->S4.build->next = calloc(1, sizeof(BUILD2));
1402         [self readMapScript4build:fp];
1403         sdd2[datRow].MS.D->P->S4.build = sdd2[datRow].MS.D->P->S4.build->next;
1404     }sdd2[datRow].MS.D->P->S4.build = buildTop;
1405
1406
1407 }
1408
1409 -(void)readMapScript4subj:(FILE*)fp{
1410
1411
1412     sdd2[datRow].MS.D->P->S4.subj->team = (int)[self readInt:fp];
1413     sdd2[datRow].MS.D->P->S4.subj->x = (int)[self readInt:fp];
1414     sdd2[datRow].MS.D->P->S4.subj->y = (int)[self readInt:fp];
1415
1416     /*
1417      //struct _UNIT2 *next;
1418      //UNITCHIP C;
1419
1420      int team;
1421      int x;
1422      int y;
1423      */
1424 }
1425
1426 -(void)readMapScript4wayp:(FILE*)fp{
1427
1428     sdd2[datRow].MS.D->P->S4.wayp->type = (int)[self readInt:fp];
1429     sdd2[datRow].MS.D->P->S4.wayp->x = (int)[self readInt:fp];
1430     sdd2[datRow].MS.D->P->S4.wayp->y = (int)[self readInt:fp];
1431     sdd2[datRow].MS.D->P->S4.wayp->z = (int)[self readInt:fp];
1432     sdd2[datRow].MS.D->P->S4.wayp->x2 = (int)[self readInt:fp];
1433     sdd2[datRow].MS.D->P->S4.wayp->y2 = (int)[self readInt:fp];
1434
1435     /*
1436      //struct _PLACEMENT *next;
1437
1438      int type;
1439      int x;
1440      int y;
1441      int z;
1442      int x2;
1443      int y2;
1444      */
1445 }
1446
1447 -(void)readMapScript4obje:(FILE*)fp{
1448
1449     sdd2[datRow].MS.D->P->S4.obje->team = (int)[self readInt:fp];
1450     sdd2[datRow].MS.D->P->S4.obje->x = (int)[self readInt:fp];
1451     sdd2[datRow].MS.D->P->S4.obje->y = (int)[self readInt:fp];
1452
1453     /*
1454      //struct _UNIT2 *next;
1455      //UNITCHIP C;
1456
1457      int team;
1458      int x;
1459      int y;
1460      */
1461 }
1462
1463 -(void)readMapScript4build:(FILE*)fp{
1464
1465     sdd2[datRow].MS.D->P->S4.build->team = (int)[self readInt:fp];
1466     sdd2[datRow].MS.D->P->S4.build->x = (int)[self readInt:fp];
1467     sdd2[datRow].MS.D->P->S4.build->y = (int)[self readInt:fp];
1468
1469     /*
1470      //struct _BUILD2 *next;
1471      //struct _BUILDCHIP *C;
1472
1473      int team;
1474      int x;
1475      int y;
1476      */
1477 }
1478
1479 -(void)readMapScript5:(FILE*)fp{
1480
1481     sdd2[datRow].MS.D->P->S5->x = (int)[self readInt:fp];
1482     sdd2[datRow].MS.D->P->S5->y = (int)[self readInt:fp];
1483     sdd2[datRow].MS.D->P->S5->type = (int)[self readInt:fp];
1484     sdd2[datRow].MS.D->P->S5->team = (int)[self readInt:fp];
1485     sdd2[datRow].MS.D->P->S5->unitNum = (int)[self readInt:fp];
1486     sdd2[datRow].MS.D->P->S5->saveInt = (int)[self readInt:fp];
1487
1488     sdd2[datRow].MS.D->P->S5->U = UC[sdd2[datRow].MS.D->P->S5->unitNum];
1489
1490     /*
1491      //struct _MAPSCRIPT5 *next;
1492
1493      int x;
1494      int y;
1495
1496      int type;
1497      int team;
1498
1499      //UNITCHIP U;
1500      int unitNum;
1501
1502      int saveInt;
1503      */
1504 }
1505
1506
1507 -(void)readMapScript6:(FILE*)fp{
1508
1509     sdd2[datRow].MS.D->P->S6.team = (int)[self readInt:fp];
1510
1511     sdd2[datRow].MS.D->P->S6.RCsupply = (int)[self readInt:fp];
1512     sdd2[datRow].MS.D->P->S6.RCfood = (int)[self readInt:fp];
1513     sdd2[datRow].MS.D->P->S6.RCmoney = (int)[self readInt:fp];
1514
1515     sdd2[datRow].MS.D->P->S6.RCsupplyAdd = (int)[self readInt:fp];
1516     sdd2[datRow].MS.D->P->S6.RCfoodAdd = (int)[self readInt:fp];
1517     sdd2[datRow].MS.D->P->S6.RCmoneyAdd = (int)[self readInt:fp];
1518
1519     sdd2[datRow].MS.D->P->S6.RCsupplyValue = (int)[self readInt:fp];
1520     sdd2[datRow].MS.D->P->S6.RCfoodValue = (int)[self readInt:fp];
1521     sdd2[datRow].MS.D->P->S6.RCmoneyValue = (int)[self readInt:fp];
1522
1523     sdd2[datRow].MS.D->P->S6.RCsupplySelect = (int)[self readInt:fp];
1524     sdd2[datRow].MS.D->P->S6.RCfoodSelect = (int)[self readInt:fp];
1525     sdd2[datRow].MS.D->P->S6.RCmoneySelect = (int)[self readInt:fp];
1526
1527     sdd2[datRow].MS.D->P->S6.RCsupplyS = (int)[self readInt:fp];
1528     sdd2[datRow].MS.D->P->S6.RCfoodS = (int)[self readInt:fp];
1529     sdd2[datRow].MS.D->P->S6.RCmoneyS = (int)[self readInt:fp];
1530
1531     /*
1532      int team;
1533
1534      bool RCsupply;
1535      bool RCfood;
1536      bool RCmoney;
1537
1538      bool RCsupplyAdd;
1539      bool RCfoodAdd;
1540      bool RCmoneyAdd;
1541
1542      int RCsupplyValue;
1543      int RCfoodValue;
1544      int RCmoneyValue;
1545
1546      int RCsupplySelect;
1547      int RCfoodSelect;
1548      int RCmoneySelect;
1549
1550      bool RCsupplyS;
1551      bool RCfoodS;
1552      bool RCmoneyS;
1553      */
1554 }
1555
1556 -(void)readMapScriptBGM:(FILE*)fp{
1557
1558     NSString *directoryPath;
1559
1560     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1561     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1562
1563
1564     NSString* Cpath = @"data/BGM/";
1565     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1566
1567     sdd2[datRow].MS.D->P->BGM.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->BGM.name] retain];
1568     sdd2[datRow].MS.D->P->BGM.fName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->BGM.fName] retain];
1569
1570     sdd2[datRow].MS.D->P->BGM.snd = [[[NSSound alloc] initWithContentsOfURL:
1571                                       [NSURL fileURLWithPath:sdd2[datRow].MS.D->P->BGM.fName] byReference:NO] retain];
1572
1573     /*
1574      //NSString *name;
1575      NSString *fName;
1576      //NSSound *snd;
1577      */
1578 }
1579
1580 -(void)readMapScriptSE:(FILE*)fp{
1581
1582     NSString *directoryPath;
1583
1584     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1585     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1586
1587
1588     NSString* Cpath = @"data/BGM/";
1589     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1590
1591     sdd2[datRow].MS.D->P->SE.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->SE.name] retain];
1592     sdd2[datRow].MS.D->P->SE.fName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->SE.fName] retain];
1593
1594     sdd2[datRow].MS.D->P->SE.snd = [[[NSSound alloc] initWithContentsOfURL:
1595                                       [NSURL fileURLWithPath:sdd2[datRow].MS.D->P->SE.fName] byReference:NO] retain];
1596
1597     /*
1598      NSString *name;
1599      NSString *fName;
1600      //NSSound *snd;
1601      */
1602 }
1603
1604 -(void)readMapScriptSC:(FILE*)fp{
1605
1606     sdd2[datRow].MS.D->P->sc.scFlag = (int)[self readInt:fp];
1607     sdd2[datRow].MS.D->P->sc.edcdFlag = (int)[self readInt:fp];
1608
1609     /*
1610      bool scFlag;
1611      bool edcdFlag;
1612      */
1613 }
1614
1615 -(void)readMapScriptGAOV:(FILE*)fp{
1616
1617
1618     sdd2[datRow].MS.D->P->gaov.fNname = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->gaov.fNname] retain];
1619     sdd2[datRow].MS.D->P->gaov.gaovFlag = (int)[self readInt:fp];
1620     sdd2[datRow].MS.D->P->gaov.edcdFlag = (int)[self readInt:fp];
1621
1622     /*
1623      NSString *fNname;
1624      //NSImage *img;
1625      bool gaovFlag;
1626      bool edcdFlag;
1627      */
1628 }
1629
1630 -(void)inputFileData{
1631
1632     [self saveStruct];
1633     [self loadStruct];
1634 }
1635
1636 -(void)saveStruct{
1637
1638     //まんこ
1639     NSString *directoryPath;
1640
1641     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1642     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1643
1644
1645     NSString* Cpath = @"SaveData/";
1646     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1647
1648     NSString *path = [[NSString alloc] initWithUTF8String:datFilePath];
1649
1650     if(0 && [[NSFileManager defaultManager] fileExistsAtPath:path]){
1651         [self loadStruct];
1652             if(datRow < 0)
1653                 return;
1654
1655
1656         if(1){
1657
1658             sdd.name = [sdd2[datRow].name retain];
1659             sdd.imgAdressCnt = sdd2[datRow].imgAdressCnt;
1660             sdd.imgAdressFix = sdd2[datRow].imgAdressFix;
1661             sdd.img = sdd2[datRow].img;
1662
1663             sdd.MFselectedRow = sdd2[datRow].MFselectedRow;
1664             sdd.storyNumb = sdd2[datRow].storyNumb;
1665             sdd.scenarioNumb = sdd2[datRow].scenarioNumb;
1666
1667             sdd.mapfileName = [sdd2[datRow].mapfileName retain];
1668             sdd.levelName = [sdd2[datRow].levelName retain];
1669             sdd.levelName = [sdd2[datRow].scenarioName retain];
1670
1671             sdd.chipHeight = sdd2[datRow].chipHeight;
1672             sdd.chipWidth = sdd2[datRow].chipWidth;
1673
1674             sdd.posX = sdd2[datRow].posX;
1675             sdd.posY = sdd2[datRow].posY;
1676
1677             sdd.eSlctX = sdd2[datRow].eSlctX;
1678             sdd.eSlctY = sdd2[datRow].eSlctY;
1679
1680             sdd.registerNum = sdd2[datRow].registerNum;
1681             sdd.registerNumB = sdd2[datRow].registerNumB;
1682
1683             sdd.esSceneProc = sdd2[datRow].esSceneProc;
1684
1685             sdd.endGameCondition = sdd2[datRow].endGameCondition;
1686             sdd.initMapFlag = sdd2[datRow].initMapFlag;
1687             sdd.initStatusFlag = sdd2[datRow].initStatusFlag;
1688             sdd.TeamCountFlag = sdd2[datRow].TeamCountFlag;
1689             sdd.battleBegin = sdd2[datRow].battleBegin;
1690             sdd.startES = sdd2[datRow].startES;
1691
1692             sdd.cpuAImodeflag = sdd2[datRow].cpuAImodeflag;
1693             sdd.cpuModeATTACKflag = sdd2[datRow].cpuModeATTACKflag;
1694             sdd.cpuModeMOVEflag = sdd2[datRow].cpuModeMOVEflag;
1695             sdd.cpuTurnEndFlag = sdd2[datRow].cpuTurnEndFlag;
1696             sdd.waitSwtichFlag = sdd2[datRow].waitSwtichFlag;
1697             sdd.battleReadyUpFlag = sdd2[datRow].battleReadyUpFlag;
1698             sdd.setBattleModeFlag = sdd2[datRow].setBattleModeFlag;
1699
1700             sdd.wtRdy = sdd2[datRow].wtRdy;
1701             sdd.wtRdy2 = sdd2[datRow].wtRdy2;
1702             sdd.wtRdy3 = sdd2[datRow].wtRdy3;
1703
1704             sdd.wtMovedFlag = sdd2[datRow].wtMovedFlag;
1705             sdd.wtAttackedFlag = sdd2[datRow].wtAttackedFlag;
1706             sdd.unitMoveEndFlag = sdd2[datRow].unitMoveEndFlag;
1707             sdd.battleSetUp = sdd2[datRow].battleSetUp;
1708             sdd.pushStanbyFlag = sdd2[datRow].pushStanbyFlag;
1709             sdd.battleEndFlag = sdd2[datRow].battleEndFlag;
1710             sdd.wtUnitNum = sdd2[datRow].wtUnitNum;
1711             sdd.messageDialog = sdd2[datRow].messageDialog;
1712
1713             /*
1714             for(int i = 0;i < 1002;i++)
1715                 for(int j = 0;j < 1002;j++)
1716                     sdd.chipNum[i][j] = sdd2[datRow].chipNum[i][j];
1717             for(int i = 0;i < 1002;i++)
1718                 for(int j = 0;j < 1002;j++)
1719                     sdd.buildNum[i][j] = sdd2[datRow].buildNum[i][j];
1720             for(int i = 0;i < 1002;i++)
1721                 for(int j = 0;j < 1002;j++)
1722                     sdd.unitNum[i][j] = sdd2[datRow].unitNum[i][j];
1723             for(int i = 0;i < 1002;i++)
1724                 for(int j = 0;j < 1002;j++)
1725                     sdd.loadNum[i][j] = sdd2[datRow].loadNum[i][j];
1726             for(int i = 0;i < 1002;i++)
1727                 for(int j = 0;j < 1002;j++)
1728                     sdd.buildTeam[i][j] = sdd2[datRow].buildTeam[i][j];
1729             for(int i = 0;i < 1002;i++)
1730                 for(int j = 0;j < 1002;j++)
1731                     sdd.unitTeam[i][j] = sdd2[datRow].unitTeam[i][j];
1732             */
1733             for(int i = 0;i < sdd.registerNum;i++)
1734                 sdd.dU[i] = sdd2[datRow].dU[i];
1735             for(int i = 0;i < sdd.registerNumB;i++)
1736                 sdd.dB[i] = sdd2[datRow].dB[i];
1737
1738             for(int i = 0;i < 3;i++)
1739                 sdd.P[i] = sdd2[datRow].P[i];
1740
1741             //カレントスイッチなど
1742             for(int i = 0;i < 9999;i++)
1743                 sdd.Suicchi[i] = sdd2[datRow].Suicchi[i];
1744
1745             sdd.HensuuNum = sdd2[datRow].HensuuNum;
1746             for(int i = 0;i < 65000;i++)
1747                 sdd.Hensuu[i] = [sdd2[datRow].Hensuu[i] retain];
1748             for(int i = 0;i < 65000;i++)
1749                 sdd.HensuuName[i] = [sdd2[datRow].HensuuName[i] retain];
1750
1751             sdd.MS = sdd2[datRow].MS;
1752
1753         }
1754
1755         datExistFlag = true;
1756     }else{
1757         datExistFlag = false;
1758     }
1759
1760     if(1){
1761         FILE *fpo;
1762
1763         fpo = fopen(datFilePath, "wb");
1764         if(!fpo)
1765             return;
1766
1767
1768         [self writeNSString:fpo str:sdd.name];
1769         [self writeNSImage:fpo str:sdd.img adCnt:&sdd.imgAdressCnt adFix:&sdd.imgAdressFix];
1770
1771
1772         [self writeInt:fpo val:sdd.MFselectedRow];
1773         [self writeInt:fpo val:sdd.storyNumb];
1774         [self writeInt:fpo val:sdd.scenarioNumb];
1775         [self writeNSString:fpo str:sdd.mapfileName];
1776         [self writeNSString:fpo str:sdd.levelName];
1777         [self writeNSString:fpo str:sdd.scenarioName];
1778
1779         [self writeInt:fpo val:sdd.chipHeight];
1780         [self writeInt:fpo val:sdd.chipWidth];
1781         [self writeInt:fpo val:sdd.posX];
1782         [self writeInt:fpo val:sdd.posY];
1783         [self writeInt:fpo val:sdd.eSlctX];
1784         [self writeInt:fpo val:sdd.eSlctY];
1785         [self writeInt:fpo val:sdd.registerNum];
1786         [self writeInt:fpo val:sdd.registerNumB];
1787         [self writeInt:fpo val:sdd.esSceneProc];
1788         [self writeInt:fpo val:sdd.endGameCondition];
1789
1790         [self writeInt:fpo val:sdd.initMapFlag];
1791         [self writeInt:fpo val:sdd.initStatusFlag];
1792         [self writeInt:fpo val:sdd.TeamCountFlag];
1793         [self writeInt:fpo val:sdd.battleBegin];
1794         [self writeInt:fpo val:sdd.startES];
1795
1796         [self writeInt:fpo val:sdd.cpuAImodeflag];
1797         [self writeInt:fpo val:sdd.cpuModeATTACKflag];
1798         [self writeInt:fpo val:sdd.cpuModeMOVEflag];
1799         [self writeInt:fpo val:sdd.cpuTurnEndFlag];
1800         [self writeInt:fpo val:sdd.waitSwtichFlag];
1801         [self writeInt:fpo val:sdd.battleReadyUpFlag];
1802         [self writeInt:fpo val:sdd.setBattleModeFlag];
1803
1804         [self writeInt:fpo val:sdd.wtRdy];
1805         [self writeInt:fpo val:sdd.wtRdy2];
1806         [self writeInt:fpo val:sdd.wtRdy3];
1807
1808         [self writeInt:fpo val:sdd.wtMovedFlag];
1809         [self writeInt:fpo val:sdd.wtAttackedFlag];
1810         [self writeInt:fpo val:sdd.unitMoveEndFlag];
1811         [self writeInt:fpo val:sdd.battleSetUp];
1812         [self writeInt:fpo val:sdd.pushStanbyFlag];
1813         [self writeInt:fpo val:sdd.battleEndFlag];
1814         [self writeInt:fpo val:sdd.wtUnitNum];
1815         [self writeInt:fpo val:sdd.messageDialog];
1816
1817         /*//これやると容量が重くなる（24MB超えるので保存しない）
1818         for(int i = 0;i < 1002;i++)
1819             for(int j = 0;j < 1002;j++)
1820                 [self writeInt:fpo val:sdd.chipNum[i][j]];
1821         for(int i = 0;i < 1002;i++)
1822             for(int j = 0;j < 1002;j++)
1823                 [self writeInt:fpo val:sdd.buildNum[i][j]];
1824         for(int i = 0;i < 1002;i++)
1825             for(int j = 0;j < 1002;j++)
1826                 [self writeInt:fpo val:sdd.unitNum[i][j]];
1827         for(int i = 0;i < 1002;i++)
1828             for(int j = 0;j < 1002;j++)
1829                 [self writeInt:fpo val:sdd.loadNum[i][j]];
1830         for(int i = 0;i < 1002;i++)
1831             for(int j = 0;j < 1002;j++)
1832                 [self writeInt:fpo val:sdd.buildTeam[i][j]];
1833         for(int i = 0;i < 1002;i++)
1834             for(int j = 0;j < 1002;j++)
1835                 [self writeInt:fpo val:sdd.unitTeam[i][j]];
1836         */
1837
1838         for(int i = 0;i < sdd.registerNum;i++)
1839             [self writeUnitD:fpo row:i];
1840         for(int i = 0;i < sdd.registerNumB;i++)
1841             [self writeBiuldD:fpo row:i];
1842             NSLog(@"\n(保存)%@:IMGADRESS %p\n", sdd.name,sdd.img);
1843
1844         for(int i = 0;i < 3;i++){
1845             fwrite(&sdd.P[i], sizeof(PLAYER), 1, fpo);
1846             [self writeNSString:fpo str:P[i].name];
1847         }
1848         //カレントスイッチなど
1849         for(int i = 0;i < 9999;i++)
1850             [self writeInt:fpo val:sdd.Suicchi[i]];
1851
1852         [self writeInt:fpo val:sdd.HensuuNum];
1853         for(int i = 0;i < 65000;i++)
1854             [self writeNSString:fpo str:sdd.Hensuu[i]];
1855         for(int i = 0;i < 65000;i++)
1856             [self writeNSString:fpo str:sdd.HensuuName[i]];
1857
1858
1859         [self writeMapScript:fpo];
1860
1861         fclose(fpo);
1862
1863         routeCnt = 0;
1864
1865         saveFlag = false;
1866     }
1867     [self loadStruct];
1868 }
1869
1870 -(void)writeBiuldD:(FILE*)fp row:(int)r{
1871
1872     [self writeInt:fp val:sdd.dB[r].number];
1873     [self writeInt:fp val:sdd.dB[r].team];
1874     [self writeInt:fp val:sdd.dB[r].chipNumber];
1875     [self writeInt:fp val:sdd.dB[r].makeLv];
1876
1877     [self writeInt:fp val:sdd.dB[r].x];
1878     [self writeInt:fp val:sdd.dB[r].y];
1879     [self writeInt:fp val:sdd.dB[r].z];
1880
1881     [self writeInt:fp val:sdd.dB[r].dead];
1882
1883     //[self writeBuildDimage:fp row:r];
1884     [self writeBuildChipD:fp val:sdd.dB[r].C];
1885 }
1886
1887 -(void)writeBuildChipD:(FILE*)fp val:(BUILDCHIPD)val{
1888
1889     [self writeInt:fp val:val.chipNumb];
1890     [self writeNSString:fp str:val.name];
1891     [self writeNSString:fp str:val.nameID];
1892
1893     fwrite(&val.S_C, sizeof(BSTATUS), 1, fp);
1894
1895     NSLog(@"gj folks...");
1896 }
1897
1898 -(void)writeBuildDimage:(FILE*)fp row:(int)r{
1899     FILE *fpx;
1900
1901     NSString *directoryPath;
1902
1903     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1904     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1905
1906     NSString* Cpath = @"Awars IV.app/Contents/Resources/";
1907     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1908
1909     NSString *path2 = @INSTANT_IMG;
1910
1911     if(1){
1912         NSData *imgData = [sdd.dB[r].img TIFFRepresentation];
1913         NSBitmapImageRep *brep = [NSBitmapImageRep imageRepWithData:imgData];
1914         imgData = [brep representationUsingType:NSPNGFileType properties:nil];
1915         [imgData writeToFile:path2 atomically:YES];
1916
1917         fpx = fopen(INSTANT_IMG, "rb");
1918
1919         unsigned char in_buf[1024], out_buf[1024];
1920         int rinf;
1921
1922         sdd.dB[r].imgAdCnt = 0;
1923         sdd.dB[r].imgAdFix = 0;
1924
1925         fpos_t fpt = 0;
1926         while (!feof(fpx)) {
1927             fgetpos(fp, &fpt);
1928             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
1929             if(rinf < 0){
1930                 break;
1931             }
1932             memcpy((void*)out_buf, (void*)in_buf, 1024);
1933             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
1934             if(rinf < 0){
1935                 break;
1936             }
1937             sdd.dB[r].imgAdCnt++;
1938             sdd.dB[r].imgAdFix = rinf;
1939         }
1940
1941         fpt -= (sdd.dB[r].imgAdCnt-1)*1024;
1942         fsetpos(fp, &fpt);
1943         [self writeInt:fp val:(int)sdd.dB[r].imgAdCnt];
1944         [self writeInt:fp val:(int)sdd.dB[r].imgAdFix];
1945
1946         fpt = 0;
1947         fsetpos(fpx, &fpt);
1948         while (!feof(fpx)) {
1949             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
1950             if(rinf < 0){
1951                 break;
1952             }
1953             memcpy((void*)out_buf, (void*)in_buf, 1024);
1954             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
1955             if(rinf < 0){
1956                 break;
1957             }
1958         }
1959
1960
1961
1962         fclose(fpx);
1963     }
1964 }
1965
1966 -(void)writeUnitD:(FILE*)fp row:(int)r{
1967
1968     [self writeInt:fp val:sdd.dU[r].CPU];
1969     [self writeInt:fp val:sdd.dU[r].number];
1970     [self writeInt:fp val:sdd.dU[r].team];
1971     [self writeInt:fp val:sdd.dU[r].chipNumber];
1972     [self writeInt:fp val:sdd.dU[r].chipNumberL];
1973
1974     [self writeInt:fp val:sdd.dU[r].x];
1975     [self writeInt:fp val:sdd.dU[r].y];
1976     [self writeInt:fp val:sdd.dU[r].z];
1977
1978     [self writeInt:fp val:sdd.dU[r].ix];
1979     [self writeInt:fp val:sdd.dU[r].iy];
1980     [self writeInt:fp val:sdd.dU[r].iz];
1981
1982     [self writeInt:fp val:sdd.dU[r].dead];
1983
1984     [self writeInt:fp val:sdd.dU[r].loadChipFlag];
1985
1986     [self writeInt:fp val:sdd.dU[r].unControlable];
1987     [self writeInt:fp val:sdd.dU[r].joinArmyFromNext];
1988     [self writeInt:fp val:sdd.dU[r].persuasion];
1989
1990     [self writeInt:fp val:sdd.dU[r].targType1L];
1991     [self writeInt:fp val:sdd.dU[r].targType2L];
1992     [self writeInt:fp val:sdd.dU[r].targType1D];
1993     [self writeInt:fp val:sdd.dU[r].targType2D];
1994
1995     [self writeNSString:fp str:sdd.dU[r].army];
1996     //[self writeUnitDimage:fp row:r];
1997
1998
1999     [self writeUnitChipD:fp val:sdd.dU[r].C];
2000     [self writeUnitChipLD:fp val:sdd.dU[r].CL];
2001
2002 }
2003
2004 -(void)writeUnitChipD:(FILE*)fp val:(UNITCHIPD)val{
2005
2006     [self writeInt:fp val:val.chipNumb];
2007     [self writeNSString:fp str:val.name];
2008     [self writeNSString:fp str:val.nameNick];
2009     [self writeNSString:fp str:val.nameClass];
2010     [self writeNSString:fp str:val.nameID];
2011
2012
2013
2014     fwrite(&val.R_C, sizeof(RESIST), 1, fp);
2015     fwrite(&val.S_C, sizeof(STATUS), 1, fp);
2016
2017     NSLog(@"oops is right youre supposed to get...");
2018 }
2019
2020 -(void)writeUnitChipLD:(FILE*)fp val:(LOADCHIPD)val{
2021
2022     [self writeInt:fp val:val.chipNumb];
2023     [self writeNSString:fp str:val.name];
2024     [self writeNSString:fp str:val.nameID];
2025
2026
2027
2028     fwrite(&val.R_C, sizeof(RESIST), 1, fp);
2029     fwrite(&val.S_C, sizeof(STATUS2), 1, fp);
2030
2031     NSLog(@"oops is right youre supposed to get...2");
2032 }
2033
2034 -(void)writeUnitDimage:(FILE*)fp row:(int)r{
2035     FILE *fpx;
2036
2037     NSString *directoryPath;
2038
2039     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2040     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2041
2042     NSString* Cpath = @"Awars IV.app/Contents/Resources/";
2043     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2044
2045     NSString *path2 = @INSTANT_IMG;
2046
2047     if(1){
2048         NSData *imgData = [sdd.dU[r].img TIFFRepresentation];
2049         NSBitmapImageRep *brep = [NSBitmapImageRep imageRepWithData:imgData];
2050         imgData = [brep representationUsingType:NSPNGFileType properties:nil];
2051         [imgData writeToFile:path2 atomically:YES];
2052
2053         fpx = fopen(INSTANT_IMG, "rb");
2054
2055         unsigned char in_buf[1024], out_buf[1024];
2056         int rinf;
2057
2058         sdd.dU[r].imgAdCnt = 0;
2059         sdd.dU[r].imgAdFix = 0;
2060
2061         fpos_t fpt = 0;
2062         while (!feof(fpx)) {
2063             fgetpos(fp, &fpt);
2064             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2065             if(rinf < 0){
2066                 break;
2067             }
2068             memcpy((void*)out_buf, (void*)in_buf, 1024);
2069             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2070             if(rinf < 0){
2071                 break;
2072             }
2073             sdd.dU[r].imgAdCnt++;
2074             sdd.dU[r].imgAdFix = rinf;
2075         }
2076
2077         fpt -= (sdd.dU[r].imgAdCnt-1)*1024;
2078         fsetpos(fp, &fpt);
2079         [self writeInt:fp val:(int)sdd.dU[r].imgAdCnt];
2080         [self writeInt:fp val:(int)sdd.dU[r].imgAdFix];
2081
2082         fpt = 0;
2083         fsetpos(fpx, &fpt);
2084         while (!feof(fpx)) {
2085             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2086             if(rinf < 0){
2087                 break;
2088             }
2089             memcpy((void*)out_buf, (void*)in_buf, 1024);
2090             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2091             if(rinf < 0){
2092                 break;
2093             }
2094         }
2095
2096
2097
2098         fclose(fpx);
2099     }
2100 }
2101
2102
2103
2104 -(void)loadStruct{
2105
2106     //まんこ
2107     NSString *directoryPath;
2108
2109     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2110     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2111
2112
2113     NSString* Cpath = @"SaveData/";
2114     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2115
2116     if(datRow < 0)
2117         return;
2118
2119     FILE *fpi;
2120
2121     fpi = fopen(datFilePath, "rb");
2122     if(!fpi)
2123         return;
2124
2125
2126         sdd2[datRow].name = [[self readNSString:fpi strOut:sdd2[datRow].name] retain];
2127
2128         sdd2[datRow].imgAdressCnt = (int)[self readInt:fpi];
2129         sdd2[datRow].imgAdressFix = (int)[self readInt:fpi];
2130         sdd2[datRow].img = [[self readNSImage:fpi imgOut:sdd2[datRow].img dcnt:sdd2[datRow].imgAdressCnt dfix:sdd2[datRow].imgAdressFix] retain];
2131
2132         sdd2[datRow].MFselectedRow = (int)[self readInt:fpi];
2133         sdd2[datRow].storyNumb = (int)[self readInt:fpi];
2134         sdd2[datRow].scenarioNumb = (int)[self readInt:fpi];
2135         sdd2[datRow].mapfileName = [[self readNSString:fpi strOut:sdd2[datRow].mapfileName] retain];
2136         sdd2[datRow].levelName = [[self readNSString:fpi strOut:sdd2[datRow].levelName] retain];
2137         sdd2[datRow].scenarioName = [ [self readNSString:fpi strOut:sdd2[datRow].scenarioName] retain];
2138
2139         sdd2[datRow].chipHeight = (int)[self readInt:fpi];
2140         sdd2[datRow].chipWidth = (int)[self readInt:fpi];
2141         sdd2[datRow].posX = (int)[self readInt:fpi];
2142         sdd2[datRow].posY = (int)[self readInt:fpi];
2143         sdd2[datRow].eSlctX = (int)[self readInt:fpi];
2144         sdd2[datRow].eSlctY = (int)[self readInt:fpi];
2145         sdd2[datRow].registerNum = (int)[self readInt:fpi];
2146         sdd2[datRow].registerNumB = (int)[self readInt:fpi];
2147         sdd2[datRow].esSceneProc = (int)[self readInt:fpi];
2148         sdd2[datRow].endGameCondition = (int)[self readInt:fpi];
2149
2150         sdd2[datRow].initMapFlag = (int)[self readInt:fpi];
2151         sdd2[datRow].initStatusFlag = (int)[self readInt:fpi];
2152         sdd2[datRow].TeamCountFlag = (int)[self readInt:fpi];
2153         sdd2[datRow].battleBegin = (int)[self readInt:fpi];
2154         sdd2[datRow].startES = (int)[self readInt:fpi];
2155
2156         sdd2[datRow].cpuAImodeflag = (int)[self readInt:fpi];
2157         sdd2[datRow].cpuModeATTACKflag = (int)[self readInt:fpi];
2158         sdd2[datRow].cpuModeMOVEflag = (int)[self readInt:fpi];
2159         sdd2[datRow].cpuTurnEndFlag = (int)[self readInt:fpi];
2160         sdd2[datRow].waitSwtichFlag = (int)[self readInt:fpi];
2161         sdd2[datRow].battleReadyUpFlag = (int)[self readInt:fpi];
2162         sdd2[datRow].setBattleModeFlag = (int)[self readInt:fpi];
2163
2164         sdd2[datRow].wtRdy = (int)[self readInt:fpi];
2165         sdd2[datRow].wtRdy2 = (int)[self readInt:fpi];
2166         sdd2[datRow].wtRdy3 = (int)[self readInt:fpi];
2167
2168         sdd2[datRow].wtMovedFlag = (int)[self readInt:fpi];
2169         sdd2[datRow].wtAttackedFlag = (int)[self readInt:fpi];
2170         sdd2[datRow].unitMoveEndFlag = (int)[self readInt:fpi];
2171         sdd2[datRow].battleSetUp = (int)[self readInt:fpi];
2172         sdd2[datRow].pushStanbyFlag = (int)[self readInt:fpi];
2173         sdd2[datRow].battleEndFlag = (int)[self readInt:fpi];
2174         sdd2[datRow].wtUnitNum = (int)[self readInt:fpi];
2175         sdd2[datRow].messageDialog = (int)[self readInt:fpi];
2176
2177     /*//saveStructとワンセット容量の関係で読み込まない
2178     for(int i = 0;i < 1002;i++)
2179         for(int j = 0;j < 1002;j++)
2180             sdd2[datRow].chipNum[i][j] = (int)[self readInt:fpi];
2181     for(int i = 0;i < 1002;i++)
2182         for(int j = 0;j < 1002;j++)
2183             sdd2[datRow].buildNum[i][j] = (int)[self readInt:fpi];
2184     for(int i = 0;i < 1002;i++)
2185         for(int j = 0;j < 1002;j++)
2186             sdd2[datRow].unitNum[i][j] = (int)[self readInt:fpi];
2187     for(int i = 0;i < 1002;i++)
2188         for(int j = 0;j < 1002;j++)
2189             sdd2[datRow].loadNum[i][j] = (int)[self readInt:fpi];
2190     for(int i = 0;i < 1002;i++)
2191         for(int j = 0;j < 1002;j++)
2192             sdd2[datRow].buildTeam[i][j] = (int)[self readInt:fpi];
2193     for(int i = 0;i < 1002;i++)
2194         for(int j = 0;j < 1002;j++)
2195             sdd2[datRow].unitTeam[i][j] = (int)[self readInt:fpi];
2196     */
2197     for(int i = 0;i < sdd2[datRow].registerNum;i++)
2198         [self readUnitD:fpi row:i];
2199     for(int i = 0;i < sdd2[datRow].registerNumB;i++)
2200         [self readBiuldD:fpi row:i];
2201
2202         NSLog(@"\n(読み込み)%@:IMGADRESS %p\n",sdd2[datRow].name,sdd2[datRow].img);
2203
2204     for(int i = 0;i < 3;i++){
2205         fread(&sdd2[datRow].P[i], sizeof(PLAYER), 1, fpi);
2206         sdd2[datRow].P[i].name = [[self readNSString:fpi strOut:sdd2[datRow].P[i].name] retain];
2207     }
2208
2209     //カレントスイッチなど
2210     for(int i = 0;i < 9999;i++)
2211         sdd2[datRow].Suicchi[i] = (int)[self readInt:fpi];
2212
2213     sdd2[datRow].HensuuNum = (int)[self readInt:fpi];
2214     for(int i = 0;i < 65000;i++)
2215         sdd2[datRow].Hensuu[i] = [[self readNSString:fpi strOut:sdd2[datRow].Hensuu[i]] retain];
2216     for(int i = 0;i < 65000;i++)
2217         sdd2[datRow].HensuuName[i] = [[self readNSString:fpi strOut:sdd2[datRow].HensuuName[i]] retain];
2218
2219     [self readMapScript:fpi];
2220
2221     fclose(fpi);
2222
2223 }
2224
2225
2226 -(void)loadOptionMenu{
2227     NSString *directoryPath;
2228
2229     directoryPath = [[NSBundle mainBundle] bundlePath];
2230     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2231
2232
2233     NSString* Cpath = @"Contents/Resources/";
2234     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2235
2236     FILE *fpi;
2237
2238     fpi = fopen(OPTIONFILE_NAME, "rb");
2239     if(!fpi)
2240         return;
2241
2242     wtfom.nameTitle = [@"" retain];
2243     NSLog(@"%@", wtfom.nameTitle);
2244     wtfom.nameTitle = [[self readNSString:fpi strOut:wtfom.nameTitle] retain];
2245     wtfom.nameVersion = [[self readNSString:fpi strOut:wtfom.nameVersion] retain];
2246     wtfom.nameOpening = [[self readNSString:fpi strOut:wtfom.nameOpening] retain];
2247     wtfom.nameBGM = [[self readNSString:fpi strOut:wtfom.nameBGM] retain];
2248
2249     wtfom.allowMapEditor = (int)[self readInt:fpi];
2250     wtfom.allowScenarioEditor = (int)[self readInt:fpi];
2251     wtfom.onlyOnceOpening = (int)[self readInt:fpi];
2252     wtfom.newOpeningIsShown = (int)[self readInt:fpi];
2253
2254     wtfom.adCntIT = (int)[self readInt:fpi];
2255     wtfom.adFixIT = (int)[self readInt:fpi];
2256     wtfom.imgTitle = [[self readNSImage:fpi imgOut:wtfom.imgTitle dcnt:wtfom.adCntIT dfix:wtfom.adFixIT] retain];
2257
2258
2259     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2260     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2261
2262     Cpath = @"data/Movie";
2263
2264     BOOL isDirectory;
2265
2266     [[NSFileManager defaultManager] fileExistsAtPath:Cpath isDirectory:&isDirectory];
2267
2268     if(!isDirectory)
2269         [[NSFileManager defaultManager] createDirectoryAtPath:Cpath withIntermediateDirectories:YES attributes:nil error:nil];
2270
2271
2272     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2273
2274     if([[NSFileManager defaultManager] fileExistsAtPath:wtfom.nameOpening])
2275         openingAVP = [[AVPlayer playerWithURL:[NSURL fileURLWithPath:wtfom.nameOpening]] retain];
2276     else
2277         openingAVP = NULL;
2278
2279     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2280     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2281
2282     Cpath = @"data/BGM/";
2283     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2284
2285     /*
2286     char *cwd;
2287     cwd = getcwd(NULL, 0);
2288
2289     NSLog(@"%s", cwd);
2290     */
2291
2292     titleBGM = [[[NSSound alloc] initWithContentsOfURL:[NSURL fileURLWithPath:wtfom.nameBGM] byReference:NO] retain];
2293
2294     fclose(fpi);
2295 }
2296
2297 -(void)openingAVPVfunc{
2298
2299     if(openingAVP && openingAVPVisActive){
2300         openingAVPV.player = openingAVP;
2301         openingAVPV.videoGravity =  AVLayerVideoGravityResize;
2302     }
2303
2304     if(openingAVPVisHidden)
2305         [openingAVPV setHidden:YES];
2306     else
2307         [openingAVPV setHidden:NO];
2308
2309 }
2310
2311 -(void)saveOptionMenu{
2312     NSString *directoryPath;
2313
2314     directoryPath = [[NSBundle mainBundle] bundlePath];
2315     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2316
2317
2318     NSString* Cpath = @"Contents/Resources/";
2319     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2320
2321     /*
2322     char *cwd;
2323     cwd = getcwd(NULL, 0);
2324
2325     NSLog(@"%s", cwd);
2326     */
2327
2328     FILE *fpo;
2329
2330     fpo = fopen(OPTIONFILE_NAME, "wb");
2331     if(!fpo)
2332         return;
2333
2334     [self writeNSString:fpo str:wtfom.nameTitle];
2335     [self writeNSString:fpo str:wtfom.nameVersion];
2336     [self writeNSString:fpo str:wtfom.nameOpening];
2337     [self writeNSString:fpo str:wtfom.nameBGM];
2338
2339     [self writeInt:fpo val:wtfom.allowMapEditor];
2340     [self writeInt:fpo val:wtfom.allowScenarioEditor];
2341     [self writeInt:fpo val:wtfom.onlyOnceOpening];
2342     [self writeInt:fpo val:wtfom.newOpeningIsShown];
2343
2344     [self writeNSImage:fpo str:wtfom.imgTitle adCnt:&wtfom.adCntIT adFix:&wtfom.adFixIT];
2345
2346
2347
2348
2349     fclose(fpo);
2350 }
2351
2352
2353
2354 -(void)clickSGL:(id)sender{
2355
2356     datRow = (int)[saveGameListTV clickedRow];
2357 }
2358
2359 -(void)clickLFOL:(id)sender{
2360
2361     LFOLrow = (int)[loadFileOutputListTV selectedRow];
2362     SDLrow = -1;
2363
2364     for(int i = 1;i <= saveNumb;i++){
2365
2366         for(int j = 0;j < [loadFileOutputListMA count];j++){
2367
2368             if([SDL[j+1].name isEqualToString:[loadFileOutputListMA[LFOLrow] valueForKey:@"name"]]){
2369                 SDLrow = j;
2370
2371                 [loadFileOutputTF setStringValue:[NSString stringWithFormat:@"%@ まで", SDL[SDLrow+1].levelName]];
2372                 return;
2373             }
2374         }
2375     }
2376
2377     [loadFileOutputTF setStringValue:[NSString stringWithFormat:@""]];
2378
2379 }
2380
2381 -(void)doubleClickBCL:(id)sender{
2382
2383     enum{
2384         MC_ANTEI,
2385         MC_FUANTEI,
2386         MC_CHIKURIN,
2387         MC_MIZUBA,
2388         MC_ASASE,
2389         MC_NAIBU
2390     };
2391
2392     enum{
2393         BC_ANTEI,
2394         BC_CHIKURIN,
2395         BC_ASASE,
2396         BC_SONOTA
2397     };
2398
2399     bclRdy = false;
2400
2401     U = UTop;
2402     for(int i = 0;i < slctedUnitNum;i++){
2403         U = U->next;
2404     }
2405
2406     if (MC[chipNum[possionX][possionY]].type == MC_ANTEI) {
2407
2408         if(BC[U->C.S->list[crBCL]-1].type == BC_ANTEI){
2409             bclRdy = true;
2410         }
2411
2412     }
2413
2414     if (MC[chipNum[possionX][possionY]].type == MC_CHIKURIN) {
2415
2416         if(BC[U->C.S->list[crBCL]-1].type == BC_CHIKURIN){
2417             bclRdy = true;
2418         }
2419
2420     }
2421
2422     if (MC[chipNum[possionX][possionY]].type == MC_ASASE) {
2423
2424         if(BC[U->C.S->list[crBCL]-1].type == BC_ASASE){
2425             bclRdy = true;
2426         }
2427
2428     }
2429
2430     if(BC[U->C.S->list[crBCL]].type == BC_SONOTA){
2431         bclRdy = true;
2432     }
2433
2434     if(bclRdy){
2435         bclRdy = false;
2436         if(buildNum[possionX][possionY] >= 0){
2437             U = UTop;
2438             return;
2439         }
2440
2441         if(U->team == 0)
2442         if(P[0].resource >= BC[U->C.S->list[crBCL]-1].Csupply){
2443             if(P[0].food >= BC[U->C.S->list[crBCL]-1].Cfood){
2444                 if (P[0].money >= BC[U->C.S->list[crBCL]-1].Cmoney) {
2445                     P[0].resource -= BC[U->C.S->list[crBCL]-1].Csupply;
2446                     P[0].food -= BC[U->C.S->list[crBCL]-1].Cfood;
2447                     P[0].money -= BC[U->C.S->list[crBCL]-1].Cmoney;
2448
2449                     buildNum[possionX][possionY] = U->C.S->list[crBCL]-1;
2450
2451                     buildTeam[possionX][possionY] = 0;
2452
2453
2454                     [self addBuildStatus];
2455
2456                     bclRdy = true;
2457                 }
2458             }
2459         }
2460
2461         if(U->team == 2)
2462         if(P[1].resource >= BC[U->C.S->list[crBCL]-1].Csupply){
2463             if(P[1].food >= BC[U->C.S->list[crBCL]-1].Cfood){
2464                 if (P[1].money >= BC[U->C.S->list[crBCL]-1].Cmoney) {
2465                     P[1].resource -= BC[U->C.S->list[crBCL]-1].Csupply;
2466                     P[1].food -= BC[U->C.S->list[crBCL]-1].Cfood;
2467                     P[1].money -= BC[U->C.S->list[crBCL]-1].Cmoney;
2468
2469                     buildNum[possionX][possionY] = U->C.S->list[crBCL]-1;
2470
2471                     buildTeam[possionX][possionY] = 2;
2472
2473                     [self addBuildStatus];
2474
2475                     bclRdy = true;
2476                 }
2477             }
2478         }
2479         [createPanel close];
2480     }
2481
2482     U = UTop;
2483 }
2484
2485 -(void)clickBCL:(id)sender{
2486     crBCL = (int)[BCreateListTV clickedRow];
2487
2488
2489
2490 }
2491
2492
2493 -(void)doubleClickCSL:(id)sender{
2494
2495     U = UTop;
2496     for(int i = 0;i < slctedUnitNum;i++){
2497         U = U->next;
2498     }
2499     CSLU = U;
2500
2501     SKILL *sTop = U->C.S;
2502     while (U->C.S) {
2503         if(U->C.S->type == 2) break;
2504         U->C.S = U->C.S->next;
2505     }
2506     if(!U->C.S){
2507         U->C.S = sTop;
2508         U = UTop;
2509         return;
2510     }
2511
2512     if(U->team == 0)
2513         if(U->C.S->cost[crCSL] <= U->C.S_C.MP){
2514             //U->C.S_C.MP -= U->C.S->cost[crCSL];
2515             CSLUC = UC[U->C.S->list[crCSL]-1];
2516
2517             U->C.S = sTop;
2518             cslRdy = true;
2519             [summonPanel close];
2520             //unitColorInitFlag = true;
2521         }
2522     if(U->team == 2)
2523         if(U->C.S->cost[crCSL] <= U->C.S_C.MP){
2524
2525             //U->C.S_C.MP -= U->C.S->cost[crCSL];
2526             CSLUC = UC[U->C.S->list[crCSL]-1];
2527
2528             U->C.S = sTop;
2529             cslRdy = true;
2530             [summonPanel close];
2531             //unitColorInitFlag = true;
2532         }
2533
2534     U = UTop;
2535
2536 }
2537
2538 -(void)clickCSL:(id)sender{
2539     crCSL = (int)[CSummonListTV clickedRow];
2540
2541
2542 }
2543
2544 -(void)doubleClickCAL:(id)sender{
2545
2546     if([CAttackListTV clickedRow] < 0) return;
2547
2548     if(crCAL < 0)
2549         crCAL = 0;
2550
2551     int postCAL1 = crCAL1;
2552     int postCAL2 = crCAL2;
2553
2554     if(!battleSet1Flag && !battleSet2Flag){
2555     U = UTop;
2556     while (!(AUN[1] == U->number)) {
2557         U = U->next;
2558     }
2559
2560
2561
2562         if(U->chipNumberL < 0){
2563
2564             ATTACK *aTop = U->C.A;
2565
2566             crCAL = (int)[CAttackListTV clickedRow];
2567             crCAL1 = (int)[CAttackListTV clickedRow];
2568             for(int i = 0;i < crCAL;i++){
2569                 U->C.A = U->C.A->next;
2570             }
2571
2572             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2573             costVIG = U->C.A->vigor;
2574
2575             if(costMP <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
2576                 if(U->C.A->extent > 0){
2577                     atkExtentFlag = true;
2578                 }else{
2579                     atkExtentFlag = false;
2580                 }
2581                 dcRdy = true;
2582                 [atkPanel close];
2583             }
2584             U->C.A = aTop;
2585             U = UTop;
2586             crCAL1 = crCAL;
2587             return;
2588         }else{
2589             ATTACK *aTop = U->CL.A;
2590             crCAL = (int)[CAttackListTV clickedRow];
2591             crCAL1 = (int)[CAttackListTV clickedRow];
2592             for(int i = 0;i < crCAL;i++){
2593                 U->CL.A = U->CL.A->next;
2594             }
2595
2596             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2597             costVIG = U->CL.A->vigor;
2598
2599             if(costMP <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
2600                 dcRdy = true;
2601                 if(U->CL.A->extent > 0){
2602                     atkExtentFlag = true;
2603                 }else{
2604                     atkExtentFlag = false;
2605                 }
2606                 [atkPanel close];
2607             }
2608             U->CL.A = aTop;
2609             U = UTop;
2610             crCAL1 = crCAL;
2611             return;
2612         }
2613     }
2614
2615     if(battleSet1Flag && !battleSet2PushedFlag){
2616
2617
2618         U = UTop;
2619         while (!(AUN[1] == U->number)) {
2620             U = U->next;
2621         }
2622
2623         if(U->chipNumberL < 0){
2624             ATTACK *aTop = U->C.A;
2625             crCAL1 = (int)[CAttackListTV clickedRow];
2626             for(int i = 0;i < crCAL1;i++){
2627                 U->C.A = U->C.A->next;
2628             }
2629
2630             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2631             costVIG = U->C.A->vigor;
2632
2633
2634             if(costMP <= U->C.S_C.MP && U->atkRange >= U->C.A->rangeA
2635                && U->atkRange <= U->C.A->rangeB && costVIG >= U->C.S_C.vigor){
2636                 //dcRdy = true;
2637                 [atkPanel close];
2638                 U->C.A = aTop;
2639                 U = UTop;
2640                 return;
2641             }
2642             U->C.A = aTop;
2643             crCAL1 = crCAL;
2644             U = UTop;
2645
2646         }else{
2647             ATTACK *aTop = U->CL.A;
2648             crCAL1 = (int)[CAttackListTV clickedRow];
2649             for(int i = 0;i < crCAL1;i++){
2650                 U->CL.A = U->CL.A->next;
2651             }
2652
2653             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2654             costVIG = U->C.A->vigor;
2655
2656             if(costMP <= U->CL.S_C.EN && U->atkRange >= U->CL.A->rangeA
2657                && U->atkRange <= U->CL.A->rangeB && costVIG >= U->C.S_C.vigor){
2658                 //dcRdy = true;
2659                 [atkPanel close];
2660                 U->CL.A = aTop;
2661                 U = UTop;
2662                 return;
2663             }
2664             U->CL.A = aTop;
2665             crCAL1 = crCAL;
2666             U = UTop;
2667         }
2668
2669     }
2670
2671     if(battleSet2Flag && battleSet2PushedFlag){
2672         U = UTop;
2673         while (!(AUN[1] == U->number)) {
2674             U = U->next;
2675         }
2676
2677         if(U->chipNumberL < 0){
2678             U = UTop;
2679             U = UTop;
2680             while (!(AUN[1] == U->number)) {
2681                 U = U->next;
2682             }
2683
2684             int omgRange = U->atkRange;
2685
2686             U = UTop;
2687             while (!(DUN[1] == U->number)) {
2688                 U = U->next;
2689             }
2690
2691             U->atkRange = omgRange;
2692
2693             ATTACK *aTop = U->C.A;
2694             crCAL2 = (int)[CAttackListTV clickedRow];
2695             for(int i = 0;i < crCAL2;i++){
2696                 U->C.A = U->C.A->next;
2697             }
2698
2699             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2700             costVIG = U->C.A->vigor;
2701
2702
2703             if(costMP <= U->C.S_C.MP && U->atkRange >= U->C.A->rangeA
2704                 && U->atkRange <= U->C.A->rangeB && U->C.S_C.vigor){
2705                 //dcRdy = true;
2706                 [atkPanel close];
2707                 U->C.A = aTop;
2708                 U = UTop;
2709                 return;
2710             }
2711             U->C.A = aTop;
2712             crCAL1 = crCAL;
2713             U = UTop;
2714         }else{
2715             U = UTop;
2716             U = UTop;
2717             while (!(AUN[1] == U->number)) {
2718                 U = U->next;
2719             }
2720
2721             int omgRange = U->atkRange;
2722
2723             U = UTop;
2724             while (!(DUN[1] == U->number)) {
2725                 U = U->next;
2726             }
2727
2728             U->atkRange = omgRange;
2729
2730             ATTACK *aTop = U->CL.A;
2731             crCAL2 = (int)[CAttackListTV clickedRow];
2732             for(int i = 0;i < crCAL2;i++){
2733                 U->CL.A = U->CL.A->next;
2734             }
2735
2736             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2737             costVIG = U->C.A->vigor;
2738
2739             if(costMP <= U->CL.S_C.EN && U->atkRange >= U->CL.A->rangeA
2740                && U->atkRange <= U->CL.A->rangeB && U->C.S_C.vigor){
2741                 //dcRdy = true;
2742                 [atkPanel close];
2743                 U->CL.A = aTop;
2744                 U = UTop;
2745                 return;
2746             }
2747             U->CL.A = aTop;
2748             crCAL1 = crCAL;
2749             U = UTop;
2750
2751         }
2752
2753         U = UTop;
2754
2755     }
2756
2757
2758     crCAL1 = postCAL1;
2759     crCAL2 = postCAL2;
2760 }
2761
2762
2763 -(void)clickCAL:(id)sender{
2764
2765     crCAL = (int)[CAttackListTV clickedRow];
2766
2767     if(!battleSetFlag){crCAL = crCAL1;
2768         crCAL1 = (int)[CAttackListTV clickedRow];
2769         crCAL = crCAL1;
2770         U = UTop;
2771         while (!(AUN[1] == U->number)) {
2772             U = U->next;
2773         }
2774     }else if(battleSetFlag){crCAL = crCAL2;
2775         crCAL2 = (int)[CAttackListTV clickedRow];
2776         crCAL = crCAL2;
2777         U = UTop;
2778         while (!(DUN[1] == U->number)) {
2779             U = U->next;
2780         }
2781
2782     }
2783
2784     if(U->chipNumberL >= 0) {
2785         U = UTop;
2786         [self initCAttackSelect2];
2787     }
2788     else if(U->chipNumber >= 0) {
2789         U = UTop;
2790         [self initCAttackSelect];
2791     }
2792     U = UTop;
2793 }
2794
2795 -(void)initCAttackSelect{
2796
2797     U = UTop;
2798
2799     while (!(AUN[1] == U->number)) {
2800         U = U->next;
2801     }
2802     if(!battleSetFlag){crCAL = crCAL1;
2803         //crCAL1 = (int)[CAttackListTV clickedRow];
2804         crCAL = crCAL1;
2805         U = UTop;
2806         while (!(AUN[1] == U->number)) {
2807             U = U->next;
2808         }
2809     }else if(battleSetFlag){crCAL = crCAL2;
2810         //crCAL2 = (int)[CAttackListTV clickedRow];
2811         crCAL = crCAL2;
2812         U = UTop;
2813         while (!(DUN[1] == U->number)) {
2814             U = U->next;
2815         }
2816
2817     }
2818
2819     //U = Uselected;
2820
2821     [CAttackListAC setSelectionIndex:crCAL];
2822     crCAL = (int)[CAttackListTV clickedRow];
2823     ATTACK *aTop = U->C.A;
2824     for(int i = 0;i < crCAL;i++){
2825         U->C.A = U->C.A->next;
2826     }
2827
2828     if(!U->C.A) {
2829         [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
2830         [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->C.S_C.MP]];
2831         [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
2832         [region setStringValue:[NSString stringWithFormat:@"陸-- 宙-- 海-- 空--"]];
2833         [crytical setStringValue:@""];
2834         [atkProperty setStringValue:@""];
2835         U->C.A = aTop;
2836         return;
2837     }
2838
2839     if(U->C.A->bullet > 0) [bullet setStringValue:[NSString stringWithFormat:@"%d／%d", U->C.A->bulletC, U->C.A->bullet]];
2840     else [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
2841     if(U->C.A->MP > 0) [costP setStringValue:[NSString stringWithFormat:@"%g（%g）", U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100+0.5), U->C.S_C.MP]];
2842     else [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->C.S_C.MP]];
2843     if(U->C.A->vigor > 0) [costV setStringValue:[NSString stringWithFormat:@"%d（%d）", U->C.A->vigor, U->C.S_C.vigor]];
2844     else [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
2845
2846     NSString *Riku, *Chu, *Umi, *Sora;
2847
2848     switch (U->C.A->riku) {
2849         case 0:
2850             Riku = [@"A" retain];
2851             break;
2852         case 1:
2853             Riku = [@"B"retain];
2854             break;
2855         case 2:
2856             Riku = [@"C"retain];
2857             break;
2858         case 3:
2859             Riku = [@"D"retain];
2860             break;
2861         case 4:
2862             Riku = [@"E"retain];
2863             break;
2864         case 5:
2865             Riku = [@"S"retain];
2866             break;
2867         case 6:
2868             Riku = [@"SS"retain];
2869             break;
2870     }
2871     switch (U->C.A->chu) {
2872         case 0:
2873             Chu = [@"A" retain];
2874             break;
2875         case 1:
2876             Chu = [@"B" retain];
2877             break;
2878         case 2:
2879             Chu = [@"C" retain];
2880             break;
2881         case 3:
2882             Chu = [@"D" retain];
2883             break;
2884         case 4:
2885             Chu = [@"E" retain];
2886             break;
2887         case 5:
2888             Chu = [@"S" retain];
2889             break;
2890         case 6:
2891             Chu = [@"SS" retain];
2892             break;
2893     }
2894     switch (U->C.A->umi) {
2895         case 0:
2896             Umi = [@"A" retain];
2897             break;
2898         case 1:
2899             Umi = [@"B" retain];
2900             break;
2901         case 2:
2902             Umi = [@"C" retain];
2903             break;
2904         case 3:
2905             Umi = [@"D" retain];
2906             break;
2907         case 4:
2908             Umi = [@"E" retain];
2909             break;
2910         case 5:
2911             Umi = [@"S" retain];
2912             break;
2913         case 6:
2914             Umi = [@"SS" retain];
2915             break;
2916     }
2917     switch (U->C.A->sora) {
2918         case 0:
2919             Sora = [@"A" retain];
2920             break;
2921         case 1:
2922             Sora = [@"B" retain];
2923             break;
2924         case 2:
2925             Sora = [@"C" retain];
2926             break;
2927         case 3:
2928             Sora = [@"D" retain];
2929             break;
2930         case 4:
2931             Sora = [@"E" retain];
2932             break;
2933         case 5:
2934             Sora = [@"S" retain];
2935             break;
2936         case 6:
2937             Sora = [@"SS" retain];
2938             break;
2939     }
2940
2941     if(!U->C.A->name){
2942         Riku = @"--";
2943         Chu = @"--";
2944         Umi = @"--";
2945         Sora = @"--";
2946     }
2947
2948     [region setStringValue:[NSString stringWithFormat:@"陸%@ 宙%@ 海%@ 空%@",  Riku, Chu, Umi, Sora]];
2949     [crytical setStringValue:@""];
2950     [atkProperty setStringValue:@""];
2951
2952     U->C.A = aTop;
2953     U = UTop;
2954 }
2955
2956 -(void)initCAttackSelect2{
2957
2958     U = UTop;
2959
2960     while (!(AUN[1] == U->number)) {
2961         U = U->next;
2962     }
2963     if(battleSet1Flag){
2964         //crCAL1 = (int)[CAttackListTV clickedRow];
2965         U = UTop;
2966         while (!(AUN[1] == U->number)) {
2967             U = U->next;
2968         }
2969     }
2970     if(battleSet2Flag){
2971         //crCAL2 = (int)[CAttackListTV clickedRow];
2972         U = UTop;
2973         while (!(DUN[1] == U->number)) {
2974             U = U->next;
2975         }
2976
2977     }
2978
2979     ATTACK *aTop = U->CL.A;
2980     for(int i = 0;i < crCAL;i++){
2981         U->CL.A = U->CL.A->next;
2982     }
2983
2984     if(!U->CL.A) {
2985
2986         U = UTop;
2987         return;
2988     }
2989     if(U->CL.A->bullet > 0) [bullet setStringValue:[NSString stringWithFormat:@"%d／%d", U->CL.A->bulletC, U->CL.A->bullet]];
2990     else [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
2991     if(U->CL.A->EN > 0) [costP setStringValue:[NSString stringWithFormat:@"%g（%g）", U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100+0.5), U->CL.S_C.EN]];
2992     else [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->CL.S_C.EN]];
2993     if(U->CL.A->vigor > 0) [costV setStringValue:[NSString stringWithFormat:@"%d（%d）", U->CL.A->vigor, U->C.S_C.vigor]];
2994     else [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
2995
2996     NSString *Riku, *Chu, *Umi, *Sora;
2997
2998     switch (U->CL.A->riku) {
2999         case 0:
3000             Riku = @"A";
3001             break;
3002         case 1:
3003             Riku = @"B";
3004             break;
3005         case 2:
3006             Riku = @"C";
3007             break;
3008         case 3:
3009             Riku = @"D";
3010             break;
3011         case 4:
3012             Riku = @"E";
3013             break;
3014         case 5:
3015             Riku = @"S";
3016             break;
3017         case 6:
3018             Riku = @"SS";
3019             break;
3020     }
3021     switch (U->CL.A->chu) {
3022         case 0:
3023             Chu = @"A";
3024             break;
3025         case 1:
3026             Chu = @"B";
3027             break;
3028         case 2:
3029             Chu = @"C";
3030             break;
3031         case 3:
3032             Chu = @"D";
3033             break;
3034         case 4:
3035             Chu = @"E";
3036             break;
3037         case 5:
3038             Chu = @"S";
3039             break;
3040         case 6:
3041             Chu = @"SS";
3042             break;
3043     }
3044     switch (U->CL.A->umi) {
3045         case 0:
3046             Umi = @"A";
3047             break;
3048         case 1:
3049             Umi = @"B";
3050             break;
3051         case 2:
3052             Umi = @"C";
3053             break;
3054         case 3:
3055             Umi = @"D";
3056             break;
3057         case 4:
3058             Umi = @"E";
3059             break;
3060         case 5:
3061             Umi = @"S";
3062             break;
3063         case 6:
3064             Umi = @"SS";
3065             break;
3066     }
3067     switch (U->CL.A->sora) {
3068         case 0:
3069             Sora = @"A";
3070             break;
3071         case 1:
3072             Sora = @"B";
3073             break;
3074         case 2:
3075             Sora = @"C";
3076             break;
3077         case 3:
3078             Sora = @"D";
3079             break;
3080         case 4:
3081             Sora = @"E";
3082             break;
3083         case 5:
3084             Sora = @"S";
3085             break;
3086         case 6:
3087             Sora = @"SS";
3088             break;
3089     }
3090
3091     if(!U->CL.A->name){
3092         Riku = @"--";
3093         Chu = @"--";
3094         Umi = @"--";
3095         Sora = @"--";
3096     }
3097
3098     [region setStringValue:[NSString stringWithFormat:@"陸%@ 宙%@ 海%@ 空%@",  Riku, Chu, Umi, Sora]];
3099     [crytical setStringValue:@""];
3100     [atkProperty setStringValue:@""];
3101
3102     U->CL.A = aTop;
3103     U = UTop;
3104 }
3105
3106
3107 -(void)doubleClickCRL:(id)sender{
3108
3109     if(crCRL == -1) return;
3110
3111     if(unitBreak->team == 0)
3112     if(P[0].resource >= BRU->S_M.cSupply && P[0].food >= BRU->S_M.cFood && P[0].money >= BRU->S_M.cMoney){
3113
3114         P[0].resource -= BRU->S_M.cSupply;
3115         P[0].food -= BRU->S_M.cFood;
3116         P[0].money -= BRU->S_M.cMoney;
3117
3118         unitNum[possionX][possionY] = BRUindex;
3119         if(researchTeam == 0) unitTeam[possionX][possionY] = 0;
3120         if(researchTeam == 2) unitTeam[possionX][possionY] = 2;
3121
3122         [self addUnitStatus];
3123
3124         unitColorInitFlag = true;
3125
3126         [researchPanel close];
3127     }
3128
3129     if(unitBreak->team == 2)
3130         if(P[1].resource >= BRU->S_M.cSupply && P[1].food >= BRU->S_M.cFood && P[1].money >= BRU->S_M.cMoney){
3131
3132             P[1].resource -= BRU->S_M.cSupply;
3133             P[1].food -= BRU->S_M.cFood;
3134             P[1].money -= BRU->S_M.cMoney;
3135
3136             unitNum[possionX][possionY] = BRUindex;
3137             if(researchTeam == 0) unitTeam[possionX][possionY] = 0;
3138             if(researchTeam == 2) unitTeam[possionX][possionY] = 2;
3139
3140             [self addUnitStatus];
3141
3142             unitColorInitFlag = true;
3143
3144             [researchPanel close];
3145         }
3146
3147 }
3148
3149 -(void)clickCRL:(id)sender{
3150
3151     crCRL = (int)[CResearchListTV clickedRow];
3152     if(crCRL < 0)
3153         return;
3154     BUILDCHIP *B;
3155
3156     B = &BC[buildNum[possionX][possionY]];
3157
3158
3159     RESEARCH *Rtop;
3160     UNITCHIP *BU;
3161
3162     Rtop = B->R;
3163     if(B->R){
3164     BU = B->R->U;
3165     BRU = BU;
3166     for(int i = 0;i <= crCRL;i++){
3167         BU = B->R->U;
3168         BRU = BU;
3169         [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", BU->S_M.ATK]];
3170         [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", BU->S_M.DEF]];
3171         [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", BU->S_M.CAP]];
3172         [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", BU->S_M.ACU]];
3173         [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", BU->S_M.EVA]];
3174         [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", BU->S_M.MOV]];
3175         [researchIMG setImage:BU->imgb];
3176         [researchIMG setImageScaling:NSScaleToFit];
3177
3178         B->R = B->R->next;
3179     }
3180     B->R = Rtop;
3181         BRUindex = 0;
3182     for (int i = 0; BRU->nameID != UC[i].nameID && i < UCN;i++) {
3183         BRUindex++;
3184
3185     }
3186         return;
3187     }
3188
3189     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
3190
3191         int k = 0;
3192         B->R = Rtop;
3193         while (B->R) {
3194             B->R = B->R->next;
3195             k++;
3196         }
3197
3198         for(int i = k;i <= crCRL;i++){
3199
3200             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ATK]];
3201             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.DEF]];
3202             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.CAP]];
3203             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ACU]];
3204             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.EVA]];
3205             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp1 + i - k)-1].S_M.MOV]];
3206             [researchIMG setImage:UC[*(GuildDisp1 + i - k)-1].imgb];
3207             [researchIMG setImageScaling:NSScaleToFit];
3208
3209         }B->R = Rtop;
3210
3211         BRUindex = 0;
3212         for (int i = 0; UC[*(GuildDisp1 + crCRL - k)-1].nameID != UC[i].nameID && i < UCN;i++) {
3213             BRUindex++;
3214         }BRU = &UC[BRUindex];
3215
3216
3217
3218     }else if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
3219
3220         int k = 0;
3221         B->R = Rtop;
3222         while (B->R) {
3223             B->R = B->R->next;
3224             k++;
3225         }
3226
3227         for(int i = k;i <= crCRL;i++){
3228
3229             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ATK]];
3230             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.DEF]];
3231             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.CAP]];
3232             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ACU]];
3233             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.EVA]];
3234             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp2 + i - k)-1].S_M.MOV]];
3235             [researchIMG setImage:UC[*(GuildDisp2 + i - k)-1].imgb];
3236             [researchIMG setImageScaling:NSScaleToFit];
3237
3238         }B->R = Rtop;
3239
3240
3241         BRUindex = 0;
3242         for (int i = 0; UC[*(GuildDisp2 + crCRL - k)-1].nameID != UC[i].nameID && i < UCN;i++) {
3243             BRUindex++;
3244         }BRU = &UC[BRUindex];
3245     }
3246
3247
3248
3249
3250
3251    }
3252
3253 -(void)SetStatusFunc{
3254     double STRfix;
3255     double VITfix;
3256     double AGIfix;
3257     double DEXfix;
3258     double MENfix;
3259     double INTfix;
3260     double LUKfix;
3261
3262     double S, V, A, D, M, I;
3263
3264
3265
3266     U = UTop;
3267
3268     while(U){
3269     STRfix = (
3270               U->C.eHandL.STR +
3271               U->C.eHandR.STR +
3272               U->C.eHead.STR +
3273               U->C.eBody.STR +
3274               U->C.eFoot.STR +
3275               U->C.eArm.STR) +
3276     U->C.S_M.STR *(
3277                          U->C.eHandL.pSTR +
3278                          U->C.eHandR.pSTR +
3279                          U->C.eHead.pSTR +
3280                          U->C.eBody.pSTR +
3281                          U->C.eFoot.pSTR +
3282                          U->C.eArm.pSTR +
3283                          0)/100
3284     ;
3285
3286     VITfix = (
3287               U->C.eHandL.VIT +
3288               U->C.eHandR.VIT +
3289               U->C.eHead.VIT +
3290               U->C.eBody.VIT +
3291               U->C.eFoot.VIT +
3292               U->C.eArm.VIT) +
3293     U->C.S_M.VIT *(
3294                          U->C.eHandL.pVIT +
3295                          U->C.eHandR.pVIT +
3296                          U->C.eHead.pVIT +
3297                          U->C.eBody.pVIT +
3298                          U->C.eFoot.pVIT +
3299                          U->C.eArm.pVIT +
3300                          0)/100
3301     ;
3302     AGIfix = (
3303               U->C.eHandL.AGI +
3304               U->C.eHandR.AGI +
3305               U->C.eHead.AGI +
3306               U->C.eBody.AGI +
3307               U->C.eFoot.AGI +
3308               U->C.eArm.AGI) +
3309     U->C.S_M.AGI *(
3310                          U->C.eHandL.pAGI +
3311                          U->C.eHandR.pAGI +
3312                          U->C.eHead.pAGI +
3313                          U->C.eBody.pAGI +
3314                          U->C.eFoot.pAGI +
3315                          U->C.eArm.pAGI +
3316                          0)/100
3317     ;
3318     DEXfix = (
3319               U->C.eHandL.DEX +
3320               U->C.eHandR.DEX +
3321               U->C.eHead.DEX +
3322               U->C.eBody.DEX +
3323               U->C.eFoot.DEX +
3324               U->C.eArm.DEX) +
3325     U->C.S_M.DEX *(
3326                          U->C.eHandL.pDEX +
3327                          U->C.eHandR.pDEX +
3328                          U->C.eHead.pDEX +
3329                          U->C.eBody.pDEX +
3330                          U->C.eFoot.pDEX +
3331                          U->C.eArm.pDEX +
3332                          0)/100
3333     ;
3334     MENfix = (
3335               U->C.eHandL.MEN +
3336               U->C.eHandR.MEN +
3337               U->C.eHead.MEN +
3338               U->C.eBody.MEN +
3339               U->C.eFoot.MEN +
3340               U->C.eArm.MEN) +
3341     U->C.S_M.MEN *(
3342                          U->C.eHandL.pMEN +
3343                          U->C.eHandR.pMEN +
3344                          U->C.eHead.pMEN +
3345                          U->C.eBody.pMEN +
3346                          U->C.eFoot.pMEN +
3347                          U->C.eArm.pMEN +
3348                          0)/100
3349     ;
3350     INTfix = (
3351               U->C.eHandL.INT +
3352               U->C.eHandR.INT +
3353               U->C.eHead.INT +
3354               U->C.eBody.INT +
3355               U->C.eFoot.INT +
3356               U->C.eArm.INT) +
3357     U->C.S_M.INT *(
3358                          U->C.eHandL.pINT +
3359                          U->C.eHandR.pINT +
3360                          U->C.eHead.pINT +
3361                          U->C.eBody.pINT +
3362                          U->C.eFoot.pINT +
3363                          U->C.eArm.pINT +
3364                          0)/100
3365     ;
3366     LUKfix = (
3367               U->C.eHandL.LUK +
3368               U->C.eHandR.LUK +
3369               U->C.eHead.LUK +
3370               U->C.eBody.LUK +
3371               U->C.eFoot.LUK +
3372               U->C.eArm.LUK) +
3373     U->C.S_M.LUK *(
3374                          U->C.eHandL.pLUK +
3375                          U->C.eHandR.pLUK +
3376                          U->C.eHead.pLUK +
3377                          U->C.eBody.pLUK +
3378                          U->C.eFoot.pLUK +
3379                          U->C.eArm.pLUK +
3380                          0)/100
3381     ;
3382
3383     S = U->C.S_C.STR + STRfix;
3384     V = U->C.S_C.VIT + VITfix;
3385     A = U->C.S_C.AGI + AGIfix;
3386     D = U->C.S_C.DEX + DEXfix;
3387     M = U->C.S_C.MEN + MENfix;
3388     I = U->C.S_C.INT + INTfix;
3389
3390     U->C.S_C.ATK = (S*5 + D*2 + A)/8;
3391     U->C.S_C.DEF = (V*5 + M*2 + S)/8;
3392     U->C.S_C.CAP = (I*4 + D*1 + M*2)/7;
3393     U->C.S_C.ACU = (D*4 + A*1 + M)/6;
3394     U->C.S_C.EVA = (A*4 + A*1 + M)/6;
3395
3396         U->C.S_C.ATK += 0.5;
3397         U->C.S_C.DEF += 0.5;
3398         U->C.S_C.CAP += 0.5;
3399         U->C.S_C.ACU += 0.5;
3400         U->C.S_C.EVA += 0.5;
3401
3402         U->C.S_C.ATK = floor(U->C.S_C.ATK);
3403         U->C.S_C.DEF = floor(U->C.S_C.DEF);
3404         U->C.S_C.CAP = floor(U->C.S_C.CAP);
3405         U->C.S_C.ACU = floor(U->C.S_C.ACU);
3406         U->C.S_C.EVA = floor(U->C.S_C.EVA);
3407
3408         U = U->next;
3409     }U = UTop;
3410
3411 }
3412
3413 -(void)initMapscript{
3414
3415     for(int i = 0;i < 9999;i++){
3416         Suicchi[i] = false;
3417     }
3418
3419     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
3420     MAPSCRIPTD *MSDtop = MS.D;
3421
3422     if(!MS.D) return;
3423     MAPSCRIPT0 *MSDPt = MS.D->P;
3424
3425     while(MS.D){
3426         MS.D->endFlag = false;
3427
3428
3429         double deltaET = floor(MS.D->ET2) - floor(MS.D->ET1);
3430         int deltaR = 0;
3431         if(deltaET < 0) deltaET = 0;
3432
3433         if(MS.D->ET1 <= eventTime && MS.D->ET2 >= eventTime){
3434             if(deltaET > 0) deltaR = rand()%(int)deltaET;
3435         }
3436
3437         MS.D->ET3 = MS.D->ET1 + (double)deltaR;
3438         MS.D->ET4 = MS.D->ET3;
3439
3440         MSDPt = MS.D->P;
3441         while (MS.D->P) {
3442                 MS.D->P->endFlag = false;
3443             MS.D->P = MS.D->P->next;
3444         }MS.D->P = MSDPt;
3445
3446         MS.D = MS.D->next;
3447     }
3448
3449     MS.D = MSDtop;
3450
3451     MSDTO = MSDtop;
3452     MF[MFselectedRow+1].MS = MS;
3453
3454     [self HensuuLoad];
3455 }
3456
3457 -(void)EventLoopFS:(NSTimer*)time{
3458
3459     if(openingAVP && openingAVPVisActive){
3460         if(openingAVP.rate <= 0 || openingAVPisDeactive){
3461             [openingAVP pause];
3462             openingAVPVisHidden = true;
3463             [self openingAVPVfunc];
3464             openingAVPVisActive = false;
3465             openingAVPisDeactive = false;
3466             if(titleBGM) [titleBGM play];
3467         }
3468     }else if(!openingAVP && openingAVPVisActive){
3469         openingAVPVisActive = false;
3470         openingAVPisDeactive = false;
3471         if(titleBGM) [titleBGM play];
3472     }
3473
3474
3475     //NSLog(@"msgCnt %d", msgCnt);
3476
3477     if(stopByFSVmenuFlag){
3478         [FSMenu makeKeyAndOrderFront:nil];
3479         [menuPanel close];
3480         moveFlag = false;
3481         attackFlag = false;
3482         summonFlag = false;
3483         menuDisplayFlag = false;
3484     }
3485
3486     if(saveDataLoadedFlag)
3487         return;
3488
3489     U = UTop;
3490     if(U){
3491     U = UTop;
3492     for(int i = 0;i < DUN[1];i++){
3493
3494         U = U->next;
3495     }
3496
3497     //NSLog(@"%d, %d", MF[0].MS.playerSet1, sdd2[0].MS.playerSet1);
3498
3499     //if(Utarget) NSLog(@"PX %d PY %d UX %d UY %d", possionX, possionY, Utarget->x, Utarget->y);
3500         U = UTop;
3501     }
3502
3503     if(coolTime){
3504
3505         lmao++;
3506
3507         if(lmao > 20){
3508             coolTime = false;
3509             lmao = 0;
3510         }
3511
3512     }
3513
3514     if(!fuckingLoadBugFix){
3515         battleRdy = false;
3516         [battleWindow close];
3517     }
3518
3519     if(extentBattleFlag){
3520         if(!battleSetUp){
3521             battleSetUp = true;
3522             attackingWait = true;
3523             goto ahhh;
3524         }
3525         if(!battleSetUpIgnore){
3526
3527             battleRdy = false;
3528             battleSet1Flag = false;
3529             battleSet2Flag = false;
3530             battleSettingFlag = false;
3531         extentBattleFlag = false;
3532             extentBattleFlag2 = true;
3533         }
3534     }
3535     if(cpuAtkExtendFlag2){
3536         if(!battleSetUp){
3537             battleSetUp = true;
3538             attackingWait = true;
3539             goto ahhh;
3540         }
3541         if(!battleSetUpIgnore){
3542
3543
3544             battleRdy = false;
3545             battleSet1Flag = false;
3546             battleSet2Flag = false;
3547             battleSettingFlag = false;
3548         extentBattleFlag = false;
3549         extentBattleFlag2 = true;
3550         cpuAtkExtendFlag2 = false;
3551         [battlePanel close];
3552         }
3553     }if(extentBattleFlag2){
3554         battleFlag = false;
3555     }
3556
3557 ahhh:{}
3558     if(setBattleModeFlag){
3559         if(!battleReadyUpFlag){battleReadyUpFlag = true;
3560
3561             P[0].resource = 500;
3562             P[0].food = 500;
3563             P[0].money = 500;
3564             P[1].resource = 500;
3565             P[1].food = 500;
3566             P[1].money = 500;
3567             P[2].resource = 500;
3568             P[2].food = 500;
3569             P[2].money = 500;
3570
3571         [battleReadyUpPN1 setStringValue:P[0].name];
3572         [battleReadyUpPN2 setStringValue:P[1].name];
3573
3574         NSString *string = @"";
3575         string = [string stringByAppendingFormat:@"%@の勝利条件\n", P[0].name];
3576         if(MF[MFselectedRow+1].MS.EGClight.endType1 == 1){
3577            string = [string stringByAppendingString:@"敵の壊滅\n"];
3578
3579         }else if(MF[MFselectedRow+1].MS.EGClight.endType1 == 2){
3580             string = [string stringByAppendingString:@"味方の壊滅\n"];
3581
3582         }
3583
3584         string = [string stringByAppendingString:@"\n"];
3585
3586         string = [string stringByAppendingFormat:@"%@の勝利条件\n", P[1].name];
3587         if(MF[MFselectedRow+1].MS.EGCdark.endType1 == 2){
3588             string = [string stringByAppendingString:@"敵の壊滅\n"];
3589         }else if(MF[MFselectedRow+1].MS.EGClight.endType1 == 1){
3590             string = [string stringByAppendingString:@"味方の壊滅\n"];
3591
3592         }
3593
3594
3595         [battleReadyUpSupply1 setIntValue:P[0].resource];
3596         [battleReadyUpFood1 setIntValue:P[0].food];
3597         [battleReadyUpMoney1 setIntValue:P[0].money];
3598
3599         [battleReadyUpSupply2 setIntValue:P[1].resource];
3600         [battleReadyUpFood2 setIntValue:P[1].food];
3601         [battleReadyUpMoney2 setIntValue:P[1].money];
3602
3603         if(MF[MFselectedRow+1].MS.playerSet1 == 1){
3604             [battleReadyUpMAN1A setEnabled:NO];
3605             [battleReadyUpMAN1B setEnabled:NO];
3606             [battleReadyUpMAN1A setState:1];
3607             [battleReadyUpMAN1B setState:0];
3608         }else if(MF[MFselectedRow+1].MS.playerSet1 == 2){
3609             [battleReadyUpMAN1A setEnabled:NO];
3610             [battleReadyUpMAN1B setEnabled:NO];
3611             [battleReadyUpMAN1A setState:0];
3612             [battleReadyUpMAN1B setState:1];
3613         }else{
3614             MF[MFselectedRow+1].MS.playerSet1 = 1;
3615             [battleReadyUpMAN1A setEnabled:YES];
3616             [battleReadyUpMAN1B setEnabled:YES];
3617             [battleReadyUpMAN1A setState:1];
3618             [battleReadyUpMAN1B setState:0];
3619         }
3620
3621         if(MF[MFselectedRow+1].MS.playerSet2 == 1){
3622             [battleReadyUpMAN2A setEnabled:NO];
3623             [battleReadyUpMAN2B setEnabled:NO];
3624             [battleReadyUpMAN2A setState:1];
3625             [battleReadyUpMAN2B setState:0];
3626         }else if(MF[MFselectedRow+1].MS.playerSet2 == 2){
3627             [battleReadyUpMAN2A setEnabled:NO];
3628             [battleReadyUpMAN2B setEnabled:NO];
3629             [battleReadyUpMAN2A setState:0];
3630             [battleReadyUpMAN2B setState:1];
3631         }else{
3632             MF[MFselectedRow+1].MS.playerSet2 = 1;
3633             [battleReadyUpMAN2A setEnabled:YES];
3634             [battleReadyUpMAN2B setEnabled:YES];
3635             [battleReadyUpMAN2A setState:1];
3636             [battleReadyUpMAN2B setState:0];
3637         }
3638
3639         }
3640
3641         if(retardhelp1){
3642             if([battleReadyUpMAN1A state] != 0)
3643                 MF[MFselectedRow+1].MS.playerSet1 = 1;
3644             else
3645                 MF[MFselectedRow+1].MS.playerSet1 = 2;
3646             retardhelp1 = false;
3647         }
3648         if(retardhelp2){
3649             if([battleReadyUpMAN2A state] != 0)
3650                 MF[MFselectedRow+1].MS.playerSet2 = 1;
3651             else
3652                 MF[MFselectedRow+1].MS.playerSet2 = 2;
3653             retardhelp2 = false;
3654         }
3655
3656         return;
3657     }
3658
3659
3660
3661     if(buildNum[possionX][possionY] < 0){
3662         [selectMesh setImage:MC[chipNum[possionX][possionY]].img];
3663         [selectMeshText setStringValue:MC[chipNum[possionX][possionY]].name];
3664         [selectMeshValue setStringValue:[NSString stringWithFormat:@"%d％", MC[chipNum[possionX][possionY]].dmgfix]];
3665     }else{
3666         [selectMesh setImage:BC[buildNum[possionX][possionY]].img];
3667         [selectMeshText setStringValue:BC[buildNum[possionX][possionY]].name];
3668         [selectMeshValue setStringValue:[NSString stringWithFormat:@"%d％", BC[buildNum[possionX][possionY]].dmgfix]];
3669     }
3670     [self SetStatusFunc];
3671
3672
3673     if(initStatusFlag){
3674
3675
3676         if(1){
3677
3678
3679
3680
3681             if(Uselected){
3682             if(Uselected->chipNumberL < 0){
3683             if(!Uselected->dead){
3684
3685                 if(Uselected->team == 0){
3686                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[0].name]];
3687                 }
3688                 if(Uselected->team == 2){
3689                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[1].name]];
3690                 }
3691                 if(Uselected->team == 1){
3692                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[2].name]];
3693                 }
3694
3695                 [tfName setStringValue:[NSString stringWithFormat:@"%@", Uselected->C.name]];
3696                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP %g/%g", Uselected->C.S_C.HP, Uselected->C.S_M.HP]];
3697                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"%g", Uselected->C.S_C.HP/Uselected->C.S_M.HP*100 + 0.5] intValue]];
3698                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP %g/%g", Uselected->C.S_C.MP, Uselected->C.S_M.MP]];
3699                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 %g", Uselected->C.S_C.ATK]];
3700                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 %g", Uselected->C.S_C.DEF]];
3701                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 %g", Uselected->C.S_C.CAP]];
3702                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 %g", Uselected->C.S_C.ACU]];
3703                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 %g", Uselected->C.S_C.EVA]];
3704                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 %d", Uselected->C.S_C.MOV]];
3705                 [tfWait setStringValue:[NSString stringWithFormat:@"WT %g", Uselected->C.S_C.WT]];
3706                 [selectChara setImage:Uselected->C.imgb];
3707                 [selectChara setImageScaling:NSScaleToFit];
3708
3709
3710
3711             }else{
3712                 [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3713                 [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3714                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3715                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3716                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3717                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3718                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3719                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3720                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3721                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3722                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3723                 [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3724                 [selectChara setImage:NULL];
3725
3726
3727             }
3728             }else{
3729                 if(!Uselected->dead){
3730
3731                     if(Uselected->team == 0){
3732                         [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[0].name]];
3733                     }
3734                     if(Uselected->team == 2){
3735                         [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[1].name]];
3736                     }
3737
3738                     [tfName setStringValue:[NSString stringWithFormat:@"%@", Uselected->CL.name]];
3739                     [HPbarTF setStringValue:[NSString stringWithFormat:@"HP %g/%g", Uselected->CL.S_C.HP, Uselected->CL.S_M.HP]];
3740                     [HPbarLI setIntValue:[[NSString stringWithFormat:@"%g", Uselected->CL.S_C.HP/Uselected->CL.S_M.HP*100 + 0.5] intValue]];
3741                     [MPbarTF setStringValue:[NSString stringWithFormat:@"EN %g/%g", Uselected->CL.S_C.EN, Uselected->CL.S_M.EN]];
3742                     [tfAttack setStringValue:[NSString stringWithFormat:@"移動力 %d", Uselected->CL.S_C.MOV]];
3743                     [tfDefence setStringValue:[NSString stringWithFormat:@"運動性 %g", Uselected->CL.S_C.MOB]];
3744                     [tfCalc setStringValue:[NSString stringWithFormat:@"装甲 %g", Uselected->CL.S_C.ARM]];
3745                     [tfHit setStringValue:[NSString stringWithFormat:@"限界 %g", Uselected->CL.S_C.LIM]];
3746                     [tfDodge setStringValue:[NSString stringWithFormat:@""]];
3747                     [tfMove setStringValue:[NSString stringWithFormat:@""]];
3748                     [tfWait setStringValue:[NSString stringWithFormat:@"WT %g", Uselected->CL.S_C.WT]];
3749                     [selectChara setImage:Uselected->CL.imgb];
3750                     [selectChara setImageScaling:NSScaleToFit];
3751
3752
3753                 }else{
3754                     [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3755                     [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3756                     [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3757                     [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3758                     [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3759                     [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3760                     [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3761                     [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3762                     [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3763                     [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3764                     [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3765                     [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3766                     [selectChara setImage:NULL];
3767
3768                 }
3769
3770
3771
3772             }
3773             }else{
3774                 [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3775                 [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3776                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3777                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3778                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3779                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3780                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3781                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3782                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3783                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3784                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3785                 [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3786                 [selectChara setImage:NULL];
3787
3788             }
3789         }
3790
3791     }
3792
3793     if(unitBreak){
3794     if(unitBreak->team == 0){
3795         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[0].resource]];
3796         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[0].food]];
3797         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[0].money]];
3798     }else if(unitBreak->team == 2){
3799         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[1].resource]];
3800         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[1].food]];
3801         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[1].money]];
3802     }else if(unitBreak->team == 1){
3803         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[2].resource]];
3804         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[2].food]];
3805         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[2].money]];
3806     }
3807     }
3808
3809     if(menuDisplayFlag){
3810         [self SetMenu];
3811         [self initBCreateList];
3812         [self initCSummonList];
3813     }
3814
3815     if(initMapFlag && datFileLoadCompFromTitle && !saveDataLoadedFlag){
3816
3817         mouseDoubleClickedCnt = 0;
3818         mouseDoubleClickedFlag = false;
3819         mouseClicked = false;
3820         messageDialog = false;
3821
3822         for(int i = 0;i<=1000;i++){
3823             for(int j = 0;j<= 1000;j++){
3824                 buildNum[i][j] = -1;
3825                 unitNum[i][j] = -1;
3826                 loadNum[i][j] = -1;
3827                 buildTeam[i][j] = -1;
3828                 unitTeam[i][j] = -1;
3829             }
3830         }
3831
3832         [self initUnitStatusDat];
3833         //NSLog(@"%d, %d", unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3834         [self initBuildStatusDat];
3835         msgCnt = 0;
3836         msgLvl = 0;
3837         msgLvlMax = 0;
3838         initImgFlag = false;
3839         initStringNum = false;
3840         bugFixFlag1 = false;
3841         bugFixFlag2 = false;
3842         bugFixFlag3 = false;
3843
3844         eventTime = 0;
3845         coolTime = true;
3846
3847         wtRdy = false;
3848         wtRdy2 = false;
3849         wtRdy3 = false;
3850
3851         //ここに進行したマップスクリプト値関数
3852         //NSLog(@"%d, %d", unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3853         [self setTargetListDat];
3854         [self initGuildList];
3855
3856         for(int i = 0;i < 255;i++){
3857             AUN[i] = 0;
3858             DUN[i] = 0;
3859         }
3860         cpuTurnEndFlag = false;
3861         mapChipDataLoadProc = 0;
3862
3863         U = UTop;
3864         unitBreak = U;
3865
3866         battleEndFlag = false;
3867         initStatusFlag = true;
3868         TeamCountFlag = true;
3869         cpuTurnEndFlag = false;
3870         unitColorInitFlag = true;
3871         initMapEventFlag = true;
3872         fieldViewBattleInitFlag = true;
3873         MF[MFselectedRow+1].MS = sdd2[datRow].MS;
3874         MF[MFselectedRow+1].MS.D = sdd2[datRow].MS.D;
3875         MSDTOPP = sdd2[datRow].MS.D;
3876         MSDTOP = sdd2[datRow].MS.D;
3877         msdtop = sdd2[datRow].MS.D;
3878         MSDTO = sdd2[datRow].MS.D;
3879
3880         //if(UTop) NSLog(@"%d, %d, %d", UTop->CPU, unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3881         datFileLoadCompFromTitle = false;
3882
3883         BGMsub = NULL;
3884         SEsub = NULL;
3885     }else if (initMapFlag && !initStatusFlag) {
3886         registerNum = 0;
3887         registerNumB = 0;
3888         mouseDoubleClickedCnt = 0;
3889         mouseDoubleClickedFlag = false;
3890         mouseClicked = false;
3891
3892         wtRdy = false;
3893         wtRdy2 = false;
3894         wtRdy3 = false;
3895         battleEndFlag = false;
3896
3897
3898         [self initUnitStatus];
3899         [self initBuildStatus];
3900
3901         //NSLog(@"%d", unitNum[1][1]);
3902         U = UTop;
3903
3904         while (U != NULL) {
3905             U->C.S_C.HP = U->C.S_M.HP;
3906
3907             U = U->next;
3908         }
3909         U = UTop;
3910
3911         initStatusFlag = true;
3912         unitBreak = U;
3913         TeamCountFlag = true;
3914
3915         unitColorInitFlag = true;
3916
3917         MFselectedRow = 0;
3918         for (int i = 1;i < 512;i++) {
3919             if([[SC[storyNumb].nameMAP objectAtIndex:scenarioNumb] isEqualToString:[NSString stringWithFormat:@"%@", MF[i].fileName]])
3920                 break;
3921             MFselectedRow++;
3922         }if(MFselectedRow > 510){
3923             MFselectedRow = 0;
3924             mapChipDataLoadFail = true;
3925         }
3926
3927         [self initMapscript];
3928         msgLvl = 0;
3929         msgLvlMax = 0;
3930         initImgFlag = false;
3931         initStringNum = false;
3932         bugFixFlag1 = false;
3933         bugFixFlag2 = false;
3934         bugFixFlag3 = false;
3935
3936         eventTime = 0;
3937         coolTime = true;
3938
3939         [self setTargetList];
3940
3941
3942         initMapEventFlag = true;
3943         fieldViewBattleInitFlag = true;
3944
3945
3946         for(int i = 0;i < 255;i++){
3947             AUN[i] = 0;
3948             DUN[i] = 0;
3949         }
3950
3951         [self initGuildList];
3952         cpuTurnEndFlag = false;
3953         mapChipDataLoadProc = 0;
3954     }
3955
3956     if(mapChipDataLoadFail){
3957         [endGamePanel close];
3958
3959         endGameCondition = false;
3960         initMapFlag = false;
3961         TeamCountFlag = false;
3962         initStatusFlag = false;
3963         battleBegin = false;
3964         startES = true;
3965
3966         redWinFlag = false;
3967         blueWinFlag = false;
3968         battleFlag = false;
3969         battleRdy = false;
3970
3971         mapChipDataLoadFail = false;
3972
3973         [fsWindow close];
3974
3975         esSceneProc = 0;
3976
3977         [BGMsub stop];
3978         BGMsub = NULL;
3979
3980         endGameCondition = false;
3981         initMapFlag = false;
3982         TeamCountFlag = false;
3983         initStatusFlag = false;
3984         battleBegin = false;
3985         startES = true;
3986
3987         cpuModeMOVEflag = false;
3988         cpuModeATTACKflag = false;
3989
3990         redWinFlag = false;
3991         blueWinFlag = false;
3992         cpuAImodeflag = false;
3993         cpuTurnEndFlag = true;
3994         stageClearFlag = false;
3995         waitSwtichFlag = false;
3996         battleReadyUpFlag = false;
3997         setBattleModeFlag = false;
3998
3999         wtRdy = false;
4000         wtRdy2 = false;
4001
4002
4003         Uselected = NULL;
4004         return;
4005     }else if(initMapFlag){
4006         mapChipDataLoadProc++;
4007     }
4008
4009     if(mapChipDataLoadProc > 2)
4010         mapChipDataLoadProc = 2;
4011
4012     if(mapChipDataLoadProc == 1){
4013         [fsWindow makeKeyAndOrderFront:nil];
4014         [esWindow close];
4015         [titleWindow close];
4016         mapChipDataLoadProc++;
4017     }
4018
4019     if(unitBreak){
4020         if(unitBreak->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2){
4021             unitBreak->CPU = true;
4022             cpuAImodeflag = true;
4023             //NSLog(@"OMFG");
4024         }else if(unitBreak->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2){
4025             unitBreak->CPU = true;
4026             cpuAImodeflag = true;
4027             //NSLog(@"OMFG");
4028         }else if(unitBreak->team == 1){
4029             unitBreak->CPU = true;
4030             cpuAImodeflag = true;
4031             //NSLog(@"OMFG");
4032         }
4033         else{
4034             unitBreak->CPU = false;
4035             cpuAImodeflag = false;
4036         }
4037     }
4038
4039
4040     if(cpuAImodeflag){
4041         if(!cpuTurnEndFlag && unitBreak->C.S_C.WT == 0){
4042             [fieldView modeCPUturn];
4043             CPUturn = true;
4044             //NSLog(@"%d", U->x);
4045         }else{
4046             CPUturn = false;
4047         }
4048
4049     }else{
4050         CPUturn = false;
4051     }
4052
4053
4054     //NSLog(@"%p", UTop);
4055     if(battleWindowFlag){battleFlag = true; battleWindowFlag = false;
4056
4057     }
4058
4059     if(extentBattleFlag || cpuAtkExtendFlag2){
4060         if(!attackExtentFlag && !cpuAtkExtendFlag2)
4061             attackingWait = true;
4062         else
4063             attackingWait = false;
4064         if(battleRdy)
4065             attackingWait = true;
4066      }
4067
4068     while(1){
4069         if(battleFlag && !battleSetUp){
4070
4071             if(Utarget && !battleRdy)
4072                 if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4073                     (unitBreak->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4074                     (unitBreak->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4075                     (unitBreak->team == 1)
4076                    ){
4077
4078                     //おまんこかわいい
4079
4080                     vaginaCnt++;
4081                     if(vaginaCnt > 50){
4082                         [self battleStartCPU];//攻撃目標ウェイト
4083                         attackingWait = true;
4084                         vaginaCnt = 0;
4085                         oopsCnt = 80;
4086
4087                         if(attackExtentFlag || cpuAtkExtendFlag){
4088                             attackingWait = false;
4089                         }
4090                     }else
4091                         return;
4092                 }
4093
4094         }
4095
4096         break;
4097     }
4098
4099     if(initMapFlag && battleFlag)
4100         if((!attackExtentFlag && !cpuAtkExtendFlag))
4101             if(!battleSettingFlag && attackingWait){
4102                 windowPoint.x = [mapWindow frame].origin.x;
4103                 windowPoint.y = [mapWindow frame].origin.y;
4104                 [battlePanel setFrameOrigin:windowPoint];
4105                 [battlePanel makeKeyAndOrderFront:nil];
4106                 [self setBattlePanel];
4107             }
4108
4109     if(Utarget && attackingWait){
4110
4111         if(battleSetUp && ((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4112             (unitBreak->team == 2 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet2 == 2) || (unitBreak->team == 1 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4113             (unitBreak->team == 0 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet1 == 2) || (unitBreak->team == 1 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4114             (unitBreak->team == 1 && Utarget->team == 1) ||
4115             (unitBreak->team == 2 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4116             (unitBreak->team == 0 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2)
4117             )
4118            ){
4119             if(!animationFlag1 && !animationFlag2)
4120                 oopsCnt--;
4121             if(oopsCnt > 0)
4122                 return;
4123             else{
4124                 oopsCnt = 30;//cpu攻撃設定
4125             }
4126
4127             //battleFlag = false;
4128             battleRdy = false;
4129             battleSet1Flag = false;
4130             battleSet2Flag = false;
4131             battleSettingFlag = false;
4132             attackingWait = false;
4133
4134         }
4135     }
4136
4137
4138     if(Utarget){
4139         if(battleRdy && ((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) || (unitBreak->team == 2 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet2 == 2) || (unitBreak->team == 1 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4140             (unitBreak->team == 0 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet1 == 2) || (unitBreak->team == 1 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4141             (unitBreak->team == 1 && Utarget->team == 1) ||
4142             (unitBreak->team == 2 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4143             (unitBreak->team == 0 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2)
4144             )
4145            ){
4146
4147             if(!Uselected)
4148                 oopsCnt = 30;
4149
4150             if(!(AVpreview.rate > 0) && !animationFlag1 && !animationFlag2)
4151                 oopsCnt--;
4152             if(oopsCnt > 0)
4153                 return;
4154             else{
4155                 //cpu攻撃ナビ
4156             }
4157
4158             bLoopFlag = false;
4159         }
4160     }
4161     damnitFixFlag = true;
4162     if(!datFileLoadCompFromTitle && initMapFlag){
4163         [self EventFunc:true];
4164         if(crapBugFixFlag){
4165             crapBugFixFlag = false;
4166             return;
4167         }
4168     }
4169
4170     if(damnitFixFlag)
4171     if(battleSetUp && fuckingLoadBugFix && Uselected && !attackingWait){
4172         if(!battleSetUpIgnore && fuckingLoadBugFix){
4173             [self AttackDisplay];
4174
4175             windowPoint.x = [mapWindow frame].origin.x;
4176             windowPoint.y = [mapWindow frame].origin.y;
4177             [battleWindow setFrameOrigin:windowPoint];
4178             [battleWindow makeKeyAndOrderFront:nil];
4179         }else if(battleSetUpIgnore){
4180             [mapWindow makeKeyAndOrderFront:nil];
4181         }else{
4182             /*
4183             windowPoint.x = [mapWindow frame].origin.x;
4184             windowPoint.y = [mapWindow frame].origin.y;
4185             [battleWindow setFrameOrigin:windowPoint];
4186             [battleWindow makeKeyAndOrderFront:nil];*/
4187
4188         }
4189
4190     }
4191
4192     U = UTop;
4193
4194     if(battleRdy && battleSetUp && fuckingLoadBugFix && !battleSetUpIgnore){
4195         [self DisplayMessage];
4196     }
4197
4198     if(wtRdy3)
4199         return;
4200     U = UTop;
4201     U = unitBreak;
4202     if(battleBegin && !wtRdy2 && !battleFlag)
4203         while (!wtRdy) {
4204             wtPx = 0;
4205             wtPy = 0;
4206             //NSLog(@"eventTime%g", eventTime);
4207
4208             while (U) {
4209                 if(!U->dead && U->C.S_C.WT > 0) U->C.S_C.WT -= 1;
4210                 if(U->dead) {
4211                     U->C.S_C.WT = 999999;
4212                     //goto lolwtfshit;
4213                 }
4214                 if(U->C.S_C.WT <= 0 && !U->dead){//WTターン周り
4215                     battleEndFlag = false;
4216                     U->C.S_C.WT = 0;
4217
4218
4219                     wtUnitNum = U->number;
4220                     wtPx = U->x;
4221                     wtPy = U->y;
4222                     wtRdy = true;
4223                     wtRdy2 = true;
4224                     unitBreak = U;
4225                     Uselected = U;
4226                     possionX = unitBreak->x;
4227                     possionY = unitBreak->y;
4228                     //おまんちん
4229                     stanbyFlag = false;
4230                     wtMovedFlag = false;
4231                     wtAttackedFlag = false;
4232                     guildRE1 = false;
4233                     guildRE2 = false;
4234
4235                     [fieldView scrollPoint:NSMakePoint((wtPx-8)*32, (wtPy-8)*32)];
4236
4237
4238                     if(buildNum[U->x][U->y] >= 0){
4239                         B = BTop;
4240                         while(B){
4241
4242                             if(B->x == U->x && B->y == U->y){
4243                                 break;
4244                             }
4245                             B = B->next;
4246                         }
4247
4248                         if(!B){
4249                             B = BTop;
4250                             goto wtfshit;
4251
4252                         }
4253
4254                         if(B->C.recHP > 0){
4255                             U->C.S_C.HP += floor(U->C.S_M.HP*B->C.recHP/100);
4256                             if(U->C.S_C.HP >= U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
4257                         }
4258
4259                         if(B->C.recMP > 0){
4260                             U->C.S_C.MP += floor(U->C.S_M.MP*B->C.recMP/100);
4261                             if(U->C.S_C.MP >= U->C.S_M.MP) U->C.S_C.MP = U->C.S_M.MP;
4262                         }
4263
4264                         if(B->C.recEN > 0){
4265                             U->CL.S_C.EN += floor(U->CL.S_M.EN*B->C.recEN/100);
4266                             if(U->CL.S_C.EN >= U->CL.S_M.EN) U->CL.S_C.EN = U->CL.S_M.EN;
4267                         }
4268
4269                         if(B->C.recHPL > 0){
4270                             U->CL.S_C.HP += floor(U->CL.S_M.HP*B->C.recHPL/100);
4271                             if(U->CL.S_C.HP >= U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
4272                         }
4273
4274
4275                         B = BTop;
4276                     }
4277
4278                     eventTime++;
4279                     U = UTop;
4280
4281                     [self EventFunc:false];
4282                     pussyCumsOnlyOnceFlag = false;
4283
4284                     goto lolwtfshit;
4285                 }
4286
4287             wtfshit:{}
4288
4289                 U = U->next;
4290                 if(!U) {
4291                     BTop = B;
4292                     while(B){
4293                         if(!B->dead) B->C.S_C.WTE -= 1;
4294                         if(B->C.S_C.WTE <= 0){
4295
4296                             if(B->team == 0){
4297                                 P[0].resource += B->C.Esupply;
4298                                 P[0].food += B->C.Efood;
4299                                 P[0].money += B->C.Emoney;
4300                             }
4301                             if(B->team == 2){
4302                                 P[1].resource += B->C.Esupply;
4303                                 P[1].food += B->C.Efood;
4304                                 P[1].money += B->C.Emoney;
4305                             }
4306                             if(B->team == 1){
4307                                 P[2].resource += B->C.Esupply;
4308                                 P[2].food += B->C.Efood;
4309                                 P[2].money += B->C.Emoney;
4310                             }
4311
4312                             B->C.S_C.WTE = B->C.S_M.WTE;
4313                         }
4314                         B = B->next;
4315                     }B = BTop;
4316                 }
4317             }
4318             eventTime++;
4319             U = UTop;
4320
4321             //NSLog(@"%g", eventTime);
4322             [self EventFunc:false];
4323
4324             pussyCumsOnlyOnceFlag = false;
4325             wtRdy = false;
4326             //NSLog(@"eventTime%g", eventTime);
4327             if(!U) break;
4328             //if(wtRdy3) break;
4329
4330         }
4331     lolwtfshit:{}
4332     U = UTop;
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342     if(buildSelectedFlag){
4343         windowPoint.x = [mapWindow frame].origin.x;
4344         windowPoint.y = [mapWindow frame].origin.y;
4345         [researchPanel setFrameOrigin:windowPoint];
4346         if([self setBuildList]){
4347             [researchPanel makeKeyAndOrderFront:nil];
4348         };
4349         buildSelectedFlag = false;
4350     }
4351
4352     if(TeamCountFlag && !endGameCondition){
4353         U = UTop;
4354         TeamCount0 = 0;
4355         TeamCount2 = 0;
4356         while(U){
4357             if((U->team == 0 || U->team == 1) && !U->dead){
4358                 TeamCount0++;
4359             }
4360             else if(U->team == 2 && !U->dead){
4361                 TeamCount2++;
4362             }
4363             U = U->next;
4364         }
4365         U = UTop;
4366
4367
4368         if(targType1cnt[1] == 0 || targType2cnt[1] == 0){
4369             endGameCondition = true;
4370             redWinFlag = true;
4371             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4372
4373         }
4374         if(targType1cnt[0] == 0 || targType2cnt[0] == 0){
4375             endGameCondition = true;
4376             blueWinFlag = true;
4377             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4378
4379         }
4380
4381         if(targType2Dflag){
4382             endGameCondition = true;
4383             redWinFlag = true;
4384             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4385
4386         }
4387         if(targType2Lflag){
4388             endGameCondition = true;
4389             blueWinFlag = true;
4390             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4391
4392         }
4393
4394         if(TeamCount0 == 0 && (MF[MFselectedRow+1].MS.EGCdark.endType1 == 2 || MF[MFselectedRow+1].MS.EGCdark.endType2 == 2)){
4395             endGameCondition = true;
4396             redWinFlag = true;
4397             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4398         }
4399         if(TeamCount2 == 0 && (MF[MFselectedRow+1].MS.EGClight.endType1 == 1 || MF[MFselectedRow+1].MS.EGClight.endType2 == 1)){
4400             endGameCondition = true;
4401             blueWinFlag = true;
4402             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4403
4404         }
4405     }
4406
4407
4408     static int endGamePanelWait = 100;
4409
4410     if(endGameCondition && !battleRdy){
4411
4412         if(redWinFlag && blueWinFlag){
4413
4414
4415         }else{
4416             windowPoint.x = [mapWindow frame].origin.x+30;
4417             windowPoint.y = [mapWindow frame].origin.y+200;
4418             [endGamePanel setFrameOrigin:windowPoint];
4419             [endGamePanel makeKeyAndOrderFront:nil];
4420             endGamePanelWait--;
4421             if(endGamePanelWait > 0) return;
4422         }
4423
4424         [endGamePanel close];
4425
4426         [fsWindow close];
4427
4428         esSceneProc = 0;
4429
4430         [BGMsub stop];
4431         BGMsub = NULL;
4432
4433         endGameCondition = false;
4434         initMapFlag = false;
4435         TeamCountFlag = false;
4436         initStatusFlag = false;
4437         battleBegin = false;
4438         startES = true;
4439
4440         cpuModeMOVEflag = false;
4441         cpuModeATTACKflag = false;
4442
4443         redWinFlag = false;
4444         blueWinFlag = false;
4445         cpuAImodeflag = false;
4446         cpuTurnEndFlag = true;
4447         waitSwtichFlag = false;
4448
4449         wtRdy = false;
4450         wtRdy2 = false;
4451         Uselected = NULL;
4452
4453         endGamePanelWait = 100;
4454         stageClearFlag = false;
4455         stageClearFlag2 = false;
4456         battleReadyUpFlag = false;
4457         setBattleModeFlag = false;
4458     }
4459     if(backTitleFlag){
4460
4461         [titleWindow makeKeyAndOrderFront:nil];
4462         [fsWindow close];
4463
4464         esSceneProc = 0;
4465
4466         [BGMsub stop];
4467         BGMsub = NULL;
4468
4469         endGameCondition = false;
4470         initMapFlag = false;
4471         TeamCountFlag = false;
4472         initStatusFlag = false;
4473         battleBegin = false;
4474         startES = true;
4475
4476         cpuModeMOVEflag = false;
4477         cpuModeATTACKflag = false;
4478
4479         redWinFlag = false;
4480         blueWinFlag = false;
4481         cpuAImodeflag = false;
4482         cpuTurnEndFlag = true;
4483         backTitleFlag = false;
4484         backTitleFlag2 = true;
4485         waitSwtichFlag = false;
4486         battleReadyUpFlag = false;
4487         setBattleModeFlag = false;
4488
4489
4490         wtRdy = false;
4491         wtRdy2 = false;
4492
4493         Uselected = NULL;
4494
4495     }if(stageClearFlag){
4496
4497         if(stageClearFlag2){
4498
4499             endGameCondition = true;
4500             blueWinFlag = true;
4501             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4502
4503
4504
4505             return;
4506         }
4507
4508         [fsWindow close];
4509
4510         esSceneProc = 0;
4511
4512         [BGMsub stop];
4513         BGMsub = NULL;
4514
4515         endGameCondition = false;
4516         initMapFlag = false;
4517         TeamCountFlag = false;
4518         initStatusFlag = false;
4519         battleBegin = false;
4520         startES = true;
4521
4522         cpuModeMOVEflag = false;
4523         cpuModeATTACKflag = false;
4524
4525         redWinFlag = false;
4526         blueWinFlag = false;
4527         cpuAImodeflag = false;
4528         cpuTurnEndFlag = true;
4529         stageClearFlag = false;
4530         waitSwtichFlag = false;
4531         battleReadyUpFlag = false;
4532         setBattleModeFlag = false;
4533
4534         wtRdy = false;
4535         wtRdy2 = false;
4536
4537
4538         Uselected = NULL;
4539
4540     }
4541
4542     if(gameOverFlag){
4543
4544
4545         [GameOverIV setImage:gaov.img];
4546
4547
4548         [GameOverWindow makeKeyAndOrderFront:nil];
4549         [fsWindow close];
4550
4551         endGameCondition = false;
4552         initMapFlag = false;
4553         TeamCountFlag = false;
4554         initStatusFlag = false;
4555         battleBegin = false;
4556         startES = true;
4557
4558         cpuModeMOVEflag = false;
4559         cpuModeATTACKflag = false;
4560
4561         redWinFlag = false;
4562         blueWinFlag = false;
4563         cpuAImodeflag = false;
4564         cpuTurnEndFlag = true;
4565         backTitleFlag = false;
4566         gameOverFlag = false;
4567         gameOverFlag2 = true;
4568         waitSwtichFlag = false;
4569         battleReadyUpFlag = false;
4570         setBattleModeFlag = false;
4571
4572         wtRdy = false;
4573         wtRdy2 = false;
4574         Uselected = NULL;
4575
4576     }
4577
4578     /*
4579     if(Uselected)
4580         if(!Uselected->dead){
4581
4582             U = UTop;
4583
4584             while (U->number != wtUnitNum) {
4585                 U = U->next;
4586             }
4587
4588             if(!wtMovedFlag && !wtAttackedFlag){
4589                 U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
4590             }else if(wtMovedFlag && wtAttackedFlag){
4591                 U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
4592             }else if(wtMovedFlag){
4593                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4594             }else if(wtAttackedFlag){
4595                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4596             }
4597
4598             U = UTop;
4599
4600             wtRdy = false;
4601         }
4602     */
4603     if(summonRdyFlag){
4604         U = UTop;
4605
4606
4607         U = UTop;
4608         [self addSummonStatus];
4609
4610         U = CSLU;
4611
4612         if(U->team == 0){
4613
4614             SKILL *sTop = U->C.S;
4615
4616             while (U->C.S) {
4617                 if(U->C.S->type == 2) break;
4618                 U->C.S = U->C.S->next;
4619             }
4620
4621             U->C.S_C.MP -= U->C.S->cost[crCSL];
4622
4623             if(!U->C.S){
4624                 U->C.S = sTop;
4625                 U = UTop;
4626                 return;
4627             }
4628
4629
4630             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4631             unitTeam[possionX][possionY] = 0;
4632
4633             U->C.S = sTop;
4634             unitColorInitFlag = true;
4635         }
4636         if(U->team == 2){
4637
4638             SKILL *sTop = U->C.S;
4639
4640             while (U->C.S) {
4641                 if(U->C.S->type == 2) break;
4642                 U->C.S = U->C.S->next;
4643             }
4644
4645             U->C.S_C.MP -= U->C.S->cost[crCSL];
4646
4647             if(!U->C.S){
4648                 U->C.S = sTop;
4649                 U = UTop;
4650                 return;
4651             }
4652
4653             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4654             unitTeam[possionX][possionY] = 2;
4655
4656             U->C.S = sTop;
4657             unitColorInitFlag = true;
4658         }
4659
4660         summonRdyFlag = false;
4661         cslRdy = false;
4662
4663         U = UTop;
4664     }
4665
4666
4667
4668     if(unitMoveEndFlag){
4669         //pussyLoopFlag = false;
4670     }
4671
4672
4673     w000p:
4674
4675
4676     if(displayBattleCheckPanelFlag == 1){
4677         displayBattleCheckPanelFlag = 2;
4678         battleFlag = true;
4679         windowPoint.x = [mapWindow frame].origin.x;
4680         windowPoint.y = [mapWindow frame].origin.y;
4681         [atkPanel setFrameOrigin:windowPoint];
4682     }
4683
4684
4685
4686     U = UTop;
4687
4688
4689
4690
4691
4692 }
4693
4694 -(void)EventFunc:(bool)eventLoopProcFlag{
4695
4696
4697
4698
4699     if(battleSetUp){
4700         pussyLoopFlag = false;
4701     }
4702
4703
4704     if(attackingWait){
4705         return;
4706     }
4707
4708
4709     if(battleBegin && !pussyLoopFlag){
4710         //wtRdy3 = true;
4711         bool proccessTrue = false;
4712         static bool onlyBigin = false;
4713         MAPSCRIPT MS = MF[MFselectedRow+1].MS;
4714         MAPSCRIPTD *MSDtop;
4715         MSDtop = MSDTO;
4716         if(!MSDtop){
4717             wtRdy3 = false;
4718             return;
4719         }
4720
4721
4722         if(!onlyBigin){
4723             MSDP0top = MS.D->P;
4724             onlyBigin = true;
4725         }
4726
4727
4728
4729         while (MS.D) {
4730             int proccesType = -1;
4731
4732             bool EventFailFlag = false;
4733             static bool PtopFlag = false;
4734
4735
4736             enum{
4737                 ENTIRE_MAP,
4738                 CENTER_POINT
4739             };
4740
4741             while(MS.D){
4742                 if(MS.D->endFlag){
4743                     MS.D = MS.D->next;
4744                 }
4745                 else
4746                     break;
4747             }
4748             PtopFlag = false;
4749             if(!MS.D) {
4750                 break;
4751             }
4752
4753             if(!PtopFlag){
4754                 MSDPtop = MS.D->P;
4755                 PtopFlag = true;
4756             }
4757
4758             if(MS.D)
4759                 while(MS.D->P){
4760                     if(MS.D->P->endFlag)
4761                         MS.D->P = MS.D->P->next;
4762                     else
4763                         break;
4764                 }
4765
4766                 while(MS.D->P){
4767                     if(!eventLoopProcFlag && MS.D->P->type == 0){
4768                         proccessTrue = false;
4769                         MS.D->P = MS.D->P->next;
4770                         continue;
4771                     }
4772                     break;
4773                 }
4774
4775             if(!MS.D->P){
4776                 MS.D->endFlag = true;
4777                 messageDialog = false;
4778                 [self setMessage:NULL];
4779                 MS.D->P = MSDPtop;
4780                 PtopFlag = false;
4781
4782
4783                 MAPSCRIPT0 *MSDPT = MS.D->P;
4784
4785                 if(MS.D->ETtype == 0){
4786
4787                 }else if(MS.D->ETtype == 1){
4788                     bool resultFailFlag = false;
4789                     while(MS.D->P){
4790                         if(!MS.D->P->endFlag)
4791                             resultFailFlag = true;
4792                         MS.D->P = MS.D->P->next;
4793                     }MS.D->P = MSDPT;
4794
4795                     if(resultFailFlag)
4796                         while(MS.D->P){
4797                             MS.D->P->endFlag = false;
4798                             MS.D->P = MS.D->P->next;
4799                         }MS.D->P = MSDPT;
4800
4801                 }else if(MS.D->ETtype == 2){
4802
4803                     bool resultFailFlag = false;
4804                     while(MS.D->P){
4805                         if(!MS.D->P->succeessfulFlag)
4806                             resultFailFlag = true;
4807                         MS.D->P = MS.D->P->next;
4808                     }MS.D->P = MSDPT;
4809
4810                     if(resultFailFlag)
4811                         while(MS.D->P){
4812                             MS.D->P->endFlag = false;
4813                             MS.D->P = MS.D->P->next;
4814                         }MS.D->P = MSDPT;
4815                 }else if(MS.D->ETtype == 3){
4816
4817                     bool resultFailFlag = false;
4818                     while(MS.D->P){
4819                         if(!MS.D->P->succeessfulFlag){
4820                             resultFailFlag = false;
4821                             break;
4822                         }
4823                         MS.D->P = MS.D->P->next;
4824                         resultFailFlag = true;
4825                     }MS.D->P = MSDPT;
4826
4827                     if(resultFailFlag)
4828                         while(MS.D->P){
4829                             MS.D->P->endFlag = false;
4830                             MS.D->P = MS.D->P->next;
4831                         }MS.D->P = MSDPT;
4832                     //NSLog(@"%d", UTop->x);
4833                 }else if(MS.D->ETtype == 4){
4834                     while(MS.D->P){
4835                         MS.D->P->endFlag = false;
4836                         MS.D->P = MS.D->P->next;
4837                     }MS.D->P = MSDPT;
4838                 }
4839
4840             }
4841             if(!MS.D) {
4842
4843                 break;
4844             }
4845
4846             if(!PtopFlag){
4847                 MSDPtop = MS.D->P;
4848                 PtopFlag = true;
4849             }
4850
4851             if(MS.D->switch1)
4852                 for(int i = 0;*(MS.D->switch1+i)>0;i++){
4853                     if(Suicchi[*(MS.D->switch1+i)])
4854                         continue;
4855
4856                     EventFailFlag = true;
4857                 }
4858
4859             if(MS.D->switch2)
4860                 for(int i = 0;*(MS.D->switch2+i)>0;i++){
4861                     if(!Suicchi[*(MS.D->switch2+i)])
4862                         continue;
4863
4864                     EventFailFlag = true;
4865                 }
4866             //NSLog(@"%g", eventTime);
4867
4868             if(!MS.D->endFlag)
4869             if(eventTime == MS.D->ET4 || MS.D->ET4 == 0 || MS.D->initialDeleyedFlag){
4870
4871                 if(MS.D->P->type == 6){
4872                 if(eventTime == MS.D->ET4){
4873                     MS.D->P->S4.lagFixFlag = false;
4874                 }
4875                 else if(unitMoveEndFlag){
4876                     MS.D->P->S4.lagFixFlag = false;
4877                 }
4878                 else if(battleSetUp){
4879                     MS.D->P->S4.lagFixFlag = false;
4880                 }
4881                 else if(pushStanbyFlag){
4882                     MS.D->P->S4.lagFixFlag = false;
4883                 }
4884                 else if(battleEndFlag){
4885                     MS.D->P->S4.lagFixFlag = false;
4886                 }
4887                 else if(!MS.D->P->S4.lagFixFlag && MS.D->ET4 == 0){
4888                         MS.D->P->S4.lagFixFlag = true;
4889                     }
4890                 }
4891
4892                 if(MS.D->P->S4.lagFixFlag){
4893                     //NSLog(@"%g", eventTime);
4894                     proccessTrue = false;
4895                     goto jonny;
4896                 }
4897
4898                 proccessTrue = true;
4899                 if(MS.D->ET4 > 0){
4900
4901                     double deltaET = floor(MS.D->ET2) - floor(MS.D->ET1);
4902                     int deltaR = 0;
4903                     if(deltaET < 0) deltaET = 0;
4904
4905                     if(MS.D->ET1 <= eventTime && MS.D->ET2 >= eventTime){
4906                         if(deltaET > 0) deltaR = rand()%(int)deltaET;
4907                     }
4908
4909                     MS.D->ET3 = MS.D->ET1 + (double)deltaR;
4910
4911                     if(!MS.D->onlyInitialDeley) {
4912                         MS.D->ET4 += MS.D->ET3;
4913                     }else{
4914                         MS.D->initialDeleyedFlag = true;
4915                     }
4916                 }
4917
4918                // NSLog(@"%g %d", eventTime, P[0].resource);
4919             }else{
4920
4921                 if(wtRdy3){
4922                     proccessTrue = true;
4923                     goto jonny;
4924                 }
4925
4926                 MS.D = MS.D->next;
4927
4928                 continue;
4929             }
4930
4931         jonny:{}
4932
4933             if(MS.D->type == -1 && !EventFailFlag)
4934                 proccesType = ENTIRE_MAP;
4935             if(MS.D->type == 0 && pushStanbyFlag && (Uselected->x == MS.D->x && Uselected->y == MS.D->y) && !EventFailFlag)
4936                 proccesType = CENTER_POINT;
4937             else if(MS.D->type == 0){
4938                 proccesType = CENTER_POINT;
4939                 proccessTrue = false;
4940                 EventFailFlag = true;
4941             }
4942
4943             if(MS.D->endFlag){
4944                 MS.D = MS.D->next;
4945                 continue;
4946             }
4947
4948             if(MS.D->ET4 != 0 && pussyCumsOnlyOnceFlag){
4949                 EventFailFlag = true;
4950             }
4951
4952             marry:{}
4953             if(EventFailFlag  || !proccessTrue){
4954                 while (MS.D->P) {
4955                     //MS.D->P->endFlag = true;
4956                     MS.D->P = MS.D->P->next;
4957                 }
4958                 MS.D->P = MSDPtop;
4959                 MS.D = MS.D->next;
4960                 continue;
4961             }
4962
4963             if(!eventLoopProcFlag && MS.D->P->type == 0)
4964                 proccessTrue = false;
4965
4966             if(proccessTrue)
4967                 switch (proccesType) {
4968                     case ENTIRE_MAP:
4969                         MS.D->P = [self setEvent:MS.D->P];
4970
4971                         if(messageDialog){
4972                             MS.D->P = MSDPtop;
4973                             MS.D = MSDtop;
4974                             return;
4975                         }
4976                         if(waitSwtichFlag) {
4977                             MS.D->P = MSDPtop;
4978                             MS.D = MSDtop;
4979                             return;
4980                         }if(backTitleFlag){
4981                             MS.D->P = MSDPtop;
4982                             MS.D = MSDtop;
4983                             return;
4984
4985                         }if(stageClearFlag){
4986                             MS.D->P = MSDPtop;
4987                             MS.D = MSDtop;
4988                             return;
4989
4990                         }if(gameOverFlag){
4991                             MS.D->P = MSDPtop;
4992                             MS.D = MSDtop;
4993                             return;
4994
4995                         }
4996                         MS.D->P = MSDPtop;
4997                         break;
4998                     case CENTER_POINT:
4999                         MS.D->P = [self setEvent:MS.D->P];
5000                         if(messageDialog){
5001                             MS.D->P = MSDPtop;
5002                             MS.D = MSDtop;
5003                             return;
5004                         }
5005                         if(waitSwtichFlag) {
5006                             MS.D->P = MSDPtop;
5007                             MS.D = MSDtop;
5008                             return;
5009                         }if(backTitleFlag){
5010                             MS.D->P = MSDPtop;
5011                             MS.D = MSDtop;
5012                             return;
5013
5014                         }if(stageClearFlag){
5015                             MS.D->P = MSDPtop;
5016                             MS.D = MSDtop;
5017                             return;
5018
5019                         }if(gameOverFlag){
5020                             MS.D->P = MSDPtop;
5021                             MS.D = MSDtop;
5022                             return;
5023
5024                         }
5025                         MS.D->P = MSDPtop;
5026                         break;
5027
5028                     default:
5029                         MS.D->P = MSDPtop;
5030                         break;
5031                 }
5032
5033             MS.D->P = MSDPtop;
5034
5035
5036             bool PnextFlag = false;
5037
5038             MS.D->P = MSDPtop;
5039             while (MS.D->P) {
5040                 if(MS.D->P->endFlag){
5041                     MS.D->P = MS.D->P->next;
5042                 }else{
5043                     break;
5044                 }
5045                 if(!MS.D->P){
5046                     PnextFlag = true;
5047                 }
5048             }
5049
5050             MS.D->P = MSDPtop;
5051
5052             if(PnextFlag){
5053                 MS.D = MS.D->next;
5054             }
5055
5056
5057             continue;
5058         }
5059         MS.D = MSDtop;
5060
5061         while(MS.D){
5062
5063             MAPSCRIPT0 *MSDPT = MS.D->P;
5064             if(MS.D->ETtype == 0){
5065                 while(MS.D->P){
5066                     MS.D->P->succeessfulFlag = true;
5067                     MS.D->endFlag = true;
5068                     MS.D->P = MS.D->P->next;
5069                 }MS.D->P = MSDPT;
5070             }else if(MS.D->ETtype == 1){
5071                 bool resultFailFlag = false;
5072                 while(MS.D->P){
5073                     if(!MS.D->P->endFlag)
5074                         resultFailFlag = true;
5075                     MS.D->P = MS.D->P->next;
5076                 }MS.D->P = MSDPT;
5077
5078                 if(resultFailFlag)
5079                     while(MS.D->P){
5080                         MS.D->P->succeessfulFlag = false;
5081                         MS.D->endFlag = false;
5082                         MS.D->P = MS.D->P->next;
5083                     }MS.D->P = MSDPT;
5084
5085             }else if(MS.D->ETtype == 2){
5086
5087                 bool resultFailFlag = false;
5088                 while(MS.D->P){
5089                     if(!MS.D->P->succeessfulFlag)
5090                         resultFailFlag = true;
5091                     MS.D->P = MS.D->P->next;
5092                 }MS.D->P = MSDPT;
5093
5094                 if(resultFailFlag)
5095                     while(MS.D->P){
5096                         MS.D->P->succeessfulFlag = false;
5097                         MS.D->endFlag = false;
5098                         MS.D->P = MS.D->P->next;
5099                     }MS.D->P = MSDPT;
5100             }else if(MS.D->ETtype == 3){
5101
5102                 bool resultFailFlag = false;
5103                 while(MS.D->P){
5104                     if(!MS.D->P->succeessfulFlag){
5105                         resultFailFlag = false;
5106                         break;
5107                     }
5108                     resultFailFlag = true;
5109                     MS.D->P = MS.D->P->next;
5110                 }MS.D->P = MSDPT;
5111
5112                 if(resultFailFlag)
5113                     while(MS.D->P){
5114                         MS.D->P->succeessfulFlag = false;
5115                         MS.D->endFlag = false;
5116                         MS.D->P = MS.D->P->next;
5117                     }MS.D->P = MSDPtop;
5118             }else if(MS.D->ETtype == 4){
5119                 while(MS.D->P){
5120                     MS.D->P->succeessfulFlag = false;
5121                     MS.D->endFlag = false;
5122                     MS.D->P = MS.D->P->next;
5123                 }MS.D->P = MSDPT;
5124             }
5125
5126             MS.D->P = MSDPT;
5127             MS.D = MS.D->next;
5128         }
5129
5130         MS.D = MSDtop;
5131
5132
5133
5134         MF[MFselectedRow+1].MS.D = MS.D;
5135
5136         cpuTurnEndFlag = false;
5137         battleSetUpIgnore = false;
5138         if(!eventLoopProcFlag){
5139             pussyCumsOnlyOnceFlag = true;
5140
5141         }else
5142             fuckingLoadBugFix = true;
5143         //wtRdy3 = false;
5144     }
5145
5146
5147 }
5148
5149 -(MAPSCRIPT0*)setEvent:(MAPSCRIPT0*)MS0{
5150
5151     enum{
5152         MESSAGE_FLAG,
5153         SELECTION_FLAG,
5154         INPUTNUMBER_FLAG,
5155         SWITCH_FLAG,
5156         VALUE_FLAG,
5157         TIMER_FLAG,
5158         BRANCH_FLAG,
5159         LABEL_FLAG,
5160         LABELJUMP_FLAG,
5161         COMMENT_FLAG,
5162         RESOURCE_FLAG,
5163         APPEARANCE_FLAG = 22,
5164         DISSAPPEARANCE_FLAG = 23,
5165         WAIT_FLAG = 25,
5166         BGM_FLAG =28,
5167         SE_FLAG =30,
5168         GAMEOVER_FLAG = 35,
5169         STAGECLEAR_FLAG = 36,
5170         TITLE_FLAG = 37,
5171     };
5172
5173     int Proc = -1;
5174
5175     if(MS0->type == 0)
5176         Proc = MESSAGE_FLAG;
5177     if(MS0->type == 1)
5178         Proc = SELECTION_FLAG;
5179     if(MS0->type == 2)
5180         Proc = INPUTNUMBER_FLAG;
5181     if(MS0->type == 3)
5182         Proc = SWITCH_FLAG;
5183     if(MS0->type == 4)
5184         Proc = VALUE_FLAG;
5185     if(MS0->type == 5)
5186         Proc = TIMER_FLAG;
5187     if(MS0->type == 6)
5188         Proc = BRANCH_FLAG;
5189     if(MS0->type == 7)
5190         Proc = LABEL_FLAG;
5191     if(MS0->type == 8)
5192         Proc = LABELJUMP_FLAG;
5193     if(MS0->type == 9)
5194         Proc = COMMENT_FLAG;
5195     if(MS0->type == 10)
5196         Proc = RESOURCE_FLAG;
5197     if(MS0->type == 22)
5198         Proc = APPEARANCE_FLAG;
5199     if(MS0->type == 23)
5200         Proc = DISSAPPEARANCE_FLAG;
5201     if(MS0->type == 25)
5202         Proc = WAIT_FLAG;
5203     if(MS0->type == 28)
5204         Proc = BGM_FLAG;
5205     if(MS0->type == 30)
5206         Proc = SE_FLAG;
5207     if(MS0->type == 35)
5208         Proc = GAMEOVER_FLAG;
5209     if(MS0->type == 36)
5210         Proc = STAGECLEAR_FLAG;
5211     if(MS0->type == 37)
5212         Proc = TITLE_FLAG;
5213
5214
5215
5216
5217     switch(Proc){
5218
5219         case MESSAGE_FLAG:
5220             messageDialog = true;
5221             [self setMessage:MS0];
5222             coolTime = true;
5223             fuckingLoadBugFix = false;
5224             break;
5225         case SELECTION_FLAG:
5226
5227             MS0 = [self setSelection:MS0];
5228             coolTime = true;
5229             break;
5230         case INPUTNUMBER_FLAG:
5231             MS0 = [self setDefault:MS0];
5232             coolTime = true;
5233             break;
5234
5235         case SWITCH_FLAG:
5236             MS0 = [self setSwitch:MS0];
5237             break;
5238         case VALUE_FLAG:
5239             MS0 = [self setDefault:MS0];
5240             break;
5241         case TIMER_FLAG:
5242             MS0 = [self setDefault:MS0];
5243             break;
5244         case BRANCH_FLAG:
5245             MS0 = [self setBranch:MS0];
5246             break;
5247         case LABEL_FLAG:
5248             MS0 = [self setLabel:MS0];
5249             break;
5250         case LABELJUMP_FLAG:
5251             MS0 = [self setLabelJump:MS0];
5252             break;
5253         case COMMENT_FLAG:
5254             MS0 = [self setComment:MS0];
5255             break;
5256         case RESOURCE_FLAG:
5257             MS0 = [self setResource:MS0];
5258             break;
5259         case APPEARANCE_FLAG:
5260             MS0 = [self setAppearance:MS0];
5261             break;
5262         case DISSAPPEARANCE_FLAG:
5263             MS0 = [self setDissappearance:MS0];
5264             break;
5265         case WAIT_FLAG:
5266             MS0 = [self setWait:MS0];
5267             break;
5268         case BGM_FLAG:
5269             MS0 = [self setBGM:MS0];
5270             break;
5271         case SE_FLAG:
5272             MS0 = [self setSE:MS0];
5273             break;
5274         case GAMEOVER_FLAG:
5275             MS0 = [self setGameOver:MS0];
5276             coolTime = true;
5277             break;
5278         case STAGECLEAR_FLAG:
5279             MS0 = [self setStageClear:MS0];
5280             break;
5281         case TITLE_FLAG:
5282             MS0 = [self setTitleBack:MS0];
5283             break;
5284
5285     }
5286
5287
5288     return MS0;
5289 }
5290 -(void)setTargetListDat{
5291     targType1cnt[0] = -1;
5292     targType1cnt[1] = -1;
5293     targType2cnt[0] = -1;
5294     targType2cnt[1] = -1;
5295     targType2Lflag = false;
5296     targType2Dflag = false;
5297
5298     /*
5299     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5300
5301     while(1) {
5302
5303         for (int i = 0;i < 64;i++) {
5304             if(!MS.EGClight.etValue1[i]) break;
5305             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5306             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5307
5308             int Tx = [[array2 objectAtIndex:0] intValue];
5309             int Ty = [[array2 objectAtIndex:1] intValue];
5310             if(MS.EGClight.endType1 == 3){
5311                 U = UTop;
5312                 while (U) {
5313                     if(U->x == Tx && U->y == Ty){
5314                         U->targType1L = true;
5315                         if(targType1cnt[0] < 0)
5316                             targType1cnt[0] = 0;
5317                         targType1cnt[0]++;
5318                         break;
5319                     }
5320                     U = U->next;
5321                 }U = UTop;
5322             }
5323             if(MS.EGClight.endType1 == 4){
5324                 U = UTop;
5325                 while (U) {
5326                     if(U->x == Tx && U->y == Ty){
5327                         U->targType2L = true;
5328                         if(targType2cnt[0] < 0)
5329                             targType2cnt[0] = 0;
5330                         targType2cnt[0]++;
5331                         break;
5332                     }
5333                     U = U->next;
5334                 }U = UTop;
5335             }
5336         }
5337         for (int i = 0;i < 64;i++) {
5338             if(!MS.EGClight.etValue2[i]) break;
5339             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5340             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5341
5342             int Tx = [[array2 objectAtIndex:0] intValue];
5343             int Ty = [[array2 objectAtIndex:1] intValue];
5344
5345             if(MS.EGClight.endType2 == 3){
5346                 U = UTop;
5347                 while (U) {
5348                     if(U->x == Tx && U->y == Ty){
5349                         U->targType1L = true;
5350                         if(targType1cnt[0] < 0)
5351                             targType1cnt[0] = 0;
5352                         targType1cnt[0]++;
5353                         break;
5354                     }
5355                     U = U->next;
5356                 }U = UTop;
5357             }
5358             if(MS.EGClight.endType2 == 4){
5359                 U = UTop;
5360                 while (U) {
5361                     if(U->x == Tx && U->y == Ty){
5362                         U->targType2L = true;
5363                         if(targType2cnt[0] < 0)
5364                             targType2cnt[0] = 0;
5365                         targType2cnt[0]++;
5366                         break;
5367                     }
5368                     U = U->next;
5369                 }U = UTop;
5370             }
5371         }
5372         for (int i = 0;i < 64;i++) {
5373             if(!MS.EGCdark.etValue1[i]) break;
5374             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5375             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5376
5377             int Tx = [[array2 objectAtIndex:0] intValue];
5378             int Ty = [[array2 objectAtIndex:1] intValue];
5379
5380             if(MS.EGCdark.endType1 == 3){
5381                 U = UTop;
5382                 while (U) {
5383                     if(U->x == Tx && U->y == Ty){
5384                         U->targType1D = true;
5385                         if(targType1cnt[1] < 0)
5386                             targType1cnt[1] = 0;
5387                         targType1cnt[1]++;
5388                         break;
5389                     }
5390                     U = U->next;
5391                 }U = UTop;
5392             }
5393             if(MS.EGCdark.endType1 == 4){
5394                 U = UTop;
5395                 while (U) {
5396                     if(U->x == Tx && U->y == Ty){
5397                         U->targType2D = true;
5398                         if(targType2cnt[1] < 0)
5399                             targType2cnt[1] = 0;
5400                         targType2cnt[1]++;
5401                         break;
5402                     }
5403                     U = U->next;
5404                 }U = UTop;
5405             }
5406         }
5407         for (int i = 0;i < 64;i++) {
5408             if(!MS.EGCdark.etValue2[i]) break;
5409             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5410             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5411
5412             int Tx = [[array2 objectAtIndex:0] intValue];
5413             int Ty = [[array2 objectAtIndex:1] intValue];
5414
5415             if(MS.EGCdark.endType2 == 3){
5416                 U = UTop;
5417                 while (U) {
5418                     if(U->x == Tx && U->y == Ty){
5419                         U->targType1D = true;
5420                         if(targType1cnt[1] < 0)
5421                             targType1cnt[1] = 0;
5422                         targType1cnt[1]++;
5423                         break;
5424                     }
5425                     U = U->next;
5426                 }U = UTop;
5427             }
5428             if(MS.EGCdark.endType2 == 4){
5429                 U = UTop;
5430                 while (U) {
5431                     if(U->x == Tx && U->y == Ty){
5432                         U->targType2D = true;
5433                         if(targType2cnt[1] < 0)
5434                             targType2cnt[1] = 0;
5435                         targType2cnt[1]++;
5436                         break;
5437                     }
5438                     U = U->next;
5439                 }U = UTop;
5440             }
5441         }
5442         break;
5443     }
5444 */
5445
5446
5447 }
5448
5449 -(void)setTargetList{
5450
5451     targType1cnt[0] = -1;
5452     targType1cnt[1] = -1;
5453     targType2cnt[0] = -1;
5454     targType2cnt[1] = -1;
5455     targType2Lflag = false;
5456     targType2Dflag = false;
5457
5458
5459     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5460
5461     while(1) {
5462
5463         for (int i = 0;i < 64;i++) {
5464             if(!MS.EGClight.etValue1[i] || [MS.EGClight.etValue1[i] isEqualToString:@""]) break;
5465             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5466             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5467
5468             int Tx = [[array2 objectAtIndex:0] intValue];
5469             int Ty = [[array2 objectAtIndex:1] intValue];
5470             if(MS.EGClight.endType1 == 3){
5471                 U = UTop;
5472                 while (U) {
5473                     if(U->x == Tx && U->y == Ty){
5474                         U->targType1L = true;
5475                         if(targType1cnt[0] < 0)
5476                             targType1cnt[0] = 0;
5477                         targType1cnt[0]++;
5478                         break;
5479                     }
5480                     U = U->next;
5481                 }U = UTop;
5482             }
5483             if(MS.EGClight.endType1 == 4){
5484                 U = UTop;
5485                 while (U) {
5486                     if(U->x == Tx && U->y == Ty){
5487                         U->targType2L = true;
5488                         if(targType2cnt[0] < 0)
5489                             targType2cnt[0] = 0;
5490                         targType2cnt[0]++;
5491                         break;
5492                     }
5493                     U = U->next;
5494                 }U = UTop;
5495             }
5496         }
5497         for (int i = 0;i < 64;i++) {
5498             if(!MS.EGClight.etValue2[i] || [MS.EGClight.etValue2[i] isEqualToString:@""]) break;
5499             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5500             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5501
5502             int Tx = [[array2 objectAtIndex:0] intValue];
5503             int Ty = [[array2 objectAtIndex:1] intValue];
5504
5505             if(MS.EGClight.endType2 == 3){
5506             U = UTop;
5507                 while (U) {
5508                     if(U->x == Tx && U->y == Ty){
5509                         U->targType1L = true;
5510                         if(targType1cnt[0] < 0)
5511                             targType1cnt[0] = 0;
5512                         targType1cnt[0]++;
5513                         break;
5514                     }
5515                     U = U->next;
5516                 }U = UTop;
5517             }
5518             if(MS.EGClight.endType2 == 4){
5519                 U = UTop;
5520                 while (U) {
5521                     if(U->x == Tx && U->y == Ty){
5522                         U->targType2L = true;
5523                         if(targType2cnt[0] < 0)
5524                             targType2cnt[0] = 0;
5525                         targType2cnt[0]++;
5526                         break;
5527                     }
5528                     U = U->next;
5529                 }U = UTop;
5530             }
5531         }
5532         for (int i = 0;i < 64;i++) {
5533             if(!MS.EGCdark.etValue1[i] || [MS.EGCdark.etValue1[i] isEqualToString:@""]) break;
5534             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5535             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5536
5537             int Tx = [[array2 objectAtIndex:0] intValue];
5538             int Ty = [[array2 objectAtIndex:1] intValue];
5539
5540             if(MS.EGCdark.endType1 == 3){
5541                     U = UTop;
5542                 while (U) {
5543                     if(U->x == Tx && U->y == Ty){
5544                         U->targType1D = true;
5545                         if(targType1cnt[1] < 0)
5546                             targType1cnt[1] = 0;
5547                         targType1cnt[1]++;
5548                         break;
5549                     }
5550                     U = U->next;
5551                 }U = UTop;
5552             }
5553             if(MS.EGCdark.endType1 == 4){
5554                 U = UTop;
5555                 while (U) {
5556                     if(U->x == Tx && U->y == Ty){
5557                         U->targType2D = true;
5558                         if(targType2cnt[1] < 0)
5559                             targType2cnt[1] = 0;
5560                         targType2cnt[1]++;
5561                         break;
5562                     }
5563                     U = U->next;
5564                 }U = UTop;
5565             }
5566         }
5567         for (int i = 0;i < 64;i++) {
5568             if(!MS.EGCdark.etValue2[i] || [MS.EGCdark.etValue2[i] isEqualToString:@""]) break;
5569             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5570             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5571
5572             int Tx = [[array2 objectAtIndex:0] intValue];
5573             int Ty = [[array2 objectAtIndex:1] intValue];
5574
5575             if(MS.EGCdark.endType2 == 3){
5576                 U = UTop;
5577                 while (U) {
5578                     if(U->x == Tx && U->y == Ty){
5579                         U->targType1D = true;
5580                         if(targType1cnt[1] < 0)
5581                             targType1cnt[1] = 0;
5582                         targType1cnt[1]++;
5583                         break;
5584                     }
5585                     U = U->next;
5586                 }U = UTop;
5587             }
5588             if(MS.EGCdark.endType2 == 4){
5589                 U = UTop;
5590                 while (U) {
5591                     if(U->x == Tx && U->y == Ty){
5592                         U->targType2D = true;
5593                         if(targType2cnt[1] < 0)
5594                             targType2cnt[1] = 0;
5595                         targType2cnt[1]++;
5596                         break;
5597                     }
5598                     U = U->next;
5599                 }U = UTop;
5600             }
5601         }
5602         break;
5603     }
5604
5605
5606
5607
5608 }
5609
5610 -(bool)setBuildList{
5611
5612     crCRL = 0;
5613
5614     [self willChangeValueForKey:@"CResearchListMA"];
5615     [CResearchListMA removeAllObjects];
5616     [self didChangeValueForKey:@"CResearchListMA"];
5617
5618     [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
5619     [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
5620     [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
5621     [researchACU setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
5622     [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
5623     [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
5624     [researchIMG setImage:NULL];
5625
5626     BUILDCHIP *B0;
5627
5628     B = BTop;
5629
5630     while (B && B->x != possionX && B->y != possionY) {
5631         B = B->next;
5632     }
5633     B0 = &BC[buildNum[possionX][possionY]];
5634
5635     RESEARCH *Rtop;
5636     UNITCHIP *BU;
5637
5638     Rtop = B0->R;
5639
5640
5641     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
5642
5643
5644         if(GCnum1 < 0)
5645         if(!B0->R){
5646
5647         return false;
5648
5649         }
5650     }
5651     else if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
5652
5653
5654         if(GCnum2 < 0)
5655         if(!B0->R){
5656
5657             return false;
5658
5659         }
5660     }
5661
5662     while(B0->R){
5663         BU = B0->R->U;
5664
5665         if(B->makeLv >= B0->R->Lv){
5666         NSMutableDictionary* dict = [NSMutableDictionary new];
5667         [dict setValue:[NSString stringWithFormat:@"%@", BU->nameClass] forKey:@"name"];
5668         [dict setValue:[NSString stringWithFormat:@"%g", BU->S_M.HP] forKey:@"HP"];
5669         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d", BU->S_M.cSupply, BU->S_M.cFood, BU->S_M.cMoney] forKey:@"cost"];
5670         [dict setValue:BU->img forKey:@"img"];
5671
5672
5673         [self willChangeValueForKey:@"CResearchListMA"];
5674         [CResearchListMA addObject:dict];
5675         [self didChangeValueForKey:@"CResearchListMA"];
5676         }
5677         B0->R = B0->R->next;
5678     }
5679     B0->R = Rtop;
5680
5681     B = BTop;
5682
5683     BUILDCHIP *B;
5684
5685     B = &BC[buildNum[possionX][possionY]];
5686
5687
5688     if(B0->R){
5689     Rtop = B->R;
5690
5691     BU = B->R->U;
5692     BRU = BU;
5693
5694     for(int i = 0;i <= crCRL && B->R;i++){
5695         BU = B->R->U;
5696         BRU = BU;
5697         [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", BU->S_M.ATK]];
5698         [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", BU->S_M.DEF]];
5699         [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", BU->S_M.CAP]];
5700         [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", BU->S_M.ACU]];
5701         [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", BU->S_M.EVA]];
5702         [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", BU->S_M.MOV]];
5703         [researchIMG setImage:BU->imgb];
5704         [researchIMG setImageScaling:NSScaleToFit];
5705
5706         B->R = B->R->next;
5707     }
5708     B->R = Rtop;
5709     }
5710
5711     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5712
5713     if(B->GuildFlag &&( buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1)){
5714
5715         int a = MS.guildListRegistNum12 - MS.guildListRegistNum11;
5716
5717         if(!guildRE1){
5718         Gnum1 = 0;
5719         if(a > 0)
5720             Gnum1 = MS.guildListRegistNum11 + arc4random()%(MS.guildListRegistNum12 - MS.guildListRegistNum11+1);
5721         else
5722             Gnum1 = MS.guildListRegistNum12;
5723
5724         if(Gnum1 > GCnum1+1)
5725             Gnum1 = GCnum1;
5726         }
5727         int n = 0;
5728         guildc = 0;
5729         saveGuildList = calloc((GCnum1+1), sizeof(int));
5730         if(!guildRE1) GuildDisp1 = calloc(Gnum1, sizeof(int));
5731         for(int i = 0;i < Gnum1;i++){
5732
5733             if(!guildRE1){
5734                 n = [self chooseGuildList:GuildChosen1 gcnum:GCnum1];
5735             if(n == -1)
5736                 break;
5737                 *(GuildDisp1 + i) = *(GuildChosen1 + n);
5738             }
5739
5740             if(*(GuildDisp1 + i) <= 0)
5741                 break;
5742
5743             NSMutableDictionary* dict = [NSMutableDictionary new];
5744             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp1 + i)-1].name] forKey:@"name"];
5745             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp1 + i)-1].S_M.HP] forKey:@"HP"];
5746             [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d", UC[*(GuildDisp1 + i)-1].S_M.cSupply, UC[*(GuildDisp1 + i)-1].S_M.cFood, UC[*(GuildDisp1 + i)-1].S_M.cMoney] forKey:@"cost"];
5747             [dict setValue:UC[*(GuildDisp1 + i)-1].img forKey:@"img"];
5748
5749
5750             [self willChangeValueForKey:@"CResearchListMA"];
5751             [CResearchListMA addObject:dict];
5752             [self didChangeValueForKey:@"CResearchListMA"];
5753
5754         }
5755
5756
5757
5758         int k = 0;
5759         B->R = Rtop;
5760
5761         while (B->R) {
5762             B->R = B->R->next;
5763             k++;
5764         }
5765
5766         for(int i = k;i <= crCRL;i++){
5767             if(*(GuildDisp1 + i - k) <= 0)
5768                 continue;
5769
5770             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ATK]];
5771             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.DEF]];
5772             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.CAP]];
5773             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ACU]];
5774             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.EVA]];
5775             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp1 + i - k)-1].S_M.MOV]];
5776             [researchIMG setImage:UC[*(GuildDisp1 + i - k)-1].imgb];
5777             [researchIMG setImageScaling:NSScaleToFit];
5778
5779         }B->R = Rtop;
5780
5781         guildRE1 = true;
5782     }else if(B->GuildFlag && (buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3)){
5783
5784         int a = MS.guildListRegistNum22 - MS.guildListRegistNum21;
5785
5786         if(!guildRE2){
5787         Gnum2 = 0;
5788         if(a > 0)
5789             Gnum2 = MS.guildListRegistNum21 + arc4random()%(MS.guildListRegistNum22 - MS.guildListRegistNum21+1);
5790         else
5791             Gnum2 = MS.guildListRegistNum22;
5792
5793         if(Gnum2 > GCnum2+1)
5794             Gnum2 = GCnum2;
5795         }
5796         int n = 0;
5797
5798         guildc = 0;
5799         saveGuildList = calloc((GCnum2+1), sizeof(int));
5800         if(!guildRE2) GuildDisp2 = calloc(Gnum2, sizeof(int));
5801         for(int i = 0;i < Gnum2;i++){
5802             if(!guildRE2){
5803                 n = [self chooseGuildList:GuildChosen2 gcnum:GCnum2];
5804                 if(n == -1)
5805                     break;
5806                 *(GuildDisp2 + i) = *(GuildChosen2 + n);
5807             }
5808
5809             if(*(GuildDisp2 + i) <= 0)
5810                 break;
5811
5812             NSMutableDictionary* dict = [NSMutableDictionary new];
5813             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp2 + i)-1].name] forKey:@"name"];
5814             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp2 + i)-1].S_M.HP] forKey:@"HP"];
5815             [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d", UC[*(GuildDisp2 + i)-1].S_M.cSupply, UC[*(GuildDisp2 + i)-1].S_M.cFood, UC[*(GuildDisp2 + i)-1].S_M.cMoney] forKey:@"cost"];
5816             [dict setValue:UC[*(GuildDisp2 + i)-1].img forKey:@"img"];
5817
5818
5819             [self willChangeValueForKey:@"CResearchListMA"];
5820             [CResearchListMA addObject:dict];
5821             [self didChangeValueForKey:@"CResearchListMA"];
5822         }
5823
5824         int k = 0;
5825         B->R = Rtop;
5826         while (B->R) {
5827             B->R = B->R->next;
5828             k++;
5829         }
5830
5831         for(int i = k;i <= crCRL;i++){
5832             if(*(GuildDisp2 + i - k) <= 0)
5833                 continue;
5834
5835
5836             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ATK]];
5837             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.DEF]];
5838             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.CAP]];
5839             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ACU]];
5840             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.EVA]];
5841             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp2 + i - k)-1].S_M.MOV]];
5842             [researchIMG setImage:UC[*(GuildDisp2 + i - k)-1].imgb];
5843             [researchIMG setImageScaling:NSScaleToFit];
5844
5845         }B->R = Rtop;
5846
5847
5848         guildRE2 = true;
5849     }
5850
5851
5852
5853
5854
5855
5856
5857
5858     return true;
5859 }
5860 -(int)chooseGuildList:(int*)value gcnum:(int)gcnum{
5861
5862     int a = 0;
5863     while(1){
5864         bool sameFlag = false;
5865         bool sameFlag2 = false;
5866
5867         if(guildc >= gcnum+1){
5868             a = -1;
5869             break;
5870         }
5871
5872         a = arc4random()%(gcnum+1);
5873
5874         for(int i = 0;i < guildc;i++){
5875             if(*(saveGuildList+i) == a){
5876                 sameFlag2 = true;
5877                 break;
5878             }
5879         }
5880
5881         if(sameFlag2)
5882             continue;
5883
5884         *(saveGuildList+guildc) = a;
5885
5886         guildc++;
5887
5888         U = UTop;
5889         while(U){
5890             if([UC[*(value + a)-1].nameID isEqualToString:U->C.nameID]){
5891                 sameFlag = true;
5892                 break;
5893             }
5894             U = U->next;
5895         }U = UTop;
5896
5897         if(!sameFlag)
5898             break;
5899     }
5900
5901
5902     return a;
5903 }
5904
5905 -(void)initGuildList{
5906
5907     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5908
5909     GuildChosen1 = calloc(UCN, sizeof(int));
5910     GuildChosen2 = calloc(UCN, sizeof(int));
5911
5912     GCnum1 = -1;
5913     for (int i = 0;i < UCN;i++) {
5914         if(MS.guildListRegist[i]){
5915             GCnum1++;
5916             *(GuildChosen1 + GCnum1) = i+1;
5917         }
5918     }
5919     GCnum2 = -1;
5920     for (int i = 0;i < UCN;i++) {
5921         if(MS.guildListRegist2[i]){
5922             GCnum2++;
5923             *(GuildChosen2 + GCnum2) = i+1;
5924         }
5925     }
5926
5927 }
5928
5929
5930 -(void)SetMenu{
5931
5932     [self setCommandPanel];
5933     [menuPanel makeKeyAndOrderFront:nil];
5934 }
5935
5936 -(IBAction)pushMove:(id)sender{menuDisplayFlag = false;
5937     [menuPanel close];
5938     moveFlag = true;
5939     attackFlag = false;
5940     createFlag = false;
5941     summonFlag = false;
5942 }
5943 -(IBAction)pushAttack:(id)sender{menuDisplayFlag = false;
5944     [menuPanel close];
5945     attackFlag = true;
5946     moveFlag = false;
5947     windowPoint.x = [mapWindow frame].origin.x;
5948     windowPoint.y = [mapWindow frame].origin.y;
5949     [atkPanel setFrameOrigin:windowPoint];
5950
5951     U = UTop;
5952     while (!(AUN[1] == U->number)) {
5953         U = U->next;
5954     }
5955
5956     if(U->chipNumberL >= 0){
5957         U = UTop;
5958         [self initCAttackList2];
5959         [self initCAttackSelect2];
5960     }
5961     else if(U->chipNumber >= 0) {
5962         U = UTop;
5963         [self initCAttackList];
5964         [self initCAttackSelect];
5965     }
5966     U = UTop;
5967     [atkPanel makeKeyAndOrderFront:nil];
5968 }
5969 -(IBAction)pushStandby:(id)sender{menuDisplayFlag = false;
5970
5971     U = UTop;
5972
5973     while (U->number != wtUnitNum) {
5974         U = U->next;
5975     }
5976
5977     if(!wtMovedFlag && !wtAttackedFlag){
5978         U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
5979     }else if(wtMovedFlag && wtAttackedFlag){
5980         U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
5981     }else if(wtMovedFlag){
5982         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
5983     }else if(wtAttackedFlag){
5984         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
5985     }
5986
5987     BTop = B;
5988     while (B) {
5989         if(B->x == possionX && B->y == possionY && B->C.capture){
5990             buildCaptureFlag = true;
5991             unitMoveEndFlag = true;
5992         }
5993         B = B->next;
5994     }B = BTop;
5995
5996     U = UTop;
5997
5998     wtRdy = false;
5999     wtRdy2 = false;
6000     wtRdy3 = false;
6001     pushStanbyFlag = true;
6002     pussyLoopFlag = false;
6003     [menuPanel close];
6004 }
6005 -(IBAction)pushCreate:(id)sender{menuDisplayFlag = false;
6006     [menuPanel close];
6007     createFlag = true;
6008     moveFlag = false;
6009
6010     windowPoint.x = [mapWindow frame].origin.x;
6011     windowPoint.y = [mapWindow frame].origin.y;
6012     [createPanel setFrameOrigin:windowPoint];
6013
6014     [self initBCreateList];
6015     [createPanel makeKeyAndOrderFront:nil];
6016 }
6017
6018 -(IBAction)pushSummon:(id)sender{menuDisplayFlag = false;
6019     [menuPanel close];
6020     summonFlag = true;
6021     moveFlag = false;
6022
6023     windowPoint.x = [mapWindow frame].origin.x;
6024     windowPoint.y = [mapWindow frame].origin.y;
6025     [summonPanel setFrameOrigin:windowPoint];
6026
6027     [self initCSummonList];
6028     [summonPanel makeKeyAndOrderFront:nil];
6029 }
6030
6031
6032
6033 -(void)initStatusWindow{
6034
6035     U = UTop;
6036
6037     [STIV setImage:Uselected->C.imgb];
6038     [STnameTF setStringValue:Uselected->C.name];
6039     [STclassTF setStringValue:Uselected->C.nameClass];
6040     [SThpTF setStringValue:[NSString stringWithFormat:@"HP　%g/%g", Uselected->C.S_C.HP, Uselected->C.S_M.HP]];
6041     [STmpTF setStringValue:[NSString stringWithFormat:@"MP　%g/%g", Uselected->C.S_C.MP, Uselected->C.S_M.MP]];
6042     [STatkTF setStringValue:[NSString stringWithFormat:@"ATK %g", Uselected->C.S_C.ATK]];
6043     [STdefTF setStringValue:[NSString stringWithFormat:@"DEF %g", Uselected->C.S_C.DEF]];
6044     [STcapTF setStringValue:[NSString stringWithFormat:@"CAP %g", Uselected->C.S_C.CAP]];
6045     [STacuTF setStringValue:[NSString stringWithFormat:@"ACU %g", Uselected->C.S_C.ACU]];
6046     [STevaTF setStringValue:[NSString stringWithFormat:@"EVA %g", Uselected->C.S_C.EVA]];
6047     [STstrTF setStringValue:[NSString stringWithFormat:@"STR %g", Uselected->C.S_C.STR]];
6048     [STvitTF setStringValue:[NSString stringWithFormat:@"VIT %g", Uselected->C.S_C.VIT]];
6049     [STagiTF setStringValue:[NSString stringWithFormat:@"AGI %g", Uselected->C.S_C.AGI]];
6050     [STdexTF setStringValue:[NSString stringWithFormat:@"DEX %g", Uselected->C.S_C.DEX]];
6051     [STmenTF setStringValue:[NSString stringWithFormat:@"MEN %g", Uselected->C.S_C.MEN]];
6052     [STintTF setStringValue:[NSString stringWithFormat:@"INT %g", Uselected->C.S_C.INT]];
6053     [STmelTF setStringValue:[NSString stringWithFormat:@"MEL %g", Uselected->C.S_C.MEL]];
6054     [STmisTF setStringValue:[NSString stringWithFormat:@"MIS %g", Uselected->C.S_C.MIS]];
6055     [SThitTF setStringValue:[NSString stringWithFormat:@"HIT %g", Uselected->C.S_C.HIT]];
6056     [STdodTF setStringValue:[NSString stringWithFormat:@"DOD %g", Uselected->C.S_C.DOD]];
6057     [STreaTF setStringValue:[NSString stringWithFormat:@"REA %g", Uselected->C.S_C.REA]];
6058     [STskiTF setStringValue:[NSString stringWithFormat:@"SKI %g", Uselected->C.S_C.SKI]];
6059     [STvigTF setStringValue:[NSString stringWithFormat:@"VIG %d", Uselected->C.S_C.vigor]];
6060
6061
6062
6063
6064
6065
6066
6067     U = UTop;
6068 }
6069
6070 -(IBAction)pushStatus:(id)sender{menuDisplayFlag = false;
6071
6072     [self initStatusWindow];
6073
6074     windowPoint.x = [mapWindow frame].origin.x;
6075     windowPoint.y = [mapWindow frame].origin.y;
6076     [STwindow setFrameOrigin:windowPoint];
6077     [STwindow makeKeyAndOrderFront:nil];
6078
6079
6080
6081     [menuPanel close];
6082 }
6083
6084 -(IBAction)STsubmit:(id)sender{
6085
6086     [STwindow close];
6087 }
6088
6089 -(IBAction)pushCancel:(id)sender{menuDisplayFlag = false;
6090     moveFlag = false;
6091     attackFlag = false;
6092     summonFlag = false;
6093     [menuPanel close];
6094 }
6095 -(IBAction)pushCancelCAL:(id)sender{
6096     attackFlag = false;
6097     [atkPanel close];
6098 }
6099
6100 -(IBAction)pushCancelBCL:(id)sender{
6101     createFlag = false;
6102     [createPanel close];
6103 }
6104
6105 -(IBAction)pushCancelCSL:(id)sender{
6106     summonFlag = false;
6107     [summonPanel close];
6108 }
6109
6110 -(void)addBuildStatus{
6111     //おまんちん
6112
6113     registerNumB++;
6114
6115     if(registerNumB == 1){
6116         B = calloc(1, sizeof(BUILD));
6117         BTop = B;
6118     }
6119
6120     int omgCnt = 0;
6121     B = BTop;
6122     if(B)
6123     while (B->next) {omgCnt++;
6124         B = B->next;
6125     }
6126     if(registerNumB != 1){
6127         B->next = calloc(1, sizeof(BUILD));
6128         if(registerNumB == 2)
6129             BTop = B;
6130         B = B->next;
6131     }
6132         B->next = NULL;
6133
6134     B->number = registerNumB;
6135
6136
6137     B->chipNumber = BC[buildNum[possionX][possionY]].chipNumb;
6138     B->x = possionX;
6139     B->y = possionY;
6140     B->C = BC[buildNum[possionX][possionY]];
6141     B->img = [BC[buildNum[possionX][possionY]].img retain];
6142     unitColorInitFlag = true;
6143
6144     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
6145         B->team = 0;
6146         if(unitTeam[possionX][possionY] == 0){
6147             U->joinArmyFromNext = true;
6148             U->persuasion = true;
6149         }
6150     }
6151     if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
6152         B->team = 2;
6153     }
6154     if(buildTeam[possionX][possionY] == 4 || buildTeam[possionX][possionY] == 5){
6155         B->team = 1;
6156     }
6157     if(buildTeam[possionX][possionY] == -1){
6158         B->team = -1;
6159
6160     }
6161
6162     B = BTop;
6163 }
6164
6165
6166 -(void)addUnitStatus{
6167     registerNum++;
6168     int omgCnt = 0;
6169     U = UTop;
6170     while (U->next) {omgCnt++;
6171         U = U->next;
6172     }
6173     U->next = calloc(1, sizeof(UNIT));
6174     U = U->next;
6175     U->next = NULL;
6176     if(omgCnt == 0) U = UTop;
6177     U->number = registerNum;
6178
6179     for(int i = 0;i < UCN;i++){
6180         if([U->C.nameID isEqualToString:UC[i].nameID])
6181             U->chipNumber = i;
6182     }
6183
6184     U->chipNumber = unitNum[possionX][possionY];
6185     U->chipNumberL = loadNum[possionX][possionY];
6186     U->C.chipNumb = unitNum[possionX][possionY];
6187     U->CL.chipNumb = loadNum[possionX][possionY];
6188     U->x = possionX;
6189     U->y = possionY;
6190     U->C = *BRU;
6191                 if(unitTeam[possionX][possionY] == 0 || unitTeam[possionX][possionY] == 1){
6192                     U->team = 0;
6193                     if(unitTeam[possionX][possionY] == 1){
6194                         U->joinArmyFromNext = true;
6195                         U->persuasion = true;
6196                     }
6197
6198                     if(MF[MFselectedRow+1].MS.playerSet1 == 2){
6199                         U->CPU = true;
6200                     }
6201                 }
6202                 if(unitTeam[possionX][possionY] == 2 || unitTeam[possionX][possionY] == 3){
6203                     U->team = 2;
6204                     if(unitTeam[possionX][possionY] == 3){
6205                         U->joinArmyFromNext = true;
6206                         U->persuasion = true;
6207                     }
6208
6209                     if(MF[MFselectedRow+1].MS.playerSet2 == 2){
6210                         U->CPU = true;
6211                     }
6212                 }
6213                 if(unitTeam[possionX][possionY] == 4 || unitTeam[possionX][possionY] == 5){
6214                     U->team = 1;
6215                     if(unitTeam[possionX][possionY] == 5){
6216                         U->joinArmyFromNext = true;
6217                         U->persuasion = true;
6218                     }
6219                     U->CPU = true;
6220                 }
6221                 if(unitTeam[possionX][possionY] == -1){
6222                     U->team = -1;
6223                     if(unitTeam[possionX][possionY] == 0){
6224                         U->joinArmyFromNext = false;
6225                         U->persuasion = true;
6226                     }
6227                     U->CPU = true;
6228                 }
6229
6230
6231                 [self SetUnitStatus:unitNum[possionX][possionY]];
6232     U = UTop;
6233 }
6234
6235 -(void)addSummonStatus{
6236     registerNum++;
6237     int omgCnt = 0;
6238     U = UTop;
6239     while (U->next) {omgCnt++;
6240         U = U->next;
6241     }
6242     U->next = calloc(1, sizeof(UNIT));
6243     U = U->next;
6244     U->next = NULL;
6245     if(omgCnt == 0) U = UTop;
6246
6247
6248     U->x = possionX;
6249     U->y = possionY;
6250
6251     U->C = CSLUC;
6252     if(unitTeam[CSLU->x][CSLU->y] == 0 || unitTeam[CSLU->x][CSLU->y] == 1){
6253         U->team = 0;
6254         if(unitTeam[CSLU->x][CSLU->y] == 1){
6255             U->joinArmyFromNext = true;
6256             U->persuasion = true;
6257         }
6258     }
6259     if(unitTeam[CSLU->x][CSLU->y] == 2 || unitTeam[CSLU->x][CSLU->y] == 3){
6260         U->team = 2;
6261         if(unitTeam[CSLU->x][CSLU->y] == 3){
6262             U->joinArmyFromNext = true;
6263             U->persuasion = true;
6264         }
6265     }
6266     if(unitTeam[CSLU->x][CSLU->y] == 4 || unitTeam[CSLU->x][CSLU->y] == 5){
6267         U->team = 1;
6268         if(unitTeam[CSLU->x][CSLU->y] == 5){
6269             U->joinArmyFromNext = true;
6270             U->persuasion = true;
6271         }
6272     }
6273     if(unitTeam[CSLU->x][CSLU->y] == -1){
6274         U->team = -1;
6275         if(unitTeam[CSLU->x][CSLU->y] == 0){
6276             U->joinArmyFromNext = false;
6277             U->persuasion = true;
6278         }
6279     }
6280
6281     [self SetUnitStatus:unitNum[possionX][possionY]];
6282
6283     for(int i = 0;i < UCN;i++){
6284         if([U->C.nameID isEqualToString:UC[i].nameID])
6285             U->chipNumber = i;
6286     }
6287     for(int i = 0;i < LCN;i++){
6288         if([U->CL.nameID isEqualToString:LC[i].nameID])
6289             U->chipNumberL = i;
6290     }
6291     for(int i = 0;i < UCN;i++){
6292         if([U->C.nameID isEqualToString:UC[i].nameID])
6293             U->C.chipNumb = i;
6294     }
6295     for(int i = 0;i < LCN;i++){
6296         if([U->CL.nameID isEqualToString:LC[i].nameID])
6297             U->CL.chipNumb = i;
6298     }
6299
6300     U = UTop;
6301
6302 }
6303
6304 -(void)initUnitStatusDat{
6305     U = NULL;
6306     UTop = NULL;
6307     for(int i = 0;i < sdd2[datRow].registerNum;i++){
6308         if(i == 0){
6309             U = calloc(1, sizeof(UNIT));
6310             UTop = U;
6311         }
6312         if(i > 0)
6313             U = U->next;
6314
6315         U->x = sdd2[datRow].dU[i].x;
6316         U->y = sdd2[datRow].dU[i].y;
6317         U->number = sdd2[datRow].dU[i].number;;
6318         U->chipNumber = sdd2[datRow].dU[i].chipNumber;
6319         U->chipNumberL = sdd2[datRow].dU[i].chipNumberL;
6320         U->C.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6321         U->CL.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6322         U->atkRange = 0;
6323         U->dead = sdd2[datRow].dU[i].dead;
6324
6325         U->team = sdd2[datRow].dU[i].team;
6326         U->CPU = sdd2[datRow].dU[i].CPU;
6327         U->joinArmyFromNext = sdd2[datRow].dU[i].joinArmyFromNext;
6328         U->persuasion = sdd2[datRow].dU[i].persuasion;
6329
6330         U->ix = sdd2[datRow].dU[i].ix;
6331         U->iy = sdd2[datRow].dU[i].iy;
6332         U->iz = sdd2[datRow].dU[i].iz;
6333
6334
6335
6336         if(U->chipNumber >= 0) [self SetUnitStatus:U->chipNumber];
6337         if(U->chipNumberL >= 0) [self SetUnitStatus2:U->chipNumberL];
6338
6339         U->C.S_C = sdd2[datRow].dU[i].C.S_C;
6340         U->C.R_C = sdd2[datRow].dU[i].C.R_C;
6341
6342         if(U->chipNumberL >= 0) U->img = [LC[U->chipNumberL].img retain];
6343             else U->img = [UC[U->chipNumber].img retain];
6344
6345
6346         unitTeam[U->x][U->y] = U->team;
6347         unitNum[U->x][U->y] = U->chipNumber;
6348         loadNum[U->x][U->y] = U->chipNumberL;
6349
6350
6351         U->next = calloc(1, sizeof(UNIT));
6352     }
6353
6354     if(U) U->next = NULL;
6355     U = UTop;
6356
6357 }
6358
6359
6360 -(void)initUnitStatus{
6361     registerNum = 0;
6362     U = NULL;
6363     UTop = NULL;
6364     for(int i=1;i <= chipHeight;i++){
6365         for(int j=1;j<= chipWidth;j++){
6366             if(unitNum[j][i] >= 0 || loadNum[j][i] >= 0){
6367                 registerNum++;
6368                 if(registerNum == 1){
6369                     U = calloc(1, sizeof(UNIT));
6370                     UTop = U;
6371                 }
6372                 if(registerNum > 1)
6373                     U = U->next;
6374                 U->x = j;
6375                 U->y = i;
6376                 U->number = registerNum;
6377                 U->chipNumber = unitNum[j][i];
6378                 U->chipNumberL = loadNum[j][i];
6379                 U->C.chipNumb = U->chipNumber;
6380                 U->CL.chipNumb = U->chipNumberL;
6381
6382                 if(unitTeam[j][i] == 0 || unitTeam[j][i] == 1){
6383                     U->team = 0;
6384                     if(unitTeam[j][i] == 1){
6385                         U->joinArmyFromNext = true;
6386                         U->persuasion = true;
6387                     }
6388                     if(MF[MFselectedRow+1].MS.playerSet1 == 2)
6389                         U->CPU = true;
6390                 }
6391                 if(unitTeam[j][i] == 2 || unitTeam[j][i] == 3){
6392                     U->team = 2;
6393                     if(unitTeam[i][j] == 2){
6394                         U->joinArmyFromNext = true;
6395                         U->persuasion = true;
6396                     }
6397                     if(MF[MFselectedRow+1].MS.playerSet2 == 2)
6398                         U->CPU = true;
6399                 }
6400                 if(unitTeam[j][i] == 4 || unitTeam[j][i] == 5){
6401                     U->team = 1;
6402                     if(unitTeam[j][i] == 5){
6403                         U->joinArmyFromNext = true;
6404                         U->persuasion = true;
6405                     }
6406                     U->CPU = true;
6407                 }
6408                 if(unitTeam[j][i] == -1){
6409                     U->team = -1;
6410                     if(unitTeam[j][i] == -1){
6411                         U->joinArmyFromNext = false;
6412                         U->persuasion = true;
6413                     }
6414                     U->CPU = true;
6415                 }
6416                 if(unitNum[j][i] >= 0) [self SetUnitStatus:unitNum[j][i]];
6417                 if(loadNum[j][i] >= 0) [self SetUnitStatus2:loadNum[j][i]];
6418
6419                 U->next = calloc(1, sizeof(UNIT));
6420                 U->atkRange = 0;
6421
6422                 U->ix = U->x;
6423                 U->iy = U->y;
6424                 U->iz = 0;
6425
6426                 UNIT *Ucrnt = U;
6427
6428                 U = UTop;
6429                 while(U){
6430                     if(Ucrnt->x == U->x && Ucrnt->y == U->y){
6431                         Ucrnt->iz++;
6432                     }
6433                     U = U->next;
6434                 }
6435
6436                 U = Ucrnt;
6437             }
6438
6439         }
6440     }
6441
6442     if(U) U->next = NULL;
6443
6444     U = UTop;
6445 }
6446
6447 -(void)initBuildStatusDat{
6448     B = NULL;
6449     BTop = NULL;
6450     for(int i = 0;i < sdd2[datRow].registerNumB;i++){
6451         if(i == 0){
6452             B = calloc(1, sizeof(BUILD));
6453             BTop = B;
6454         }
6455         if(i > 0)
6456             B = B->next;
6457
6458         B->x = sdd2[datRow].dB[i].x;
6459         B->y = sdd2[datRow].dB[i].y;
6460         B->team = sdd2[datRow].dB[i].team;
6461         B->number = sdd2[datRow].dB[i].number;
6462         B->chipNumber = sdd2[datRow].dB[i].chipNumber;
6463         B->makeLv = sdd2[datRow].dB[i].makeLv;
6464         B->dead = sdd2[datRow].dB[i].dead;
6465
6466         B->C = BC[B->chipNumber];
6467         B->C.S_C = sdd2[datRow].dB[i].C.S_C;
6468
6469         B->img = [BC[B->chipNumber].img retain];
6470
6471         buildTeam[B->x][B->y] = B->team;
6472         buildNum[B->x][B->y] = B->chipNumber;
6473
6474         B->next = calloc(1, sizeof(BUILD));
6475     }
6476     if(B) B->next = NULL;
6477     B = BTop;
6478
6479 }
6480
6481
6482 -(void)initBuildStatus{
6483     B = NULL;
6484     BTop = NULL;
6485     for(int i=1;i <= chipHeight;i++){
6486         for(int j=1;j<= chipWidth;j++){
6487             if(buildNum[j][i] >= 0){
6488                 registerNumB++;
6489                 if(registerNumB == 1){
6490                     B = calloc(1, sizeof(BUILD));
6491                     BTop = B;
6492                 }
6493                 if(registerNumB > 1)
6494                     B = B->next;
6495                 B->x = j;
6496                 B->y = i;
6497                 B->number = registerNumB;
6498                 B->chipNumber = buildNum[j][i];
6499                 B->makeLv = 1;
6500                 if(buildTeam[j][i] == 0 || buildTeam[j][i] == 1){
6501                     B->team = 0;
6502
6503                 }
6504                 if(buildTeam[j][i] == 2 || buildTeam[j][i] == 3){
6505                     B->team = 2;
6506
6507                 }
6508                 if(buildTeam[j][i] == 4 || buildTeam[j][i] == 5){
6509                     B->team = 1;
6510
6511                 }
6512                 if(buildTeam[j][i] == -1){
6513                     B->team = -1;
6514
6515                 }
6516                 //[self SetUnitStatus:unitNum[j][i]];
6517
6518                 B->C = BC[buildNum[j][i]];
6519
6520                 B->next = calloc(1, sizeof(BUILD));
6521
6522             }
6523
6524         }
6525     }
6526     if(B) B->next = NULL;
6527     B = BTop;
6528
6529 }
6530
6531 -(void)SetUnitStatus:(int)UN{
6532
6533     U->C = UC[UN];
6534     U->C.S_C.vigor = 100;
6535
6536     ATTACK *Atop;
6537     ATTACK *AtopE1;
6538     ATTACK *AtopE2;
6539     ATTACK *UAtop;
6540     Atop = UC[UN].A;
6541     AtopE1 = UC[UN].eHandL.A;
6542     AtopE2 = UC[UN].eHandR.A;
6543     U->C.A = calloc(1, sizeof(ATTACK));
6544     UAtop = U->C.A;
6545
6546     bool ow1 = false;
6547     bool ow2 = false;
6548
6549     while(UC[UN].eHandR.A != NULL){ow1 = true;
6550         *U->C.A = *UC[UN].eHandR.A;
6551         U->C.A->next = calloc(1, sizeof(ATTACK));
6552         U->C.A->next->next = NULL;
6553         if(UC[UN].eHandR.A->next != NULL) U->C.A = U->C.A->next;
6554         UC[UN].eHandR.A = UC[UN].eHandR.A->next;
6555         U->C.attackListNum++;
6556     }
6557     UC[UN].eHandR.A = AtopE2;
6558
6559
6560     if(ow1) {
6561         U->C.A = U->C.A->next;
6562         ow1 = false;
6563     }
6564     while(UC[UN].eHandL.A != NULL){ow2 = true;
6565         *U->C.A = *UC[UN].eHandL.A;
6566         U->C.A->next = calloc(1, sizeof(ATTACK));
6567         U->C.A->next->next = NULL;
6568         if(UC[UN].eHandL.A->next != NULL) U->C.A = U->C.A->next;
6569         UC[UN].eHandL.A = UC[UN].eHandL.A->next;
6570         U->C.attackListNum++;
6571     }
6572     UC[UN].eHandL.A = AtopE1;
6573
6574     if(ow2) {
6575         U->C.A = U->C.A->next;
6576         ow2 = false;
6577     }
6578     while(UC[UN].A != NULL){
6579         *U->C.A = *UC[UN].A;
6580         U->C.A->next = calloc(1, sizeof(ATTACK));
6581         U->C.A->next->next = NULL;
6582         if(UC[UN].A->next != NULL) U->C.A = U->C.A->next;
6583         UC[UN].A = UC[UN].A->next;
6584     }
6585     U->C.A->next = NULL;
6586     UC[UN].A = Atop;
6587     U->C.A = UAtop;
6588     if(U->C.A) if(!U->C.A->name)
6589         U->C.A = NULL;
6590
6591 }
6592
6593 -(void)SetUnitStatus2:(int)UN{
6594
6595     U->CL = LC[UN];
6596
6597     ATTACK *Atop;
6598     ATTACK *UAtop;
6599     Atop = LC[UN].A;
6600     U->CL.A = calloc(1, sizeof(ATTACK));
6601     UAtop = U->CL.A;
6602     while(LC[UN].A != NULL){
6603         *U->CL.A = *LC[UN].A;
6604         U->CL.A->next = calloc(1, sizeof(ATTACK));
6605         U->CL.A->next->next = NULL;
6606         if(LC[UN].A->next != NULL) U->CL.A = U->CL.A->next;
6607         LC[UN].A = LC[UN].A->next;
6608     }
6609     U->CL.A->next = NULL;
6610     LC[UN].A = Atop;
6611     U->CL.A = UAtop;
6612
6613 }
6614
6615
6616 -(void)initCAttackList2{
6617     crCAL = 0;
6618
6619     CAttackListMA = [NSMutableArray new];
6620
6621     [self willChangeValueForKey:@"CAttackListMA"];
6622     [CAttackListMA removeAllObjects];
6623     [self didChangeValueForKey:@"CAttackListMA"];
6624
6625     U = UTop;
6626     if(!battleSet2PushedFlag){
6627         ATTACK *Atop;
6628         while (!(AUN[1] == U->number)) {
6629             U = U->next;
6630         }
6631         Atop = U->CL.A;
6632         for(int i = 0;i < U->CL.attackListNum;i++){
6633             if(!U->CL.A) break;
6634             NSMutableDictionary* dict = [NSMutableDictionary new];
6635             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6636             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6637             if(U->CL.A->rangeA != U->CL.A->rangeB){
6638                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6639             }else{
6640                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6641             }
6642             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6643             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6644
6645             [self willChangeValueForKey:@"CAttackListMA"];
6646             [CAttackListMA addObject:dict];
6647             [self didChangeValueForKey:@"CAttackListMA"];
6648
6649             U->CL.A = U->CL.A->next;
6650         }
6651
6652         U->CL.A = Atop;
6653     }else{
6654         ATTACK *Atop;
6655         while (!(DUN[1] == U->number)) {
6656             U = U->next;
6657         }
6658         Atop = U->CL.A;
6659         for(int i = 0;i < U->CL.attackListNum;i++){
6660
6661             if(!U->CL.A){
6662                 U->CL.attackListNum = i;
6663                 break;
6664             }
6665             NSMutableDictionary* dict = [NSMutableDictionary new];
6666             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6667             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6668             if(U->CL.A->rangeA != U->CL.A->rangeB){
6669                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6670             }else{
6671                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6672             }
6673             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6674             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6675
6676             [self willChangeValueForKey:@"CAttackListMA"];
6677             [CAttackListMA addObject:dict];
6678             [self didChangeValueForKey:@"CAttackListMA"];
6679
6680             U->CL.A = U->CL.A->next;
6681         }
6682
6683         U->CL.A = Atop;
6684
6685     }
6686     U = UTop;
6687
6688     [CAttackListAC setSelectionIndex:crCAL];
6689
6690     [self initCAttackSelect2];
6691
6692
6693
6694
6695 }
6696
6697 -(void)initCAttackList{
6698     crCAL = 0;
6699     CAttackListMA = [NSMutableArray new];
6700
6701     [self willChangeValueForKey:@"CAttackListMA"];
6702     [CAttackListMA removeAllObjects];
6703     [self didChangeValueForKey:@"CAttackListMA"];
6704
6705     U = UTop;
6706     if(!battleSet2PushedFlag){
6707         ATTACK *Atop;
6708     while (!(AUN[1] == U->number)) {
6709         U = U->next;
6710     }
6711     Atop = U->C.A;
6712         for(int i = 0;i < U->C.attackListNum;i++){
6713             if(!U->C.A) {
6714                 U->C.attackListNum = i;
6715                 break;
6716             };
6717         NSMutableDictionary* dict = [NSMutableDictionary new];
6718         [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6719         [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6720         if(U->C.A->rangeA != U->C.A->rangeB){
6721             [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6722         }else{
6723             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6724         }
6725         [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6726         //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6727
6728         [self willChangeValueForKey:@"CAttackListMA"];
6729         [CAttackListMA addObject:dict];
6730         [self didChangeValueForKey:@"CAttackListMA"];
6731
6732         U->C.A = U->C.A->next;
6733     }
6734
6735     U->C.A = Atop;
6736     }else{
6737
6738         ATTACK *Atop;
6739         while (!(DUN[1] == U->number)) {
6740             U = U->next;
6741         }
6742         Atop = U->C.A;
6743         for(int i = 0;i < U->C.attackListNum;i++){
6744             NSMutableDictionary* dict = [NSMutableDictionary new];
6745             [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6746             [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6747             if(U->C.A->rangeA != U->C.A->rangeB){
6748                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6749             }else{
6750                 [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6751             }
6752             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6753             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6754
6755             [self willChangeValueForKey:@"CAttackListMA"];
6756             [CAttackListMA addObject:dict];
6757             [self didChangeValueForKey:@"CAttackListMA"];
6758
6759             U->C.A = U->C.A->next;
6760         }
6761
6762         U->C.A = Atop;
6763
6764     }
6765     U = UTop;
6766
6767     [CAttackListAC setSelectionIndex:crCAL];
6768
6769     [self initCAttackSelect];
6770 }
6771
6772 -(void)initBCreateList{
6773     BCreateListMA = [NSMutableArray new];
6774
6775     [self willChangeValueForKey:@"BCreateListMA"];
6776     [BCreateListMA removeAllObjects];
6777     [self didChangeValueForKey:@"BCreateListMA"];
6778     buildSkillFlag = false;
6779
6780     U = UTop;
6781     SKILL *Stop;
6782     while (!(AUN[1] == U->number)) {
6783         U = U->next;
6784     }
6785     Stop = U->C.S;
6786     if(!U->C.S) {
6787         U = UTop;
6788         return;
6789     }
6790     while (U->C.S->type != 1 && U->C.S->next) {
6791         U->C.S = U->C.S->next;
6792     }
6793     if(U->C.S->type != 1) {
6794         U->C.S = Stop;
6795         U = UTop;
6796         return;
6797     }
6798     for(int i = 0;U->C.S->list[i] > 0;i++){
6799         NSMutableDictionary* dict = [NSMutableDictionary new];
6800         [dict setValue:[NSString stringWithFormat:@"%@", BC[U->C.S->list[i]-1].name] forKey:@"name"];
6801         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d",
6802                         BC[U->C.S->list[i]-1].Csupply, BC[U->C.S->list[i]-1].Cfood, BC[U->C.S->list[i]-1].Cmoney] forKey:@"cost"];
6803         [dict setValue:BC[U->C.S->list[i]-1].img forKey:@"img"];
6804
6805         [self willChangeValueForKey:@"BCreateListMA"];
6806         [BCreateListMA addObject:dict];
6807         [self didChangeValueForKey:@"BCreateListMA"];
6808
6809         buildSkillFlag = true;
6810     }
6811     U->C.S = Stop;
6812     U = UTop;
6813 }
6814
6815 -(void)initCSummonList{
6816     CSummonListMA = [NSMutableArray new];
6817
6818     [self willChangeValueForKey:@"CSummonListMA"];
6819     [CSummonListMA removeAllObjects];
6820     [self didChangeValueForKey:@"CSummonListMA"];
6821
6822     summonSkillFlag = false;
6823
6824     U = UTop;
6825     SKILL *Stop;
6826     while (!(AUN[1] == U->number)) {
6827         U = U->next;
6828     }
6829     Stop = U->C.S;
6830     if(!U->C.S) {
6831         U = UTop;
6832         return;
6833     }
6834     while (U->C.S->type != 2 && U->C.S->next) {
6835         U->C.S = U->C.S->next;
6836     }
6837     if(U->C.S->type != 2) {
6838         U->C.S = Stop;
6839         U = UTop;
6840         return;
6841     }
6842     for(int i = 0;U->C.S->list[i] > 0;i++){
6843         NSMutableDictionary* dict = [NSMutableDictionary new];
6844         [dict setValue:[NSString stringWithFormat:@"%@", UC[U->C.S->list[i]-1].nameClass] forKey:@"name"];
6845         [dict setValue:[NSString stringWithFormat:@"%g", UC[U->C.S->list[i]-1].S_M.HP] forKey:@"HP"];
6846         [dict setValue:[NSString stringWithFormat:@"%g", U->C.S->cost[i]] forKey:@"cost"];
6847         [dict setValue:UC[U->C.S->list[i]-1].img forKey:@"img"];
6848
6849         [self willChangeValueForKey:@"CSummonListMA"];
6850         [CSummonListMA addObject:dict];
6851         [self didChangeValueForKey:@"CSummonListMA"];
6852
6853         summonSkillFlag = true;
6854     }
6855     U->C.S = Stop;
6856     U = UTop;
6857
6858 }
6859
6860
6861 -(void)AttackDisplay{
6862
6863     if(battleRdy) return;
6864     if(!battleSetUp) return;
6865     if(!fuckingLoadBugFix) return;
6866
6867     U = UTop;
6868     while (!(AUN[1] == U->number)) {
6869         U = U->next;
6870     }
6871     [bplayer1 setImage:U->C.imgb];
6872     [bplayer1 setImageScaling:NSScaleToFit];
6873     [nplayer1 setStringValue:U->C.name];
6874     [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6875     [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6876     [iplayer1 setImage:MC[chipNum[U->x][U->y]].img];
6877     [mplayer1 setStringValue:MC[chipNum[U->x][U->y]].name];
6878     [rplayer1 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6879
6880     U = UTop;
6881
6882
6883     U = UTop;
6884     while (!(DUN[1] == U->number)) {
6885         U = U->next;
6886     }
6887     [bplayer2 setImage:U->C.imgb];
6888     [bplayer1 setImageScaling:NSScaleToFit];
6889     [nplayer2 setStringValue:U->C.name];
6890     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6891     [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6892     [iplayer2 setImage:MC[chipNum[U->x][U->y]].img];
6893     [mplayer2 setStringValue:MC[chipNum[U->x][U->y]].name];
6894     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6895     U = UTop;
6896
6897     [self AttackDisplay2];
6898
6899     messageProcess = 0;
6900     [battleDialog setStringValue:@"攻撃開始!!!!"];
6901
6902     battleRdy = true;
6903
6904 }
6905
6906 -(void)AttackDisplay2{
6907
6908     U = UTop;
6909
6910     while (!(DUN[1] == U->number)) {
6911         U = U->next;
6912     }
6913     U2 = U;
6914     U = UTop;
6915     while (!(AUN[1] == U->number)) {
6916         U = U->next;
6917     }
6918
6919
6920     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){U = UTop;
6921
6922         U = UTop;
6923         while (!(AUN[1] == U->number)) {
6924             U = U->next;
6925         }
6926         [bplayer1 setImage:U->CL.imgb];
6927         [bplayer1 setImageScaling:NSScaleToFit];
6928         [nplayer1 setStringValue:U->CL.name];
6929         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6930         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6931
6932         U = UTop;
6933
6934
6935         U = UTop;
6936         while (!(DUN[1] == U->number)) {
6937             U = U->next;
6938         }
6939         [bplayer2 setImage:U->CL.imgb];
6940         [bplayer1 setImageScaling:NSScaleToFit];
6941         [nplayer2 setStringValue:U->CL.name];
6942         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6943         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6944         U = UTop;
6945
6946
6947     }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){U = UTop;
6948         U = UTop;
6949         while (!(AUN[1] == U->number)) {
6950             U = U->next;
6951         }
6952         [bplayer1 setImage:U->CL.imgb];
6953         [bplayer1 setImageScaling:NSScaleToFit];
6954         [nplayer1 setStringValue:U->CL.name];
6955         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6956         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6957
6958         U = UTop;
6959
6960
6961         U = UTop;
6962         while (!(DUN[1] == U->number)) {
6963             U = U->next;
6964         }
6965         [bplayer2 setImage:U->C.imgb];
6966         [bplayer1 setImageScaling:NSScaleToFit];
6967         [nplayer2 setStringValue:U->C.name];
6968         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6969         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6970         U = UTop;
6971
6972
6973
6974
6975     }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){U = UTop;
6976         U = UTop;
6977         while (!(AUN[1] == U->number)) {
6978             U = U->next;
6979         }
6980         [bplayer1 setImage:U->C.imgb];
6981         [bplayer1 setImageScaling:NSScaleToFit];
6982         [nplayer1 setStringValue:U->C.name];
6983         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6984         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6985
6986         U = UTop;
6987
6988
6989         U = UTop;
6990         while (!(DUN[1] == U->number)) {
6991             U = U->next;
6992         }
6993         [bplayer2 setImage:U->CL.imgb];
6994         [bplayer1 setImageScaling:NSScaleToFit];
6995         [nplayer2 setStringValue:U->CL.name];
6996         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6997         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6998         U = UTop;
6999     }
7000
7001
7002     U = UTop;
7003 }
7004
7005 -(bool)sortEcheck:(ATTACK*)AT opponent:(UNIT*)UT{
7006
7007     if(AT->riku == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_RIKU)
7008         return true;
7009     if(AT->umi == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_UMI)
7010         return true;
7011     if(AT->chu == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_CHU)
7012         return true;
7013     if(AT->sora == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_SORA)
7014         return true;
7015
7016
7017
7018     return false;
7019 }
7020
7021 -(void)setBattlePanel{
7022     //おまんちん
7023     U = UTop;
7024
7025     while (!(DUN[1] == U->number)) {
7026         U = U->next;
7027     }
7028     U2 = U;
7029     U = UTop;
7030     while (!(AUN[1] == U->number)) {
7031         U = U->next;
7032     }
7033
7034     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
7035         U = UTop;
7036         [self setBattlePanelT2];
7037         return;
7038     }else if(U->chipNumberL >= 0 && U2->chipNumberL <= 0){
7039         U = UTop;
7040         [self setBattlePanelT3];
7041         return;
7042     }else if(U->chipNumberL <= 0 && U2->chipNumberL >= 0){
7043         U = UTop;
7044         [self setBattlePanelT4];
7045         return;
7046     }
7047
7048     U = UTop;
7049     while (!(AUN[1] == U->number)) {
7050         U = U->next;
7051     }
7052
7053     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7054         cpuModeBATTLEflag = false;
7055     int mostDmg = 0;
7056     int mostDmg2 = 0;
7057     int mostHit = 0;
7058     int mostNum = 0;
7059     int num = 0;
7060     ATTACK *aTop2 = U->C.A;
7061     int mpCost = 0;
7062     if(U->C.A)
7063         if(!U->C.A->D){
7064             U->C.A = NULL;
7065             aTop2 = U->C.A;
7066         }
7067
7068
7069
7070     while(U->C.A){
7071
7072         double urSupposedToGet;
7073
7074         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7075
7076         double asItIs;
7077
7078         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7079
7080
7081         double oopsIsRight = 0;
7082
7083         if(U->C.A){
7084             if(U->C.A->melee){
7085                 oopsIsRight = U->C.S_C.MEL;
7086             }else
7087                 oopsIsRight = U->C.S_C.MIS;
7088         }
7089         oopsIsRight = oopsIsRight/100;
7090
7091         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7092
7093         if(!U2->C.aura && U->C.A->D){
7094             if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7095                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7096             if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7097                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7098             if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7099                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7100             if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7101                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7102             if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7103                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7104             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7105         }else if(U->C.A->D){
7106             double val = val = 1/log(3+U2->C.S_C.MP/64);
7107             if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7108                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7109             if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7110                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7111             if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7112                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7113             if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7114                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7115             if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7116                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7117             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7118         }
7119         double val2 = log(3+U2->C.S_C.MP/64);
7120         if(U->C.aura){
7121             mostDmg2 = mostDmg2*val2;
7122         }
7123         if(U->C.A->D){
7124             if(U->C.A->D->fix == 2){
7125                 mostDmg2 = mostDmg2/2 + (U->C.S_C.HIT/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
7126
7127                 if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7128                 if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7129                 if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7130                 if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7131                 if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7132
7133
7134             }else if(U->C.A->D->fix == 1){
7135                 mostDmg2 = mostDmg2/2 + ((U->C.S_C.ATK/2+U->C.S_C.HIT/2)/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
7136
7137                 if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7138                 if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7139                 if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7140                 if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7141                 if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7142
7143             }else if(U->C.A->D->fix == 0){
7144
7145             }
7146         }
7147
7148
7149         U2A = U->C.A;
7150         costVIG = U->C.A->vigor;
7151         UNIT *oops = U;
7152         U = U2;
7153         mostDmg2 = [self dmgResist:mostDmg2];
7154
7155         //NSLog(@"crCAL1 %d", crCAL1);
7156         if(mostDmg2 < 0) mostDmg2 = 1;
7157         U = oops;
7158         if(U->C.A->D)
7159         if(mostDmg < mostDmg2 && U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
7160
7161             mostDmg = mostDmg2;
7162
7163             //mostDmg = U->C.A->totalD;
7164             mostNum = num;
7165         }
7166         if(U->C.A->D)
7167         if(mostHit < U->C.A->hitPercent && hit < 50 && mostDmg/2 < mostDmg2 && U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
7168             //mostDmg = U->C.A->totalD;
7169             mostHit = U->C.A->hitPercent;
7170             mostNum = num;
7171         }
7172         U->C.A = U->C.A->next;
7173         num++;
7174     }
7175     U->C.A = aTop2;
7176
7177         if(U->C.A->extent == 0 && mostNum >= 0 && !CPUmostDmgChoice){
7178
7179             U->C.A = aTop2;
7180             crCAL1 = 0;
7181             for(int i = 0;i < mostNum;i++){
7182                 U->C.A = U->C.A->next;
7183                 crCAL1++;
7184             }
7185         }
7186         else{
7187         U->C.A = aTop2;
7188             for(int i = 0;i < crCAL1;i++){
7189                 U->C.A = U->C.A->next;
7190             }
7191         }
7192
7193         CPUmostDmgChoice = false;
7194
7195    if(U->C.A){
7196         mostNumSub = mostNum;
7197
7198
7199         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7200        costVIG = U->C.A->vigor;
7201
7202         if(U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange
7203            && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
7204
7205         }else{
7206
7207         }
7208
7209     }U->C.A = aTop2;
7210     }
7211     U = UTop;
7212
7213     while (!(AUN[1] == U->number)) {
7214         U = U->next;
7215     }
7216     U2 = U;
7217
7218     ATTACK *aTop = U->C.A;
7219     ATTACK *u2A;
7220
7221     for(int i = 0;i < crCAL1;i++){
7222         U->C.A = U->C.A->next;
7223     }
7224
7225     //NSLog(@"%@", U->C.A->name);
7226
7227     if(battleSet1Flag){
7228         U->C.A = aTop;
7229         for (int i = 0;i < crCAL1;i++) {
7230             U->C.A = U->C.A->next;
7231         }
7232
7233     }
7234
7235     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7236     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7237     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7238     //NSLog(@"crCAL1 %d", crCAL1);
7239     if(U->C.A){
7240         [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7241
7242     }
7243     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7244     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7245     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
7246     [combatLHP1 setIntValue:(int)oops];
7247     oops = U->C.S_C.MP/U->C.S_M.MP*100;
7248     [combatLMP1 setIntValue:(int)oops];
7249
7250     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7251     //NSLog(@"mostNumSub %d crCAL1 %d", mostNumSub, crCAL1);
7252     hitFix = U->C.A->hitPercent;
7253
7254     u2A = U->C.A;
7255     U->C.A = aTop;
7256
7257     if(battleDef1Flag){
7258         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7259         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7260         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7261         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7262         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7263         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7264         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7265     }
7266     if(battleDod1Flag){
7267         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7268         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7269         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7270         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7271         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7272         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7273         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7274
7275     }
7276
7277
7278
7279
7280
7281
7282
7283     U = UTop;
7284     while (!(DUN[1] == U->number)) {
7285         U = U->next;
7286     }
7287
7288     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7289
7290     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7291     if(hi < 0) hi = 0;
7292
7293     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7294
7295     if(battleDod2Flag) hit = hit / 2;
7296     hit = floor(hit);
7297
7298     if(hit > 100) hit = 100;
7299     if(hit < 0) hit = 0;
7300
7301     if(u2A->D->sort == 1){
7302         hit = 100;
7303     }
7304
7305     if([self sortEcheck:u2A opponent:U])
7306         hit = 0;
7307     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7308     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7309
7310
7311
7312     int mostDmg = 0;
7313     int mostDmg2 = 0;
7314     int mostHit = 0;
7315     int mostNum = 0;
7316     int num = 0;
7317     ATTACK *aTop2 = U->C.A;
7318     int mpCost = 0;
7319
7320
7321     while(U->C.A){
7322
7323         double urSupposedToGet;
7324
7325         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7326
7327         double asItIs;
7328         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7329
7330         double oopsIsRight = 0;
7331
7332         if(U->C.A){
7333             if(U->C.A->melee){
7334                 oopsIsRight = U->C.S_C.MEL;
7335             }else
7336                 oopsIsRight = U->C.S_C.MIS;
7337         }
7338         oopsIsRight = oopsIsRight/100;
7339
7340         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7341
7342         if(!U2->C.aura && U->C.A->D){
7343             if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7344                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7345             if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7346                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7347             if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7348                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7349             if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7350                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7351             if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7352                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7353             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7354         }else if(U->C.A->D){
7355             double val = val = 1/log(3+U2->C.S_C.MP/64);
7356             if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7357                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7358             if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7359                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7360             if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7361                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7362             if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7363                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7364             if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
7365                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7366             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7367         }
7368         double val2 = log(3+U2->C.S_C.MP/64);
7369         if(U->C.aura){
7370             mostDmg2 = mostDmg2*val2;
7371         }
7372         if(U->C.A->D){
7373             if(U->C.A->D->fix == 2){
7374                 mostDmg2 = mostDmg2/2 + (U->C.S_C.HIT/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
7375
7376                 if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7377                 if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7378                 if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7379                 if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7380                 if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7381
7382
7383             }else if(U->C.A->D->fix == 1){
7384                 mostDmg2 = mostDmg2/2 + ((U->C.S_C.ATK/2+U->C.S_C.HIT/2)/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
7385
7386                 if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7387                 if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7388                 if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7389                 if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7390                 if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7391
7392             }else if(U->C.A->D->fix == 0){
7393
7394             }
7395         }
7396
7397         U2A = U->C.A;
7398
7399         UNIT *oops = U;
7400         //U = U2;
7401         mostDmg2 = [self dmgResist:mostDmg2];
7402         U = oops;
7403
7404         costVIG = U->C.A->vigor;
7405
7406         if(U->C.A->D)
7407         if(mostDmg < mostDmg2 && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
7408
7409             mostDmg = mostDmg2;
7410
7411             //mostDmg = U->C.A->totalD;
7412             mostNum = num;
7413         }
7414         if(U->C.A->D)
7415         if(mostHit < U->C.A->hitPercent && hit < 50 && mostDmg/2 < mostDmg2 && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 &&costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
7416             //mostDmg = U->C.A->totalD;
7417             mostHit = U->C.A->hitPercent;
7418             mostNum = num;
7419         }
7420         U->C.A = U->C.A->next;
7421         num++;
7422     }
7423
7424
7425
7426     U->C.A = aTop2;
7427     if(U->C.A){
7428     mostNumSub = mostNum;
7429
7430     for(int i = 0;i < mostNum;i++){
7431         U->C.A = U->C.A->next;
7432     }
7433     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7434
7435
7436         costVIG = U->C.A->vigor;
7437
7438
7439     if(U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
7440
7441     }else while(U->C.A){
7442         U->C.A = U->C.A->next;
7443     }
7444
7445     }
7446
7447
7448
7449     if(battleSet2Flag){
7450             U->C.A = aTop2;
7451         //NSLog(@"%@", U->C.name);
7452         for (int i = 0;i < crCAL2;i++) {
7453             U->C.A = U->C.A->next;
7454         }
7455     }
7456
7457
7458     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7459     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7460     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7461     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7462     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7463     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
7464     [combatLHP2 setIntValue:(int)oops2];
7465     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
7466     [combatLMP2 setIntValue:(int)oops2];
7467
7468     bool counter;
7469     int mpCost2 = 0;
7470     if(U->C.A){
7471         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7472         costVIG = U->C.A->vigor;
7473
7474     }
7475     if(U->C.A && U->C.A->D){
7476     if(U->C.A && !(u2A->D->sort == 1) && U->C.A->D->sort != 1 && mpCost2 <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U]){
7477         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7478         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7479         hitFix = U->C.A->hitPercent;
7480         counter = true;
7481     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U]){
7482         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7483     }
7484     }else{
7485         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7486     }
7487     U2A = U->C.A;
7488     U->C.A = aTop2;
7489
7490     if(battleDef2Flag){
7491         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7492         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7493         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7494         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7495         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7496         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7497         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7498     }
7499
7500     if(battleDod2Flag){
7501         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7502         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7503         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7504         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7505         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7506         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7507         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7508
7509     }
7510     U = UTop;
7511     while (!(DUN[1] == U->number)) {
7512         U = U->next;
7513     }
7514     U2 = U;
7515
7516     U = UTop;
7517     while (!(AUN[1] == U->number)) {
7518         U = U->next;
7519     }
7520
7521     if(counter){
7522
7523         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7524
7525
7526         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7527         if(hi < 0) hi = 0;
7528
7529         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7530         if(battleDod1Flag) hit /= 2;
7531         hit = floor(hit);
7532
7533         if(hit > 100) hit = 100;
7534         if(hit < 0) hit = 0;
7535
7536         if([self sortEcheck:U2A opponent:U])
7537             hit = 0;
7538
7539         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7540         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7541
7542     }else{
7543         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7544     }
7545
7546     U = UTop;
7547
7548     if(CPUAttackSubmitFlag){
7549         if(unitCPUAttackFlag){
7550             [battleCancelBtn setEnabled:NO];
7551             [battleCancelBtn setTransparent:YES];
7552         }else{
7553             [battleCancelBtn setEnabled:YES];
7554             [battleCancelBtn setTransparent:NO];
7555         }
7556         if(displayBattleCheckPanelFlag == 0) displayBattleCheckPanelFlag = 1;
7557     }else{
7558         [battleCancelBtn setEnabled:YES];
7559         [battleCancelBtn setTransparent:NO];
7560     }
7561
7562     U = UTop;
7563     while (!(AUN[1] == U->number)) {
7564         U = U->next;
7565     }
7566
7567     if(U->CPU){
7568         [battleAttackBtn1 setEnabled:NO];
7569         [battleAttackBtn1 setTransparent:YES];
7570         [battleGuardBtn1 setEnabled:NO];
7571         [battleGuardBtn1 setTransparent:YES];
7572         [battleDodgeBtn1 setEnabled:NO];
7573         [battleDodgeBtn1 setTransparent:YES];
7574     }else{
7575         [battleAttackBtn1 setEnabled:YES];
7576         [battleAttackBtn1 setTransparent:NO];
7577         [battleGuardBtn1 setEnabled:YES];
7578         [battleGuardBtn1 setTransparent:NO];
7579         [battleDodgeBtn1 setEnabled:YES];
7580         [battleDodgeBtn1 setTransparent:NO];
7581     }U = UTop;
7582
7583     U = UTop;
7584     while (!(DUN[1] == U->number)) {
7585         U = U->next;
7586     }
7587     if(U->CPU){
7588         [battleAttackBtn2 setEnabled:NO];
7589         [battleAttackBtn2 setTransparent:YES];
7590         [battleGuardBtn2 setEnabled:NO];
7591         [battleGuardBtn2 setTransparent:YES];
7592         [battleDodgeBtn2 setEnabled:NO];
7593         [battleDodgeBtn2 setTransparent:YES];
7594     }else{
7595         [battleAttackBtn2 setEnabled:YES];
7596         [battleAttackBtn2 setTransparent:NO];
7597         [battleGuardBtn2 setEnabled:YES];
7598         [battleGuardBtn2 setTransparent:NO];
7599         [battleDodgeBtn2 setEnabled:YES];
7600         [battleDodgeBtn2 setTransparent:NO];
7601     }U = UTop;
7602
7603
7604
7605     U = UTop;
7606
7607     for (int i = 1; i < DUN[1]; i++) {
7608         U = U->next;
7609
7610     }
7611
7612
7613     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
7614        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
7615        ){
7616
7617  //おまんこかわいい
7618
7619
7620     }else{
7621         [battleStartBtn setEnabled:YES];
7622         [battleStartBtn setTransparent:NO];
7623     }
7624
7625     U = UTop;
7626
7627     avPlayerFlag1 = false;
7628     avPlayerFlag2 = false;
7629 }
7630
7631 -(void)setBattlePanelT2{
7632
7633     U = UTop;
7634     int mpCost = 0;
7635     ATTACK *aTop2 = U->CL.A;
7636     while (!(AUN[1] == U->number)) {
7637         U = U->next;
7638     }
7639
7640     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7641         cpuModeBATTLEflag = false;
7642     int mostDmg = 0;
7643     int mostHit = 0;
7644     int mostNum = -1;
7645     int num = 0;
7646     int mpCost = 0;
7647     while(U->CL.A){
7648         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7649         costVIG = U->C.A->vigor;
7650         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
7651             mostDmg = U->CL.A->totalD;
7652             mostNum = num;
7653         }
7654         if(mostHit < U->CL.A->hitPercent && mostDmg/2 < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
7655             //mostDmg = U->C.A->totalD;
7656             mostHit = U->CL.A->hitPercent;
7657             mostNum = num;
7658         }
7659         U->CL.A = U->CL.A->next;
7660         num++;
7661     }
7662         U->CL.A = aTop2;
7663
7664         for(int i = 0;i < crCAL1;i++){
7665             U->CL.A = U->CL.A->next;
7666
7667         }
7668         ATTACK *ua = U->CL.A;
7669
7670         U->CL.A = aTop2;
7671
7672     mostNumSub = mostNum;
7673
7674         U->CL.A = aTop2;
7675
7676         for(int i = 0;i < mostNum;i++){
7677             U->C.A = U->CL.A->next;
7678         }
7679         if(U->CL.A->extent == 0){
7680
7681             U->CL.A = aTop2;
7682             crCAL1 = 0;
7683             for(int i = 0;i < mostNum;i++){
7684                 U->CL.A = U->CL.A->next;
7685                 crCAL1++;
7686             }
7687         }
7688         else{
7689             U->CL.A = aTop2;
7690             for(int i = 0;i < crCAL1;i++){
7691                 U->CL.A = U->CL.A->next;
7692             }
7693         }
7694     }else{
7695
7696         U->CL.A = NULL;
7697     }
7698     if(U->CL.A){
7699         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7700         costVIG = U->C.A->vigor;
7701     }
7702     if(U->CL.A){
7703         if(U->CL.A->rangeA <= unitBreak->atkRange && U->CL.A->rangeB >= unitBreak->atkRange && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
7704
7705         }else while(U->CL.A){
7706             U->CL.A = U->CL.A->next;
7707             crCAL1++;
7708         }
7709     }U->CL.A = aTop2;
7710
7711
7712     U = UTop;
7713     while (!(AUN[1] == U->number)) {
7714         U = U->next;
7715     }
7716     U2 = U;
7717
7718     ATTACK *aTop = U->CL.A;
7719     ATTACK *u2A;
7720
7721     if(U->C.A)
7722         crCAL1 = crCAL;
7723
7724     for(int i = 0;i < crCAL1;i++){
7725         U->CL.A = U->CL.A->next;
7726     }
7727
7728
7729     if(battleSet1Flag){
7730
7731         U->CL.A = aTop;
7732         for (int i = 0;i < crCAL1;i++) {
7733             U->CL.A = U->CL.A->next;
7734         }
7735
7736     }
7737
7738     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7739     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7740     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7741     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7742     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7743     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7744     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
7745     [combatLHP1 setIntValue:(int)oops];
7746     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
7747     [combatLMP1 setIntValue:(int)oops];
7748
7749     hit = U->CL.S_C.MOB + U->C.S_C.HIT*U->C.S_C.HP/U->C.S_M.HP;
7750     hitFix = U->CL.A->hitPercent;
7751
7752     u2A = U->CL.A;
7753     U->CL.A = aTop;
7754
7755     if(battleDef1Flag){
7756         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7757         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7758         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7759         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7760         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7761         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7762         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7763     }
7764     if(battleDod1Flag){
7765         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7766         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7767         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7768         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7769         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7770         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7771         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7772
7773     }
7774
7775
7776
7777
7778
7779
7780
7781     U = UTop;
7782     while (!(DUN[1] == U->number)) {
7783         U = U->next;
7784     }
7785
7786     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
7787     if(battleDod2Flag) hit = hit / 2;
7788     hit = floor(hit);
7789
7790     if(hit > 100) hit = 100;
7791     if(hit < 0) hit = 0;
7792
7793     if(u2A->D->sort == 1){
7794         hit = 100;
7795     }
7796
7797     if([self sortEcheck:u2A opponent:U])
7798         hit = 0;
7799     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7800     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7801
7802
7803
7804     int mostDmg = 0;
7805     int mostHit = 0;
7806     int mostNum = -1;
7807     int num = 0;
7808     costVIG = U->C.A->vigor;
7809     while(U->CL.A){
7810         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7811         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
7812             mostDmg = U->CL.A->totalD;
7813             mostNum = num;
7814         }
7815         if(mostHit < U->CL.A->hitPercent && mostDmg/2 < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
7816             //mostDmg = U->C.A->totalD;
7817             mostHit = U->CL.A->hitPercent;
7818             mostNum = num;
7819         }
7820         U->CL.A = U->CL.A->next;
7821         num++;
7822     }
7823
7824     U->CL.A = aTop2;
7825
7826     mostNumSub = mostNum;
7827
7828     if(mostNum >= 0){
7829     for(int i = 0;i < mostNum;i++){
7830         U->CL.A = U->CL.A->next;
7831     }
7832     }else{
7833
7834         U->CL.A = NULL;
7835     }
7836     if(U->CL.A){
7837         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7838         costVIG = U->C.A->vigor;
7839     }
7840     if(U->CL.A){
7841     if(U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
7842
7843     }else while(U->CL.A){
7844         U->CL.A = U->CL.A->next;
7845     }
7846     }
7847
7848
7849
7850     if(battleSet2Flag){
7851
7852         U->CL.A = aTop2;
7853
7854         for (int i = 0;i < crCAL2;i++) {
7855             U->CL.A = U->CL.A->next;
7856         }
7857
7858     }
7859
7860
7861     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7862     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7863     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7864     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7865     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7866     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
7867     [combatLHP2 setIntValue:(int)oops2];
7868     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
7869     [combatLMP2 setIntValue:(int)oops2];
7870
7871     bool counter;
7872     int mpCost2 = 0;
7873     if(U->CL.A && U->CL.A->D){
7874     if(U->CL.A->name){
7875
7876     if(U->CL.A){
7877         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7878
7879     }
7880     if(U->CL.A && !(u2A->D->sort == 1) && U->CL.A->D->sort != 1 && mpCost2 <= U->CL.S_C.EN && ![self sortEcheck:U->CL.A opponent:U2]){
7881         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7882         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
7883         hitFix = U->CL.A->hitPercent;
7884         counter = true;
7885     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
7886         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7887     }
7888
7889     }else{
7890         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7891     }
7892     }else{
7893         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7894     }
7895     U2A = U->CL.A;
7896     U->CL.A = aTop2;
7897
7898     if(battleDef2Flag){
7899         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7900         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7901         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7902         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7903         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7904         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7905         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7906     }
7907
7908     if(battleDod2Flag){
7909         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7910         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7911         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7912         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7913         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7914         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7915         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7916
7917     }
7918     U = UTop;
7919     while (!(AUN[1] == U->number)) {
7920         U = U->next;
7921     }
7922
7923     if(counter){
7924         hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
7925         if(battleDod1Flag) hit /= 2;
7926         hit = floor(hit);
7927
7928         if(hit > 100) hit = 100;
7929         if(hit < 0) hit = 0;
7930         if([self sortEcheck:U2A opponent:U])
7931             hit = 0;
7932         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7933         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7934
7935     }else{
7936         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7937     }
7938
7939     U = UTop;
7940     while (!(AUN[1] == U->number)) {
7941         U = U->next;
7942     }
7943
7944     if(U->CPU){
7945         [battleAttackBtn1 setEnabled:NO];
7946         [battleAttackBtn1 setTransparent:YES];
7947         [battleGuardBtn1 setEnabled:NO];
7948         [battleGuardBtn1 setTransparent:YES];
7949         [battleDodgeBtn1 setEnabled:NO];
7950         [battleDodgeBtn1 setTransparent:YES];
7951     }else{
7952         [battleAttackBtn1 setEnabled:YES];
7953         [battleAttackBtn1 setTransparent:NO];
7954         [battleGuardBtn1 setEnabled:YES];
7955         [battleGuardBtn1 setTransparent:NO];
7956         [battleDodgeBtn1 setEnabled:YES];
7957         [battleDodgeBtn1 setTransparent:NO];
7958     }U = UTop;
7959
7960     U = UTop;
7961     while (!(DUN[1] == U->number)) {
7962         U = U->next;
7963     }
7964     if(U->CPU){
7965         [battleAttackBtn2 setEnabled:NO];
7966         [battleAttackBtn2 setTransparent:YES];
7967         [battleGuardBtn2 setEnabled:NO];
7968         [battleGuardBtn2 setTransparent:YES];
7969         [battleDodgeBtn2 setEnabled:NO];
7970         [battleDodgeBtn2 setTransparent:YES];
7971     }else{
7972         [battleAttackBtn2 setEnabled:YES];
7973         [battleAttackBtn2 setTransparent:NO];
7974         [battleGuardBtn2 setEnabled:YES];
7975         [battleGuardBtn2 setTransparent:NO];
7976         [battleDodgeBtn2 setEnabled:YES];
7977         [battleDodgeBtn2 setTransparent:NO];
7978     }U = UTop;
7979
7980     U = UTop;
7981
7982     for (int i = 1; i < DUN[1]; i++) {
7983         U = U->next;
7984     }
7985
7986
7987     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
7988        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
7989        ){
7990         /*
7991         [battleStartBtn setEnabled:NO];
7992         [battleStartBtn setTransparent:YES];
7993          */
7994     }else{
7995         [battleStartBtn setEnabled:YES];
7996         [battleStartBtn setTransparent:NO];
7997     }
7998
7999     U = UTop;
8000
8001     avPlayerFlag1 = false;
8002     avPlayerFlag2 = false;
8003 }
8004
8005 -(void)setBattlePanelT3{
8006
8007
8008     U = UTop;
8009     while (!(AUN[1] == U->number)) {
8010         U = U->next;
8011     }
8012
8013     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 &&MF[MFselectedRow+1].MS.playerSet2 == 2)){
8014         cpuModeBATTLEflag = false;
8015     int mostDmg = 0;
8016     int mostHit = 0;
8017     int mostNum = 0;
8018     int num = 0;
8019     ATTACK *aTop2 = U->C.A;
8020     int mpCost = 0;
8021     while(U->C.A){
8022         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8023
8024         costVIG = U->C.A->vigor;
8025         if(U->C.A->D)
8026         if(mostDmg < U->C.A->totalD && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
8027             mostDmg = U->C.A->totalD;
8028             mostNum = num;
8029         }
8030         if(U->C.A->D)
8031         if(mostHit < U->C.A->hitPercent && mostDmg/2 < U->C.A->totalD && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
8032             //mostDmg = U->C.A->totalD;
8033             mostHit = U->C.A->hitPercent;
8034             mostNum = num;
8035         }
8036         U->C.A = U->C.A->next;
8037         num++;
8038     }
8039         U->C.A = aTop2;
8040
8041         for(int i = 0;i < crCAL1;i++){
8042             U->C.A = U->C.A->next;
8043
8044         }
8045         ATTACK *ua = U->C.A;
8046
8047         U->C.A = aTop2;
8048
8049     mostNumSub = mostNum;
8050         U->C.A = aTop2;
8051
8052         for(int i = 0;i < mostNum;i++){
8053             U->C.A = U->C.A->next;
8054         }
8055         if(U->C.A->extent == 0 && mostNum > 0){
8056
8057             U->C.A = aTop2;
8058             crCAL1 = 0;
8059             for(int i = 0;i < mostNum;i++){
8060                 U->C.A = U->C.A->next;
8061                 crCAL1++;
8062             }
8063         }
8064         else{
8065             U->C.A = aTop2;
8066             for(int i = 0;i < crCAL1;i++){
8067                 U->C.A = U->C.A->next;
8068             }
8069         }
8070     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8071         costVIG = U->C.A->vigor;
8072
8073
8074     if(U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
8075
8076     }else{
8077
8078     }
8079       U->C.A = aTop2;
8080     }
8081
8082     U = UTop;
8083     while (!(AUN[1] == U->number)) {
8084         U = U->next;
8085     }
8086     U2 = U;
8087
8088
8089     ATTACK *aTop = U->CL.A;
8090     ATTACK *u2A;
8091
8092     if(U->C.A)
8093         crCAL1 = crCAL;
8094
8095     for(int i = 0;i < crCAL1;i++){
8096         U->CL.A = U->CL.A->next;
8097     }
8098
8099     if(battleSet1Flag){
8100
8101         U->CL.A = aTop;
8102         for (int i = 0;i < crCAL1;i++) {
8103             U->CL.A = U->CL.A->next;
8104         }
8105
8106     }
8107
8108     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8109     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8110     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8111     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8112     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8113     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8114     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
8115     [combatLHP1 setIntValue:(int)oops];
8116     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
8117     [combatLMP1 setIntValue:(int)oops];
8118
8119     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8120     hitFix = U->CL.A->hitPercent;
8121
8122     u2A = U->CL.A;
8123     U->CL.A = aTop;
8124
8125     if(battleDef1Flag){
8126         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8127         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8128         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8129         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8130         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8131         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8132         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8133     }
8134     if(battleDod1Flag){
8135         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8136         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8137         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8138         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8139         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8140         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8141         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8142
8143     }
8144
8145
8146
8147
8148
8149     U = UTop;
8150     while (!(AUN[1] == U->number)) {
8151         U = U->next;
8152     }
8153     U2 = U;
8154
8155     U = UTop;
8156     while (!(DUN[1] == U->number)) {
8157         U = U->next;
8158     }
8159
8160     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8161
8162     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8163     if(hi < 0) hi = 0;
8164
8165     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8166     if(battleDod2Flag) hit = hit / 2;
8167     hit = floor(hit);
8168
8169     if(hit > 100) hit = 100;
8170     if(hit < 0) hit = 0;
8171
8172     if(u2A->D->sort == 1){
8173         hit = 100;
8174     }
8175     if([self sortEcheck:u2A opponent:U])
8176         hit = 0;
8177     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8178     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8179
8180
8181
8182     int mostDmg = 0;
8183     int mostHit = 0;
8184     int mostNum = 0;
8185     int num = 0;
8186     ATTACK *aTop2 = U->C.A;
8187     int mpCost = 0;
8188     while(U->C.A){
8189
8190         costVIG = U->C.A->vigor;
8191
8192         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8193         if(U->C.A->D)
8194         if(mostDmg < U->C.A->totalD && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
8195             mostDmg = U->C.A->totalD;
8196             mostNum = num;
8197         }
8198         if(U->C.A->D)
8199         if(mostHit < U->C.A->hitPercent && mostDmg/2 < U->C.A->totalD && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && U->C.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
8200             //mostDmg = U->C.A->totalD;
8201             mostHit = U->C.A->hitPercent;
8202             mostNum = num;
8203         }
8204         U->C.A = U->C.A->next;
8205         num++;
8206     }
8207
8208     U->C.A = aTop2;
8209
8210     mostNumSub = mostNum;
8211
8212     for(int i = 0;i < mostNum;i++){
8213         U->C.A = U->C.A->next;
8214     }
8215     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8216     costVIG = U->C.A->vigor;
8217
8218     if(U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
8219
8220     }else while(U->C.A){
8221         U->C.A = U->C.A->next;
8222     }
8223
8224
8225     if(battleSet2Flag){
8226
8227         U->C.A = aTop2;
8228
8229         for (int i = 0;i < crCAL2;i++) {
8230             U->C.A = U->C.A->next;
8231         }
8232
8233     }
8234
8235
8236     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8237     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8238     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8239     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8240     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8241     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
8242     [combatLHP2 setIntValue:(int)oops2];
8243     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
8244     [combatLMP2 setIntValue:(int)oops2];
8245
8246     bool counter;
8247     int mpCost2 = 0;
8248     if(U->C.A){
8249         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8250         costVIG = U->C.A->vigor;
8251
8252     }
8253     if(U->C.A &&U->C.A->D){
8254     if(U->C.A && !(u2A->D->sort == 1) && U->C.A->D->sort != 1 && mpCost2 <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
8255         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8256         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8257         hitFix = U->C.A->hitPercent;
8258         counter = true;
8259     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U2]){
8260         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8261     }}else{
8262         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8263     }
8264     U2A = U->C.A;
8265     U->C.A = aTop2;
8266
8267     if(battleDef2Flag){
8268         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8269         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8270         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8271         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8272         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8273         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8274         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8275     }
8276
8277     if(battleDod2Flag){
8278         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8279         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8280         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8281         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8282         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8283         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8284         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8285
8286     }
8287     U = UTop;
8288     while (!(AUN[1] == U->number)) {
8289         U = U->next;
8290     }
8291
8292     if(counter){
8293         hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
8294         if(battleDod1Flag) hit /= 2;
8295         hit = floor(hit);
8296
8297         if(hit > 100) hit = 100;
8298         if(hit < 0) hit = 0;
8299         if([self sortEcheck:U2A opponent:U])
8300             hit = 0;
8301         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8302         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8303
8304     }else{
8305         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8306     }
8307
8308     U = UTop;
8309     while (!(AUN[1] == U->number)) {
8310         U = U->next;
8311     }
8312
8313     if(U->CPU){
8314         [battleAttackBtn1 setEnabled:NO];
8315         [battleAttackBtn1 setTransparent:YES];
8316         [battleGuardBtn1 setEnabled:NO];
8317         [battleGuardBtn1 setTransparent:YES];
8318         [battleDodgeBtn1 setEnabled:NO];
8319         [battleDodgeBtn1 setTransparent:YES];
8320     }else{
8321         [battleAttackBtn1 setEnabled:YES];
8322         [battleAttackBtn1 setTransparent:NO];
8323         [battleGuardBtn1 setEnabled:YES];
8324         [battleGuardBtn1 setTransparent:NO];
8325         [battleDodgeBtn1 setEnabled:YES];
8326         [battleDodgeBtn1 setTransparent:NO];
8327     }U = UTop;
8328
8329     U = UTop;
8330     while (!(DUN[1] == U->number)) {
8331         U = U->next;
8332     }
8333     if(U->CPU){
8334         [battleAttackBtn2 setEnabled:NO];
8335         [battleAttackBtn2 setTransparent:YES];
8336         [battleGuardBtn2 setEnabled:NO];
8337         [battleGuardBtn2 setTransparent:YES];
8338         [battleDodgeBtn2 setEnabled:NO];
8339         [battleDodgeBtn2 setTransparent:YES];
8340     }else{
8341         [battleAttackBtn2 setEnabled:YES];
8342         [battleAttackBtn2 setTransparent:NO];
8343         [battleGuardBtn2 setEnabled:YES];
8344         [battleGuardBtn2 setTransparent:NO];
8345         [battleDodgeBtn2 setEnabled:YES];
8346         [battleDodgeBtn2 setTransparent:NO];
8347     }U = UTop;
8348
8349
8350     U = UTop;
8351
8352     for (int i = 1; i < DUN[1]; i++) {
8353         U = U->next;
8354     }
8355
8356     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8357        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8358        ){
8359         /*
8360         [battleStartBtn setEnabled:NO];
8361         [battleStartBtn setTransparent:YES];
8362          */
8363     }else{
8364         [battleStartBtn setEnabled:YES];
8365         [battleStartBtn setTransparent:NO];
8366     }
8367
8368     U = UTop;
8369
8370     avPlayerFlag1 = false;
8371     avPlayerFlag2 = false;
8372 }
8373
8374 -(void)setBattlePanelT4{
8375
8376     U = UTop;
8377
8378     while (!(AUN[1] == U->number)) {
8379         U = U->next;
8380     }
8381
8382     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2)){
8383         cpuModeBATTLEflag = false;
8384     int mostDmg = 0;
8385     int mostHit = 0;
8386     int mostNum = 0;
8387     int num = 0;
8388     ATTACK *aTop2 = U->CL.A;
8389     int mpCost = 0;
8390     while(U->CL.A){
8391         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8392         costVIG = U->C.A->vigor;
8393         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self :U->CL.A opponent:U2]){
8394             mostDmg = U->CL.A->totalD;
8395             mostNum = num;
8396         }
8397         if(mostHit < U->CL.A->hitPercent && mostDmg/2 < U->CL.A->totalD && U->CL.A->rangeA <= unitBreak->atkRange && U->CL.A->rangeB >= unitBreak->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
8398             //mostDmg = U->C.A->totalD;
8399             mostHit = U->CL.A->hitPercent;
8400             mostNum = num;
8401         }
8402         U->CL.A = U->CL.A->next;
8403         num++;
8404     }
8405
8406     mostNumSub = mostNum;
8407         U->CL.A = aTop2;
8408
8409         for(int i = 0;i < mostNum;i++){
8410             U->CL.A = U->CL.A->next;
8411         }
8412         if(U->CL.A->extent == 0){
8413
8414             U->CL.A = aTop2;
8415             crCAL1 = 0;
8416             for(int i = 0;i < mostNum;i++){
8417                 U->CL.A = U->CL.A->next;
8418                 crCAL1++;
8419             }
8420         }
8421         else{
8422             U->CL.A = aTop2;
8423             for(int i = 0;i < crCAL1;i++){
8424                 U->CL.A = U->CL.A->next;
8425             }
8426         }
8427     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8428         costVIG = U->C.A->vigor;
8429     if(U->CL.A->rangeA <= unitBreak->atkRange && U->CL.A->rangeB >= unitBreak->atkRange && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
8430
8431     }else while(U->CL.A){
8432         U->CL.A = U->CL.A->next;
8433         crCAL1++;
8434     }
8435       U->CL.A = aTop2;
8436     }
8437     U = UTop;
8438
8439     while (!(AUN[1] == U->number)) {
8440         U = U->next;
8441     }
8442     U2 = U;
8443
8444     ATTACK *aTop = U->C.A;
8445     ATTACK *u2A;
8446
8447     if(U->C.A)
8448         crCAL1 = crCAL;
8449
8450     for(int i = 0;i < crCAL1;i++){
8451         U->C.A = U->C.A->next;
8452     }
8453
8454     if(battleSet1Flag){
8455
8456         U->C.A = aTop;
8457         for (int i = 0;i < crCAL1;i++) {
8458             U->C.A = U->C.A->next;
8459         }
8460
8461     }
8462
8463     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8464     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8465     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8466     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8467     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8468     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8469     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
8470     [combatLHP1 setIntValue:(int)oops];
8471     oops = U->C.S_C.MP/U->C.S_M.MP*100;
8472     [combatLMP1 setIntValue:(int)oops];
8473
8474     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8475     hitFix = U->C.A->hitPercent;
8476
8477     u2A = U->C.A;
8478     U->C.A = aTop;
8479
8480     if(battleDef1Flag){
8481         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8482         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8483         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8484         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8485         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8486         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8487         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8488     }
8489     if(battleDod1Flag){
8490         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8491         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8492         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8493         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8494         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8495         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8496         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8497
8498     }
8499
8500
8501
8502
8503
8504
8505
8506     U = UTop;
8507     while (!(DUN[1] == U->number)) {
8508         U = U->next;
8509     }
8510
8511     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
8512     if(battleDod2Flag) hit = hit / 2;
8513     hit = floor(hit);
8514
8515     if(hit > 100) hit = 100;
8516     if(hit < 0) hit = 0;
8517
8518     if(u2A->D->sort == 1){
8519         hit = 100;
8520     }
8521     if([self sortEcheck:u2A opponent:U])
8522         hit = 0;
8523     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8524     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8525
8526
8527
8528     int mostDmg = 0;
8529     int mostHit = 0;
8530     int mostNum = 0;
8531     int num = 0;
8532     ATTACK *aTop2 = U->CL.A;
8533     int mpCost = 0;
8534     while(U->CL.A){
8535         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8536         costVIG = U->C.A->vigor;
8537         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
8538             mostDmg = U->CL.A->totalD;
8539             mostNum = num;
8540         }
8541         if(mostHit < U->CL.A->hitPercent && mostDmg/2 < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && U->CL.A->D->sort != 1 && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
8542             //mostDmg = U->C.A->totalD;
8543             mostHit = U->CL.A->hitPercent;
8544             mostNum = num;
8545         }
8546         U->CL.A = U->CL.A->next;
8547         num++;
8548     }
8549
8550     mostNumSub = mostNum;
8551
8552     U->CL.A = aTop2;
8553
8554     for(int i = 0;i < mostNum;i++){
8555         U->CL.A = U->CL.A->next;
8556     }
8557     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8558     costVIG = U->C.A->vigor;
8559     if(U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
8560
8561     }else while(U->CL.A){
8562         U->CL.A = U->CL.A->next;
8563     }
8564
8565
8566     if(battleSet2Flag){
8567
8568         U->CL.A = aTop2;
8569
8570         for (int i = 0;i < crCAL2;i++) {
8571             U->CL.A = U->CL.A->next;
8572         }
8573
8574     }
8575
8576
8577     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8578     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8579     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8580     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8581     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8582     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
8583     [combatLHP2 setIntValue:(int)oops2];
8584     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
8585     [combatLMP2 setIntValue:(int)oops2];
8586
8587     bool counter;
8588     int mpCost2 = 0;
8589     if(U->CL.A){
8590         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8591
8592     }
8593     if(U->CL.A && U->CL.A->D){
8594     if(U->CL.A && !(u2A->D->sort == 1) && U->CL.A->D->sort != 1 && mpCost2 <= U->CL.S_C.EN && ![self sortEcheck:U->CL.A opponent:U2]){
8595         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8596         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8597         hitFix = U->CL.A->hitPercent;
8598         counter = true;
8599     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
8600         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8601     }}else{
8602         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8603     }
8604     U2A = U->CL.A;
8605     U->CL.A = aTop2;
8606
8607     if(battleDef2Flag){
8608         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8609         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8610         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8611         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8612         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8613         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8614         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8615     }
8616
8617     if(battleDod2Flag){
8618         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8619         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8620         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8621         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8622         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8623         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8624         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8625
8626     }
8627
8628     U = UTop;
8629     while (!(DUN[1] == U->number)) {
8630         U = U->next;
8631     }
8632     U2 = U;
8633
8634     U = UTop;
8635     while (!(AUN[1] == U->number)) {
8636         U = U->next;
8637     }
8638
8639     if(counter){
8640
8641         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8642
8643         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8644         if(hi < 0) hi = 0;
8645
8646         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8647         if(battleDod1Flag) hit /= 2;
8648         hit = floor(hit);
8649
8650         if(hit > 100) hit = 100;
8651         if(hit < 0) hit = 0;
8652         if([self sortEcheck:U2A opponent:U])
8653             hit = 0;
8654         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8655         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8656
8657     }else{
8658         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8659     }
8660
8661     U = UTop;
8662     while (!(AUN[1] == U->number)) {
8663         U = U->next;
8664     }
8665
8666     if(U->CPU){
8667         [battleAttackBtn1 setEnabled:NO];
8668         [battleAttackBtn1 setTransparent:YES];
8669         [battleGuardBtn1 setEnabled:NO];
8670         [battleGuardBtn1 setTransparent:YES];
8671         [battleDodgeBtn1 setEnabled:NO];
8672         [battleDodgeBtn1 setTransparent:YES];
8673     }else{
8674         [battleAttackBtn1 setEnabled:YES];
8675         [battleAttackBtn1 setTransparent:NO];
8676         [battleGuardBtn1 setEnabled:YES];
8677         [battleGuardBtn1 setTransparent:NO];
8678         [battleDodgeBtn1 setEnabled:YES];
8679         [battleDodgeBtn1 setTransparent:NO];
8680     }U = UTop;
8681
8682     U = UTop;
8683     while (!(DUN[1] == U->number)) {
8684         U = U->next;
8685     }
8686     if(U->CPU){
8687         [battleAttackBtn2 setEnabled:NO];
8688         [battleAttackBtn2 setTransparent:YES];
8689         [battleGuardBtn2 setEnabled:NO];
8690         [battleGuardBtn2 setTransparent:YES];
8691         [battleDodgeBtn2 setEnabled:NO];
8692         [battleDodgeBtn2 setTransparent:YES];
8693     }else{
8694         [battleAttackBtn2 setEnabled:YES];
8695         [battleAttackBtn2 setTransparent:NO];
8696         [battleGuardBtn2 setEnabled:YES];
8697         [battleGuardBtn2 setTransparent:NO];
8698         [battleDodgeBtn2 setEnabled:YES];
8699         [battleDodgeBtn2 setTransparent:NO];
8700     }U = UTop;
8701
8702
8703     U = UTop;
8704
8705     for (int i = 1; i < DUN[1]; i++) {
8706         U = U->next;
8707     }
8708
8709     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8710        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8711        ){
8712         /*
8713         [battleStartBtn setEnabled:NO];
8714         [battleStartBtn setTransparent:YES];
8715          */
8716     }else{
8717         [battleStartBtn setEnabled:YES];
8718         [battleStartBtn setTransparent:NO];
8719     }
8720
8721     U = UTop;
8722
8723     avPlayerFlag1 = false;
8724     avPlayerFlag2 = false;
8725 }
8726
8727 -(void)DisplayMessage{
8728
8729     battleFlag = true;
8730     attackExtentFlag = false;
8731     attackingWait = false;
8732
8733     if(!battleSetUp) return;
8734     if(!fuckingLoadBugFix) return;
8735
8736     if(!battleVeryBegunFlag){
8737     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8738     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8739     [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8740     [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8741     }
8742     battleVeryBegunFlag = true;
8743     pussyLoopFlag = true;
8744     if(AVpreview){
8745     if(AVpreview.rate > 0){
8746         //[battleWindow setIgnoresMouseEvents:YES];
8747         [battleWindow makeKeyAndOrderFront:nil];
8748         //NSLog(@"%g", AVpreview.rate);
8749         return;
8750     }else{
8751         //[battleWindow setIgnoresMouseEvents:NO];
8752         //NSLog(@"%g", AVpreview.rate);
8753         AVpreview = NULL;
8754         if(avPlayerFlag1){
8755
8756             [AVPV setHidden:YES];
8757         }
8758         else if(avPlayerFlag2){
8759             [AVPV setHidden:YES];
8760         }
8761     }
8762     }
8763     if(animationFlag3){
8764         if(animationFlag1){
8765             animationFlag1 = false;
8766             U = effCun;
8767             U->C.A = attackTop;
8768         }
8769         if(animationFlag2){
8770             animationFlag2 = false;
8771             U = effCun;
8772             U->C.A = attackTop2;
8773         }
8774         U = UTop;
8775     }else{
8776         if(animationFlag1 || animationFlag2){
8777             return;
8778         }
8779     }
8780
8781     double def2 = (double)31/32;
8782     NSString *message = @"";
8783
8784     enum{
8785         RIKU,
8786         UMI,
8787         CHU,
8788         SORA
8789     };
8790
8791     enum{
8792         A,
8793         B,
8794         C,
8795         D,
8796         E,
8797         S,
8798         SS
8799     };
8800     static bool extentbool = false;
8801     static bool extentbool2 = false;
8802
8803
8804     if(cpuAtkExtendFlag){
8805         extentBattleFlag2 = true;
8806     }
8807
8808     if(!extentbool && extentBattleFlag2){
8809         extentbool = true;
8810         extentMPcostFlag = false;
8811         DUNnum = 1;
8812     }
8813
8814     assholeLoadBugFix = true;
8815
8816     switch (messageProcess) {
8817         case 0:
8818             if(bLoopFlag) break;
8819
8820             DUNnum = 1;
8821
8822             U = UTop;
8823             while (!(DUN[DUNnum] == U->number)) {
8824                 U = U->next;
8825
8826             }
8827             U2 = U;
8828             U = UTop;
8829             while (!(AUN[1] == U->number)) {
8830                 U = U->next;
8831             }
8832
8833             if(U->number == U2->number){
8834                 btSelfAction = true;
8835             }else{
8836                 btSelfAction = false;
8837             }
8838
8839             U = UTop;
8840             U2 = UTop;
8841
8842             [battleDialog setStringValue:@"攻撃開始！"];
8843             if(!baseDistanceCompFlag)
8844                 break;
8845             bLoopFlag = true;
8846             messageProcess++;
8847             DUNnum = 1;
8848
8849             break;
8850         case 1:
8851
8852             if(bLoopFlag) break;
8853
8854
8855             if(DUNnum > 1){
8856
8857
8858                 btHitExtendFlag1 = true;
8859
8860                 if(btHitExtendProc1 >= 3){
8861                     btHitExtendProc1 = 0;
8862                 }
8863             }
8864
8865                 BTunitAttackFlag1 = true;
8866             if(battleDef1Flag || battleDod1Flag)
8867                 BTunitAttackFlag1 = false;
8868
8869             U = UTop;
8870             while (!(DUN[DUNnum] == U->number)) {
8871                 U = U->next;
8872
8873             }
8874             U2 = U;
8875             U = UTop;
8876             while (!(AUN[1] == U->number)) {
8877                 U = U->next;
8878             }
8879
8880
8881             if(U->number == U2->number){
8882                 btSelfAction = true;
8883             }else{
8884                 btSelfAction = false;
8885             }
8886
8887             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
8888                 U = UTop;
8889                 [self DisplayMessageMod1A];
8890                 return;
8891             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
8892                 U = UTop;
8893                 [self DisplayMessageMod2A];
8894                 return;
8895             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
8896                 U = UTop;
8897                 [self DisplayMessageMod3A];
8898                 return;
8899             }
8900
8901
8902             U = UTop;
8903             if(bLoopFlag) break;
8904
8905             U = UTop;
8906             while (!(AUN[1] == U->number)) {
8907                 U = U->next;
8908             }
8909             ATTACK *aTop = U->C.A;
8910             attackTop = aTop;
8911             for(int i = 0;i < crCAL1;i++){
8912                 U->C.A = U->C.A->next;
8913             }
8914             effCun = U;
8915             attackCR = U->C.A;
8916
8917             if(attackCR->magic){
8918                 btAttackType1 = BT_TYPE_MAGIC;
8919             }else{
8920                 btAttackType1 = BT_TYPE_NORMAL;
8921             }
8922
8923             if(BTunitAttackFlag1)
8924             if((btAttackType1 == BT_TYPE_NORMAL && btAttackMoveValue1 < 2)
8925                || (btAttackType1 == BT_TYPE_MAGIC && btAttackMoveValue1 < 5)
8926                || (btAttackType1 == BT_TYPE_ABILITY && btAttackMoveValue1 < 2)){
8927
8928                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
8929
8930                 [battleDialog setStringValue:message];
8931                 U->C.A = aTop;
8932                 U = UTop;
8933
8934                 return;
8935             }
8936
8937             if(btHitExtendFlag1 && btHitExtendProc1 < 2){
8938
8939
8940
8941
8942                 U->C.A = aTop;
8943                 U = UTop;
8944
8945                 return;
8946             }
8947
8948             if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
8949
8950
8951             [bplayer2 setImage:U2->C.imgb];
8952             [bplayer2 setImageScaling:NSScaleToFit];
8953             [nplayer2 setStringValue:U2->C.name];
8954             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->C.S_C.HP, U2->C.S_M.HP]];
8955             [lplayer2 setIntValue:U2->C.S_C.HP/U2->C.S_M.HP*100];
8956             [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
8957             [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
8958             [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
8959
8960             if(!battleDef1Flag && !battleDod1Flag && !battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL && DUNnum == 1){
8961                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
8962
8963                 NSString *path = @"data/AttackList/ALdata";
8964
8965                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
8966
8967                 path = [path stringByAppendingFormat:@"/"];
8968
8969                 path = [path stringByAppendingString:U->C.A->AN.movName];
8970
8971                 NSData *AVData = [NSData dataWithContentsOfFile:path];
8972
8973                 if(AVData)
8974                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
8975
8976
8977                 if(!AVpreview){
8978
8979                     NSString *path = @"data/AttackList3/IALdata";
8980
8981                     path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
8982
8983                     path = [path stringByAppendingFormat:@"/"];
8984
8985                     path = [path stringByAppendingString:U->C.A->AN.movName];
8986
8987
8988                     NSData *AVData = [NSData dataWithContentsOfFile:path];
8989
8990                     if(AVData)
8991                     AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
8992
8993
8994                 }
8995
8996                 if(AVpreview) {
8997                     AVPV.player = [AVpreview retain];
8998                 }else{
8999                     goto avAWESOME;
9000                 }
9001
9002
9003                 [AVPV setHidden:NO];
9004                 [AVpreview play];
9005                 [battleDialog setStringValue:message];
9006
9007                 avPlayerFlag1 = true;
9008
9009
9010                 U->C.A = aTop;
9011                 U = UTop;
9012                 return;
9013             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUNnum == 1){
9014
9015                 [battleDialog setStringValue:message];
9016                 animationFlag1 = true;
9017                 aniFrameCnt = 0;
9018                 return;
9019             }
9020
9021         avAWESOME:{}
9022
9023             double urSupposedToGet;
9024
9025             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9026
9027             double asItIs;
9028             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9029
9030             double oopsIsRight;
9031
9032             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9033             else oopsIsRight = U->C.S_C.MIS;
9034
9035             oopsIsRight = oopsIsRight/100;
9036             double val;
9037             if(!U2->C.aura && U->C.A->D){
9038             if(U->C.A->D->type == 0) dmg = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9039                                             - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9040             if(U->C.A->D->type == 1) dmg = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9041                                             - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9042             if(U->C.A->D->type == 2) dmg = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9043                                             - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9044             if(U->C.A->D->type == 3) dmg = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9045                                             - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9046             if(U->C.A->D->type == 4) dmg = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9047                                             - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9048             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9049             }else if(U->C.A->D){
9050                 val = 1/log(3+U2->C.S_C.MP/64);
9051                 if(U->C.A->D->type == 0) dmg = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9052                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9053                 if(U->C.A->D->type == 1) dmg = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9054                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9055                 if(U->C.A->D->type == 2) dmg = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9056                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9057                 if(U->C.A->D->type == 3) dmg = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9058                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9059                 if(U->C.A->D->type == 4) dmg = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9060                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9061                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9062             }
9063             double val2 = log(3+U2->C.S_C.MP/64);
9064             if(U->C.aura){
9065                 dmg = dmg*val2;
9066             }
9067
9068             if(U->C.A->D){
9069             if(U->C.A->D->fix == 2){
9070                 dmg = dmg/2 + (U->C.S_C.HIT/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9071
9072                 if(U->C.A->D->type == 0) dmg -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9073                 if(U->C.A->D->type == 1) dmg -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9074                 if(U->C.A->D->type == 2) dmg -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9075                 if(U->C.A->D->type == 3) dmg -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9076                 if(U->C.A->D->type == 4) dmg -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9077
9078
9079             }else if(U->C.A->D->fix == 1){
9080                 dmg = dmg/2 + ((U->C.S_C.ATK/2+U->C.S_C.HIT/2)/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9081
9082                 if(U->C.A->D->type == 0) dmg -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9083                 if(U->C.A->D->type == 1) dmg -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9084                 if(U->C.A->D->type == 2) dmg -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9085                 if(U->C.A->D->type == 3) dmg -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9086                 if(U->C.A->D->type == 4) dmg -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9087
9088             }else if(U->C.A->D->fix == 0){
9089
9090             }
9091             }
9092             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9093
9094             if(extentMPcostFlag && extentBattleFlag2){
9095
9096             }else{
9097                 U->C.S_C.MP -= costMP;
9098                 extentMPcostFlag = true;
9099             }
9100
9101             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9102             hitFix = U->C.A->hitPercent;
9103
9104             U2A = U->C.A;
9105             U->C.A = aTop;
9106
9107             U = UTop;
9108             while (!(AUN[1] == U->number)) {
9109                 U = U->next;
9110             }
9111             U2 = U;
9112
9113             U = UTop;
9114             while (!(DUN[DUNnum] == U->number)) {
9115                 U = U->next;
9116             }
9117
9118             double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9119
9120             double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9121             if(hi < 0) hi = 0;
9122
9123             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9124             if(hit > 100) hit = 100;
9125             if(hit < 0) hit = 0;
9126             if(U2A->D->sort == 1){
9127                 hit = 100;
9128             }
9129             if([self sortEcheck:U2A opponent:U])
9130                 hit = 0;
9131
9132             healFlag = false;
9133
9134             int wtf = 100;
9135             if(battleDod2Flag) wtf = 50;
9136             if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
9137
9138                 if(U2A->D->sort == 0){
9139                     if(U2A->D->type == 0) NSLog(@"計算式：((%g+%g)*%g-%g)*%g*%g", U2->C.S_C.ATK,U2A->totalD,oopsIsRight,U->C.S_C.DEF, val, val2);
9140                     if(U2A->D->type == 4) NSLog(@"計算式：((%g+%g)*%g-%g)*%g*%g", U2->C.S_C.CAP,U2A->totalD,oopsIsRight,U->C.S_C.CAP, val, val2);
9141                     NSLog(@"修正前のダメージ:%g", dmg);
9142                     dmg = [self dmgResist:dmg];
9143                     NSLog(@"属性後のダメージ:%g", dmg);
9144                     def2 = pow(def2, U->C.S_C.DEF);
9145                     int omfg = rand()%100;
9146                     NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9147                     dmg = (dmg*omfg/100/10 + dmg);
9148                     NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9149                     if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9150                     else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9151
9152                     if(U->C.S_C.typeMOVE == RIKU){
9153                         if(U2A->riku == A) dmg = dmg*1.2;
9154                         if(U2A->riku == B) dmg = dmg*1.0;
9155                         if(U2A->riku == C) dmg = dmg*0.6;
9156                         if(U2A->riku == D) dmg = dmg*0.2;
9157                         if(U2A->riku == E) dmg = 0;
9158                         if(U2A->riku == S) dmg = dmg*1.5;
9159                         if(U2A->riku == SS) dmg = dmg*2.0;
9160                     } if(U->C.S_C.typeMOVE == UMI &&
9161                        (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9162                         if(U2A->umi == A) dmg = dmg*1.2;
9163                         if(U2A->umi == B) dmg = dmg*1.0;
9164                         if(U2A->umi == C) dmg = dmg*0.6;
9165                         if(U2A->umi == D) dmg = dmg*0.2;
9166                         if(U2A->umi == E) dmg = 0;
9167                         if(U2A->umi == S) dmg = dmg*1.5;
9168                         if(U2A->umi == SS) dmg = dmg*2.0;
9169                     }else if(U->C.S_C.typeMOVE == UMI){
9170                         if(U2A->riku == A) dmg = dmg*1.2;
9171                         if(U2A->riku == B) dmg = dmg*1.0;
9172                         if(U2A->riku == C) dmg = dmg*0.6;
9173                         if(U2A->riku == D) dmg = dmg*0.2;
9174                         if(U2A->riku == E) dmg = 0;
9175                         if(U2A->riku == S) dmg = dmg*1.5;
9176                         if(U2A->riku == SS) dmg = dmg*2.0;
9177
9178                     } if(U->C.S_C.typeMOVE == CHU){
9179                         if(U2A->chu == A) dmg = dmg*1.2;
9180                         if(U2A->chu == B) dmg = dmg*1.0;
9181                         if(U2A->chu == C) dmg = dmg*0.6;
9182                         if(U2A->chu == D) dmg = dmg*0.2;
9183                         if(U2A->chu == E) dmg = 0;
9184                         if(U2A->chu == S) dmg = dmg*1.5;
9185                         if(U2A->chu == SS) dmg = dmg*2.0;
9186                     } if(U->C.S_C.typeMOVE == SORA){
9187                         if(U2A->sora == A) dmg = dmg*1.2;
9188                         if(U2A->sora == B) dmg = dmg*1.0;
9189                         if(U2A->sora == C) dmg = dmg*0.6;
9190                         if(U2A->sora == D) dmg = dmg*0.2;
9191                         if(U2A->sora == E) dmg = 0;
9192                         if(U2A->sora == S) dmg = dmg*1.5;
9193                         if(U2A->sora == SS) dmg = dmg*2.0;
9194                     }
9195
9196                     NSLog(@"ユニットの地形適用後:%g", dmg);
9197                     if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
9198                     graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9199
9200                     grazeFlag = false;
9201                     omfg = rand()%100;
9202                     if(graze > omfg && !healFlag) {dmg = dmg/5;
9203                         grazeFlag = true;
9204                     }
9205                     if(battleDef2Flag) dmg -= dmg*0.5;
9206                     battleDef2Flag = false;
9207                     dmg = floor(dmg);
9208                     if(dmg < 0) dmg = 0;
9209                     U->C.S_C.HP -= dmg;
9210                     U->C.S_C.vigor++;
9211
9212                     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9213                     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9214
9215
9216
9217                 }else if(U2A->D->sort == 1){
9218                     dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
9219                     dmg = floor(dmg);
9220
9221                     U->C.S_C.HP += dmg;
9222                     if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
9223                     healFlag = true;
9224                 }
9225
9226                 while(1){
9227                     if(U->C.S_C.HP <= 0) {
9228                         U->C.S_C.HP = 0;
9229                         U2->C.S_C.vigor += 5;
9230
9231                         messageProcess = 2;
9232                         if(U->dead) break;
9233                         U->dead = true;
9234
9235
9236                         if(U->targType1L)
9237                             targType1cnt[0]--;
9238                         if(U->targType2L) {
9239                             targType2cnt[0]--;
9240                             targType2Lflag = true;
9241                         }
9242
9243                         if(U->targType1D)
9244                             targType1cnt[1]--;
9245                         if(U->targType2D) {
9246                             targType2cnt[1]--;
9247                             targType2Dflag = true;
9248                         }
9249
9250                         break;
9251                     }
9252                     break;
9253                 }
9254
9255             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9256             [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9257
9258                 if(![U2A->msg isEqualToString:@""]){
9259
9260                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9261                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9262
9263                 }
9264
9265             if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9266             if(!healFlag) {
9267                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9268                 btHitFlag1 = true;
9269                 }
9270             else {
9271                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
9272                 btHitFlag1 = false;
9273             }
9274             }else if(battleDef1Flag){
9275
9276
9277                 U = UTop;
9278                 while (!(AUN[1] == U->number)) {
9279                     U = U->next;
9280                 }
9281
9282
9283                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9284
9285                 btHitFlag1 = false;
9286
9287             }else if(battleDod1Flag){
9288
9289                 U = UTop;
9290                 while (!(AUN[1] == U->number)) {
9291                     U = U->next;
9292                 }
9293
9294                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9295
9296                 btHitFlag1 = false;
9297             }else{
9298
9299                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9300                 btHitFlag1 = false;
9301
9302             }
9303                 [battleDialog setStringValue:message];
9304
9305             [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9306
9307             U = UTop;
9308
9309             bLoopFlag = true;
9310
9311             if(!extentBattleFlag2){
9312             if(healFlag) {
9313                 messageProcess++;
9314                  };
9315             messageProcess++;
9316             }else if(extentBattleFlag2){
9317                 if(btHitExtendProc1 == 2)
9318                     btHitExtendProc1 = 3;
9319                 if(btHitExtendProc1 >= 2)
9320                     btHitExtendFix1 = 1;
9321
9322                 btHitFlagCnt1 = 0;
9323                 DUNnum++;
9324                 messageProcess = 1;
9325                 if(DUN[DUNnum] <= 0){
9326                     messageProcess++;
9327                     messageProcess++;
9328                     extentBattleFlag2 = false;
9329                     extentbool = false;
9330                     extentMPcostFlag = false;
9331                 }
9332             }
9333             message = @"";
9334             avPlayerFlag1 = false;
9335             animationFlag3 = false;
9336             btAtattckMoveEnd = false;
9337             oopsCnt = 30;
9338             break;
9339
9340         case 2:
9341
9342             if(bLoopFlag) break;
9343             BTunitAttackFlag1 = false;
9344             BTunitAttackFlag2 = true;
9345             if(battleDef2Flag || battleDod2Flag)
9346                 BTunitAttackFlag2 = false;
9347             btHitFlag1 = false;
9348
9349
9350             U = UTop;
9351             while (!(DUN[1] == U->number)) {
9352                 U = U->next;
9353             }
9354             U2 = U;
9355             U = UTop;
9356             while (!(AUN[1] == U->number)) {
9357                 U = U->next;
9358             }
9359
9360
9361             if(U->number == U2->number){
9362                 btSelfAction = true;
9363             }else{
9364                 btSelfAction = false;
9365             }
9366
9367             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
9368                 U = UTop;
9369                 [self DisplayMessageMod1B];
9370                 return;
9371             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
9372                 U = UTop;
9373                 [self DisplayMessageMod2B];
9374                 return;
9375             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
9376                 U = UTop;
9377                 [self DisplayMessageMod3B];
9378                 return;
9379             }
9380             U = UTop;
9381
9382             if(bLoopFlag) break;
9383
9384             U = UTop;
9385             while (!(AUN[1] == U->number)) {
9386                 U = U->next;
9387             }
9388             U2 = U;
9389             U = UTop;
9390
9391             U = UTop;
9392             while (!(DUN[1] == U->number)) {
9393                 U = U->next;
9394             }
9395
9396             ATTACK *aTop2 = U->C.A;
9397             attackTop2 = aTop2;
9398             int mostDmg = 0;
9399             int mostDmg2 = 0;
9400             int mostNum = 0;
9401             int num = 0;
9402             int mpCost =0;
9403
9404             if(!U->C.A) goto SKIP3;
9405
9406
9407
9408             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9409
9410             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9411
9412
9413             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9414             else oopsIsRight = U->C.S_C.MIS;
9415
9416             oopsIsRight = oopsIsRight/100;
9417
9418             if(U->C.A) {
9419                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9420             }
9421             while(U->C.A){
9422                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9423                 if(!U2->C.aura && U->C.A->D){
9424                     if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9425                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9426                     if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9427                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9428                     if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9429                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9430                     if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9431                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9432                     if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9433                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9434                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
9435                 }else if(U->C.A->D){
9436                     val = 1/log(3+U2->C.S_C.MP/64);
9437                     if(U->C.A->D->type == 0) mostDmg2 = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9438                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9439                     if(U->C.A->D->type == 1) mostDmg2 = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9440                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9441                     if(U->C.A->D->type == 2) mostDmg2 = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9442                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9443                     if(U->C.A->D->type == 3) mostDmg2 = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9444                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor)*asItIs*val;
9445                     if(U->C.A->D->type == 4) mostDmg2 = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9446                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9447                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
9448                 }
9449                 double val2 = log(3+U2->C.S_C.MP/64);
9450                 if(U->C.aura){
9451                     mostDmg2 = mostDmg2*val2;
9452                 }
9453                 if(U->C.A->D){
9454                     if(U->C.A->D->fix == 2){
9455                         mostDmg2 = mostDmg2/2 + (U->C.S_C.HIT/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9456
9457                         if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9458                         if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9459                         if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9460                         if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9461                         if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9462
9463
9464                     }else if(U->C.A->D->fix == 1){
9465                         mostDmg2 = mostDmg2/2 + ((U->C.S_C.ATK/2+U->C.S_C.HIT/2)/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9466
9467                         if(U->C.A->D->type == 0) mostDmg2 -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9468                         if(U->C.A->D->type == 1) mostDmg2 -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9469                         if(U->C.A->D->type == 2) mostDmg2 -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9470                         if(U->C.A->D->type == 3) mostDmg2 -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9471                         if(U->C.A->D->type == 4) mostDmg2 -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9472
9473                     }else if(U->C.A->D->fix == 0){
9474
9475                     }
9476                 }
9477
9478                 U2A = U->C.A;
9479                 UNIT *oops = U;
9480                 U = U2;
9481                 mostDmg2 = [self dmgResist:mostDmg2];
9482                 U = oops;
9483
9484                 costVIG = U->C.A->vigor;
9485                 if(U->C.A->D)
9486                 if(mostDmg < mostDmg2 && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && U->C.A->D->sort != 1 && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
9487
9488
9489                     mostDmg = mostDmg2;
9490
9491
9492                     //mostDmg = U->C.A->totalD;
9493                     mostNum = num;
9494                 }
9495                 U->C.A = U->C.A->next;
9496                 num++;
9497             }
9498
9499             U->C.A = aTop2;
9500
9501             if(!battleSet2PushedFlag){
9502                 for(int i = 0;i < mostNumSub;i++){
9503                 U->C.A = U->C.A->next;
9504             }
9505
9506             }else{
9507             for(int i = 0;i < crCAL2;i++){
9508                 U->C.A = U->C.A->next;
9509             }
9510
9511
9512             }
9513             if(U->C.A->D){
9514             if(U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && U->C.A->D->sort != 1 && ![self sortEcheck:U->C.A opponent:U2]){
9515
9516             }else while(U->C.A){
9517                 U->C.A = U->C.A->next;
9518             }}
9519
9520             if(!U->C.A){
9521                 U->C.A = aTop2;
9522                 U = UTop;
9523                 BTunitAttackFlag2 = false;
9524                 message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
9525                 goto SKIP1;
9526             }
9527             effCun = U;
9528             attackCR2 = U->C.A;
9529
9530             if(attackCR2->magic){
9531                 btAttackType2 = BT_TYPE_MAGIC;
9532             }else{
9533                 btAttackType2 = BT_TYPE_NORMAL;
9534             }
9535
9536             if(BTunitAttackFlag2)
9537                 if((btAttackType2 == BT_TYPE_NORMAL && btAttackMoveValue2 < 2)
9538                    || (btAttackType2 == BT_TYPE_MAGIC && btAttackMoveValue2 < 5)
9539                    || (btAttackType2 == BT_TYPE_ABILITY && btAttackMoveValue2 < 2)){
9540
9541
9542                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9543
9544                 [battleDialog setStringValue:message];
9545                 U->C.A = aTop2;
9546                 U = UTop;
9547
9548                 return;
9549             }
9550
9551             if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9552
9553             if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
9554                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
9555
9556                 NSString *path = @"data/AttackList/ALdata";
9557
9558                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
9559
9560                 path = [path stringByAppendingFormat:@"/"];
9561
9562                 path = [path stringByAppendingString:U->C.A->AN.movName];
9563
9564
9565                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9566
9567                 if(AVpreview) {
9568                     AVPV.player = [AVpreview retain];
9569                 }else{
9570                     goto avAWESOME2;
9571                 }
9572
9573                 [AVPV setControlsStyle:0];
9574                 [AVPV setHidden:NO];
9575                 [AVpreview play];
9576                 [battleDialog setStringValue:message];
9577
9578                 avPlayerFlag2 = true;
9579
9580                 U->C.A = aTop2;
9581                 U = UTop;
9582                 return;
9583             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
9584
9585
9586                 animationFlag2 = true;
9587                 aniFrameCnt = 0;
9588                 return;
9589             }
9590
9591
9592         avAWESOME2:{}
9593             U2A = U->C.A;
9594
9595             /*
9596             if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
9597             if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
9598             if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
9599             if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
9600             if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
9601             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9602             */
9603
9604             U->C.A = aTop2;
9605             U = UTop;
9606             while (!(AUN[1] == U->number)) {
9607                 U = U->next;
9608             }
9609             U2 = U;
9610             U = UTop;
9611             while (!(DUN[1] == U->number)) {
9612                 U = U->next;
9613             }
9614             NSString *string = [U2A->name retain];
9615             while (![U->C.A->name isEqualToString:string] && U->C.A) {
9616                 U->C.A = U->C.A->next;
9617             }
9618
9619             if(!U->C.A) U->C.A = aTop2;
9620
9621             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9622
9623             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9624
9625
9626             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9627             else oopsIsRight = U->C.S_C.MIS;
9628
9629             oopsIsRight = oopsIsRight/100;
9630
9631
9632             if(!U2->C.aura && U->C.A->D){
9633                 if(U->C.A->D->type == 0) dmg = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9634                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9635                 if(U->C.A->D->type == 1) dmg = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9636                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9637                 if(U->C.A->D->type == 2) dmg = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9638                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9639                 if(U->C.A->D->type == 3) dmg = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9640                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9641                 if(U->C.A->D->type == 4) dmg = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9642                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9643                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9644             }else if(U->C.A->D){
9645                 double val = val = 1/log(3+U2->C.S_C.MP/64);
9646                 if(U->C.A->D->type == 0) dmg = ((U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9647                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9648                 if(U->C.A->D->type == 1) dmg = ((U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9649                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9650                 if(U->C.A->D->type == 2) dmg = ((U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9651                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9652                 if(U->C.A->D->type == 3) dmg = ((U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9653                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9654                 if(U->C.A->D->type == 4) dmg = ((U->C.S_C.CAP*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight
9655                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9656                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9657             }
9658             val2 = log(3+U2->C.S_C.MP/64);
9659             if(U->C.aura){
9660                 dmg = dmg*val2;
9661             }
9662             if(U->C.A->D){
9663                 if(U->C.A->D->fix == 2){
9664                     dmg = dmg/2 + (U->C.S_C.HIT/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9665
9666                     if(U->C.A->D->type == 0) dmg -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9667                     if(U->C.A->D->type == 1) dmg -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9668                     if(U->C.A->D->type == 2) dmg -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9669                     if(U->C.A->D->type == 3) dmg -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9670                     if(U->C.A->D->type == 4) dmg -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9671
9672
9673                 }else if(U->C.A->D->fix == 1){
9674                     dmg = dmg/2 + ((U->C.S_C.ATK/2+U->C.S_C.HIT/2)/2*U->C.S_C.HP/U->C.S_M.HP+urSupposedToGet*U->C.S_C.vigor/100)*oopsIsRight;
9675
9676                     if(U->C.A->D->type == 0) dmg -=  (U2->C.S_C.DEF/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9677                     if(U->C.A->D->type == 1) dmg -=  (U2->C.S_C.ATK/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9678                     if(U->C.A->D->type == 2) dmg -=  (U2->C.S_C.EVA/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9679                     if(U->C.A->D->type == 3) dmg -=  (U2->C.S_C.ACU/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9680                     if(U->C.A->D->type == 4) dmg -=  (U2->C.S_C.CAP/2*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9681
9682                 }else if(U->C.A->D->fix == 0){
9683
9684                 }
9685             }
9686             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9687             U->C.S_C.MP -= costMP;
9688
9689             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9690             hitFix = U->C.A->hitPercent;
9691
9692             U2A = U->C.A;
9693
9694             U->C.A = aTop2;
9695
9696             U = UTop;
9697             while (!(DUN[1] == U->number)) {
9698                 U = U->next;
9699             }
9700             U2 = U;
9701
9702             U = UTop;
9703             while (!(AUN[1] == U->number)) {
9704                 U = U->next;
9705             }
9706
9707             hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9708
9709             hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9710             if(hi < 0) hi = 0;
9711
9712             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9713             if(hit > 100) hit = 100;
9714             if(hit < 0) hit = 0;
9715             if([self sortEcheck:U2A opponent:U])
9716                 hit = 0;
9717
9718             battleDod1Flag = false;
9719
9720             U = UTop;
9721             while (!(DUN[1] == U->number)) {
9722                 U = U->next;
9723             }
9724             U2 = U;
9725
9726             U = UTop;
9727             while (!(AUN[1] == U->number)) {
9728                 U = U->next;
9729             }
9730
9731             int omg = 100;
9732             if(battleDod1Flag) omg = 50;
9733
9734             if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
9735                 if(U2A->D->type == 0) NSLog(@"計算式：((%g+%g)*%g-%g)*%g*%g", U2->C.S_C.ATK,U2A->totalD,oopsIsRight,U->C.S_C.DEF, val, val2);
9736                 if(U2A->D->type == 4) NSLog(@"計算式：((%g+%g)*%g-%g)*%g%g", U2->C.S_C.CAP,U2A->totalD,oopsIsRight,U->C.S_C.CAP, val, val2);
9737                 NSLog(@"修正前のダメージ:%g", dmg);
9738                 dmg = [self dmgResist:dmg];
9739                 NSLog(@"属性後のダメージ:%g", dmg);
9740             def2 = pow(def2, U->C.S_C.DEF);
9741             int omfg = rand()%100;
9742                 NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9743                 dmg = (dmg*omfg/100/10 + dmg);
9744                 NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9745                 if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9746                 else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9747
9748                 if(U->C.S_C.typeMOVE == RIKU){
9749                     if(U2A->riku == A) dmg = dmg*1.2;
9750                     if(U2A->riku == B) dmg = dmg*1.0;
9751                     if(U2A->riku == C) dmg = dmg*0.6;
9752                     if(U2A->riku == D) dmg = dmg*0.2;
9753                     if(U2A->riku == E) dmg = 0;
9754                     if(U2A->riku == S) dmg = dmg*1.5;
9755                     if(U2A->riku == SS) dmg = dmg*2.0;
9756                 } if(U->C.S_C.typeMOVE == UMI &&
9757                      (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9758                     if(U2A->umi == A) dmg = dmg*1.2;
9759                     if(U2A->umi == B) dmg = dmg*1.0;
9760                     if(U2A->umi == C) dmg = dmg*0.6;
9761                     if(U2A->umi == D) dmg = dmg*0.2;
9762                     if(U2A->umi == E) dmg = 0;
9763                     if(U2A->umi == S) dmg = dmg*1.5;
9764                     if(U2A->umi == SS) dmg = dmg*2.0;
9765                 }else if(U->C.S_C.typeMOVE == UMI){
9766                     if(U2A->riku == A) dmg = dmg*1.2;
9767                     if(U2A->riku == B) dmg = dmg*1.0;
9768                     if(U2A->riku == C) dmg = dmg*0.6;
9769                     if(U2A->riku == D) dmg = dmg*0.2;
9770                     if(U2A->riku == E) dmg = 0;
9771                     if(U2A->riku == S) dmg = dmg*1.5;
9772                     if(U2A->riku == SS) dmg = dmg*2.0;
9773
9774                 } if(U->C.S_C.typeMOVE == CHU){
9775                     if(U2A->chu == A) dmg = dmg*1.2;
9776                     if(U2A->chu == B) dmg = dmg*1.0;
9777                     if(U2A->chu == C) dmg = dmg*0.6;
9778                     if(U2A->chu == D) dmg = dmg*0.2;
9779                     if(U2A->chu == E) dmg = 0;
9780                     if(U2A->chu == S) dmg = dmg*1.5;
9781                     if(U2A->chu == SS) dmg = dmg*2.0;
9782                 } if(U->C.S_C.typeMOVE == SORA){
9783                     if(U2A->sora == A) dmg = dmg*1.2;
9784                     if(U2A->sora == B) dmg = dmg*1.0;
9785                     if(U2A->sora == C) dmg = dmg*0.6;
9786                     if(U2A->sora == D) dmg = dmg*0.2;
9787                     if(U2A->sora == E) dmg = 0;
9788                     if(U2A->sora == S) dmg = dmg*1.5;
9789                     if(U2A->sora == SS) dmg = dmg*2.0;
9790                 }
9791
9792                 NSLog(@"ユニットの地形適用後:%g", dmg);
9793
9794
9795                 graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9796
9797                 grazeFlag = false;
9798                 omfg = rand()&100;
9799                 if(graze > omfg && !healFlag) {dmg = dmg/5;
9800                     grazeFlag = true;
9801                 }
9802
9803             if(battleDef1Flag) dmg -= dmg*0.5;
9804             battleDef1Flag = false;
9805                 dmg = floor(dmg);
9806                 if(dmg < 0) dmg = 0;
9807                 U->C.S_C.HP -= dmg;
9808                 U->C.S_C.vigor++;
9809
9810                 [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9811                 [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9812
9813                 while(1){
9814                 if(U->C.S_C.HP <= 0) {
9815                     U->C.S_C.HP = 0;
9816                     U2->C.S_C.vigor += 5;
9817
9818                     messageProcess = 2;
9819                     if(U->dead) break;
9820                     U->dead = true;
9821
9822
9823                     if(U->targType1L)
9824                         targType1cnt[0]--;
9825                     if(U->targType2L) {
9826                         targType2cnt[0]--;
9827                         targType2Lflag = true;
9828                     }
9829
9830                     if(U->targType1D)
9831                         targType1cnt[1]--;
9832                     if(U->targType2D) {
9833                         targType2cnt[1]--;
9834                         targType2Dflag = true;
9835                     }
9836
9837                     break;
9838                 }
9839                     break;
9840                 }
9841
9842
9843
9844                 [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9845
9846                 [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9847
9848                 if(![U2A->msg isEqualToString:@""]){
9849                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9850                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9851                 }
9852
9853
9854
9855                 if(grazeFlag)
9856                     message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9857
9858                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9859                 btHitFlag2 = true;
9860
9861             }else if(battleDef2Flag){
9862
9863
9864                 U = UTop;
9865                 while (!(DUN[1] == U->number)) {
9866                     U = U->next;
9867                 }
9868
9869
9870                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9871                 btHitFlag2 = false;
9872
9873             }else if(battleDod2Flag){
9874
9875                 U = UTop;
9876                 while (!(DUN[1] == U->number)) {
9877                     U = U->next;
9878                 }
9879
9880                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9881
9882                 btHitFlag2 = false;
9883             }else{
9884
9885                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9886                 btHitFlag2 = false;
9887             }
9888         SKIP1:
9889             [battleDialog setStringValue:message];
9890         SKIP3:
9891             U = UTop;
9892             [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9893             bLoopFlag = true;
9894             messageProcess++;
9895             message = @"";
9896             avPlayerFlag2 = false;
9897             animationFlag3 = false;
9898             btAtattckMoveEnd = false;
9899             oopsCnt = 30;
9900             break;
9901         case 3:
9902             //おまんこ
9903             if(bLoopFlag) break;
9904             if(cpuAImodeflag && !cpuTurnEndFlag) {
9905                 wtRdy = false;
9906             wtRdy2 = false;
9907             }
9908
9909             fuckingLoadBugFix = false;
9910
9911             battleSetUp = false;
9912             battleSetFlag = false;
9913             battleFlag = false;
9914             battleRdy = false;
9915             battleSet2PushedFlag = false;
9916             cpuModeBATTLEendFlag = true;
9917             crCAL1 = 0;
9918             crCAL2 = 0;
9919             [battleWindow close];
9920             pussyLoopFlag = false;
9921             cpuAtkExtendFlag3 = false;
9922             cpuOMFGmoveATKfixFlag = false;
9923             unitNoMoveFlag = false;
9924             UA = NULL;
9925             Utarget = NULL;
9926             CPUmostDmgChoice = false;
9927             //おまんちん
9928             cpuIsAttackingFlag = false;
9929             for(int g = 0;g < chipWidth;g++){
9930                 for(int k = 0;k < chipHeight;k++){
9931                     g_attackRangeExtent[g][k] = 0;
9932                 }
9933             }
9934
9935             btDistanceX1 = 0;
9936             btDistanceX2 = 0;
9937             BTunitAttackFlag1 = false;
9938             BTunitAttackFlag2 = false;
9939             BTunitAttackFlag1 = false;
9940             btAttackMoveValue1 = 0;
9941             btAttackMoveValue2 = 0;
9942             btHitFlag1 = false;
9943             btHitFlag2 = false;
9944             btHitFlagCnt1 = 0;
9945             btHitFlagCnt2 = 0;
9946             btHitExtendFlag1 = false;
9947             btHitExtendProc1 = 0;
9948             btHitExtendMove1 = 0;
9949             btHitExtendFlag2 = false;
9950             btHitExtendProc2 = 0;
9951             btHitExtendMove2 = 0;
9952             baseDistanceCompFlag = false;
9953             battleVeryBegunFlag = false;
9954             CPUAttackSubmitFlag = false;
9955             battleSetUp = false;
9956             displayBattleCheckPanelFlag = 0;
9957             battleEndFlag = true;
9958             assholeLoadBugFix = false;
9959             break;
9960
9961         default:
9962             break;
9963     }
9964
9965
9966     UCselected = UC[-1];
9967
9968
9969 }
9970
9971 -(void)DisplayMessageMod1A{//両方モビール
9972
9973     double def2 = (double)31/32;
9974     NSString *message = @"";
9975
9976     enum{
9977         RIKU,
9978         UMI,
9979         CHU,
9980         SORA,
9981     };
9982
9983     enum{
9984         A,
9985         B,
9986         C,
9987         D,
9988         E,
9989         S,
9990         SS
9991     };
9992
9993
9994
9995     if(bLoopFlag) return;
9996     U = UTop;
9997     while (!(AUN[1] == U->number)) {
9998         U = U->next;
9999     }
10000     U2 = U;
10001     ATTACK *aTop = U->CL.A;
10002     for(int i = 0;i < crCAL1;i++){
10003         U->CL.A = U->CL.A->next;
10004     }
10005
10006
10007     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10008
10009     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10010         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10011
10012         NSString *path = @"data/AttackList/ALdata";
10013
10014         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10015
10016         path = [path stringByAppendingFormat:@"/"];
10017
10018         path = [path stringByAppendingString:U->CL.A->AN.movName];
10019
10020         NSData *AVData = [NSData dataWithContentsOfFile:path];
10021
10022         if(AVData)
10023             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10024
10025
10026         if(!AVpreview){
10027
10028             NSString *path = @"data/AttackList3/IALdata";
10029
10030             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10031
10032             path = [path stringByAppendingFormat:@"/"];
10033
10034             path = [path stringByAppendingString:U->CL.A->AN.movName];
10035
10036
10037             NSData *AVData = [NSData dataWithContentsOfFile:path];
10038
10039             if(AVData)
10040                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10041
10042
10043         }
10044
10045         if(AVpreview) {
10046             AVPV.player = [AVpreview retain];
10047         }else{
10048             goto avAWESOME1A;
10049         }
10050
10051
10052         [AVPV setHidden:NO];
10053         [AVpreview play];
10054         [battleDialog setStringValue:message];
10055
10056         avPlayerFlag1 = true;
10057
10058         U->CL.A = aTop;
10059
10060         U = UTop;
10061         return;
10062     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10063
10064         [battleDialog setStringValue:message];
10065         animationFlag1 = true;
10066         aniFrameCnt = 0;
10067         return;
10068     }
10069
10070 avAWESOME1A:{}
10071
10072     dmg = U->CL.A->totalD;
10073
10074     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10075     U->CL.S_C.EN -= costMP;
10076
10077     hit = U->CL.S_C.MOB+U->C.S_C.HIT;
10078     hitFix = U->CL.A->hitPercent;
10079
10080     U2A = U->CL.A;
10081     U->CL.A = aTop;
10082
10083     U = UTop;
10084     while (!(DUN[1] == U->number)) {
10085         U = U->next;
10086     }
10087     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
10088     if(hit > 100) hit = 100;
10089     if(U2A->D->sort == 1){
10090         hit = 100;
10091     }
10092     if([self sortEcheck:U2A opponent:U])
10093         hit = 0;
10094
10095     healFlag = false;
10096
10097     int wtf = 100;
10098     if(battleDod2Flag) wtf = 50;
10099     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10100
10101         if(U2A->D->sort == 0){
10102             NSLog(@"修正前のダメージ:%g", dmg);
10103             dmg = [self dmgResist:dmg];
10104             NSLog(@"属性後のダメージ:%g", dmg);
10105             def2 = pow(def2, U->CL.S_C.ARM);
10106             int omfg = rand()%100;
10107             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10108
10109             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10110             dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10111             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10112             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10113             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10114
10115             if(U->CL.S_C.typeMOVE == RIKU){
10116                 if(U2A->riku == A) dmg = dmg*1.2;
10117                 if(U2A->riku == B) dmg = dmg*1.0;
10118                 if(U2A->riku == C) dmg = dmg*0.6;
10119                 if(U2A->riku == D) dmg = dmg*0.2;
10120                 if(U2A->riku == E) dmg = 0;
10121                 if(U2A->riku == S) dmg = dmg*1.5;
10122                 if(U2A->riku == SS) dmg = dmg*2.0;
10123             } if(U->CL.S_C.typeMOVE == UMI &&
10124                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10125                 if(U2A->umi == A) dmg = dmg*1.2;
10126                 if(U2A->umi == B) dmg = dmg*1.0;
10127                 if(U2A->umi == C) dmg = dmg*0.6;
10128                 if(U2A->umi == D) dmg = dmg*0.2;
10129                 if(U2A->umi == E) dmg = 0;
10130                 if(U2A->umi == S) dmg = dmg*1.5;
10131                 if(U2A->umi == SS) dmg = dmg*2.0;
10132             }else if(U->CL.S_C.typeMOVE == UMI){
10133                 if(U2A->riku == A) dmg = dmg*1.2;
10134                 if(U2A->riku == B) dmg = dmg*1.0;
10135                 if(U2A->riku == C) dmg = dmg*0.6;
10136                 if(U2A->riku == D) dmg = dmg*0.2;
10137                 if(U2A->riku == E) dmg = 0;
10138                 if(U2A->riku == S) dmg = dmg*1.5;
10139                 if(U2A->riku == SS) dmg = dmg*2.0;
10140
10141             } if(U->CL.S_C.typeMOVE == CHU){
10142                 if(U2A->chu == A) dmg = dmg*1.2;
10143                 if(U2A->chu == B) dmg = dmg*1.0;
10144                 if(U2A->chu == C) dmg = dmg*0.6;
10145                 if(U2A->chu == D) dmg = dmg*0.2;
10146                 if(U2A->chu == E) dmg = 0;
10147                 if(U2A->chu == S) dmg = dmg*1.5;
10148                 if(U2A->chu == SS) dmg = dmg*2.0;
10149             } if(U->CL.S_C.typeMOVE == SORA){
10150                 if(U2A->sora == A) dmg = dmg*1.2;
10151                 if(U2A->sora == B) dmg = dmg*1.0;
10152                 if(U2A->sora == C) dmg = dmg*0.6;
10153                 if(U2A->sora == D) dmg = dmg*0.2;
10154                 if(U2A->sora == E) dmg = 0;
10155                 if(U2A->sora == S) dmg = dmg*1.5;
10156                 if(U2A->sora == SS) dmg = dmg*2.0;
10157             }
10158
10159             NSLog(@"ユニットの地形適用後:%g", dmg);
10160             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10161             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10162
10163             grazeFlag = false;
10164             omfg = rand()%100;
10165             if(graze > omfg && !healFlag) {dmg = dmg/5;
10166                 grazeFlag = true;
10167             }
10168             if(battleDef2Flag) dmg -= dmg*0.5;
10169             battleDef2Flag = false;
10170             dmg = floor(dmg);
10171             if(dmg < 0) dmg = 0;
10172             U->CL.S_C.HP -= dmg;
10173             U->C.S_C.vigor++;
10174
10175         }else if(U2A->D->sort == 1){
10176             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10177             dmg = floor(dmg);
10178
10179             U->CL.S_C.HP += dmg;
10180
10181             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10182             healFlag = true;
10183         }
10184
10185         while(1){
10186             if(U->CL.S_C.HP <= 0) {
10187                 U->CL.S_C.HP = 0;
10188                 U2->C.S_C.vigor += 5;
10189
10190                 messageProcess = 2;
10191                 if(U->dead) break;
10192                 U->dead = true;
10193
10194
10195                 if(U->targType1L)
10196                     targType1cnt[0]--;
10197                 if(U->targType2L) {
10198                     targType2cnt[0]--;
10199                     targType2Lflag = true;
10200                 }
10201
10202                 if(U->targType1D)
10203                     targType1cnt[1]--;
10204                 if(U->targType2D) {
10205                     targType2cnt[1]--;
10206                     targType2Dflag = true;
10207                 }
10208
10209                 break;
10210             }
10211             break;
10212         }
10213
10214         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10215         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10216
10217         if(![U2A->msg isEqualToString:@""]){
10218
10219             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10220                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10221
10222         }
10223
10224         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10225         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10226         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
10227     }else if(battleDef1Flag){
10228
10229
10230         U = UTop;
10231         while (!(AUN[1] == U->number)) {
10232             U = U->next;
10233         }
10234
10235
10236         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10237
10238
10239     }else if(battleDod1Flag){
10240
10241         U = UTop;
10242         while (!(AUN[1] == U->number)) {
10243             U = U->next;
10244         }
10245
10246         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10247
10248
10249     }else{
10250
10251         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10252
10253     }
10254     [battleDialog setStringValue:message];
10255
10256
10257     U = UTop;
10258
10259     bLoopFlag = true;
10260
10261     if(healFlag) {
10262         messageProcess++;
10263     };
10264     messageProcess++;
10265
10266     return;
10267
10268 }
10269
10270 -(void)DisplayMessageMod1B{
10271
10272     double def2 = (double)31/32;
10273     NSString *message = @"";
10274
10275     enum{
10276         RIKU,
10277         UMI,
10278         CHU,
10279         SORA,
10280     };
10281
10282     enum{
10283         A,
10284         B,
10285         C,
10286         D,
10287         E,
10288         S,
10289         SS
10290     };
10291
10292
10293     if(bLoopFlag) return;
10294
10295     U = UTop;
10296     while (!(AUN[1] == U->number)) {
10297         U = U->next;
10298     }
10299     U2 = U;
10300     U = UTop;
10301
10302     U = UTop;
10303     while (!(DUN[1] == U->number)) {
10304         U = U->next;
10305     }
10306
10307     ATTACK *aTop2 = U->CL.A;
10308     int mostDmg = 0;
10309     int mostNum = 0;
10310     int num = 0;
10311     int mpCost =0;
10312     if(U->CL.A) {
10313         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10314         costVIG = U->C.A->vigor;
10315     }
10316     while(U->CL.A){
10317         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10318         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && U->CL.A->D->sort != 1 && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
10319             mostDmg = U->CL.A->totalD;
10320             mostNum = num;
10321         }
10322         U->CL.A = U->CL.A->next;
10323         num++;
10324     }
10325
10326     U->CL.A = aTop2;
10327
10328     if(!battleSet2PushedFlag){
10329         for(int i = 0;i < mostNumSub;i++){
10330             U->CL.A = U->CL.A->next;
10331         }
10332
10333     }else{
10334         for(int i = 0;i < crCAL2;i++){
10335             U->CL.A = U->CL.A->next;
10336         }
10337     }
10338
10339     if(!U->CL.A->name){
10340
10341         U->CL.A = NULL;
10342     }
10343     if(U->CL.A){
10344     if(U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && U->CL.A->D->sort != 1 && ![self sortEcheck:U->CL.A opponent:U2]){
10345     }else while(U->CL.A){
10346         U->CL.A = U->CL.A->next;
10347     }
10348     }
10349
10350     if(!U->CL.A){
10351         U->CL.A = aTop2;
10352         U = UTop;
10353         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10354         goto SKIP1;
10355     }
10356
10357     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10358
10359
10360     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10361         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10362
10363         NSString *path = @"data/AttackList/ALdata";
10364
10365         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10366
10367         path = [path stringByAppendingFormat:@"/"];
10368
10369         path = [path stringByAppendingString:U->CL.A->AN.movName];
10370
10371
10372         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10373
10374         if(AVpreview) {
10375             AVPV.player = [AVpreview retain];
10376         }else{
10377             goto avAWESOME1B;
10378         }
10379
10380         [AVPV setControlsStyle:0];
10381         [AVPV setHidden:NO];
10382         [AVpreview play];
10383         [battleDialog setStringValue:message];
10384
10385         avPlayerFlag2 = true;
10386
10387         U->CL.A = aTop2;
10388         U = UTop;
10389         return;
10390     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
10391
10392
10393         animationFlag2 = true;
10394         aniFrameCnt = 0;
10395         return;
10396     }
10397
10398
10399 avAWESOME1B:{}
10400
10401     dmg = U->CL.A->totalD;
10402
10403     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10404     U->CL.S_C.EN -= costMP;
10405
10406     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10407     hitFix = U->CL.A->hitPercent;
10408
10409     U2A = U->CL.A;
10410     U->CL.A = aTop2;
10411
10412
10413     U = UTop;
10414     while (!(AUN[1] == U->number)) {
10415         U = U->next;
10416     }
10417
10418
10419     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
10420     if(hit > 100) hit = 100;
10421
10422     if([self sortEcheck:U2A opponent:U])
10423         hit = 0;
10424
10425     battleDod1Flag = false;
10426
10427     int omg = 100;
10428     if(battleDod1Flag) omg = 50;
10429
10430     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
10431         NSLog(@"修正前のダメージ:%g", dmg);
10432         dmg = [self dmgResist:dmg];
10433         NSLog(@"属性後のダメージ:%g", dmg);
10434         def2 = pow(def2, U->CL.S_C.ARM);
10435         int omfg = rand()%100;
10436         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10437         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10438         dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10439
10440
10441         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10442         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10443         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10444
10445         if(U->CL.S_C.typeMOVE == RIKU){
10446             if(U2A->riku == A) dmg = dmg*1.2;
10447             if(U2A->riku == B) dmg = dmg*1.0;
10448             if(U2A->riku == C) dmg = dmg*0.6;
10449             if(U2A->riku == D) dmg = dmg*0.2;
10450             if(U2A->riku == E) dmg = 0;
10451             if(U2A->riku == S) dmg = dmg*1.5;
10452             if(U2A->riku == SS) dmg = dmg*2.0;
10453         } if(U->CL.S_C.typeMOVE == UMI &&
10454              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10455             if(U2A->umi == A) dmg = dmg*1.2;
10456             if(U2A->umi == B) dmg = dmg*1.0;
10457             if(U2A->umi == C) dmg = dmg*0.6;
10458             if(U2A->umi == D) dmg = dmg*0.2;
10459             if(U2A->umi == E) dmg = 0;
10460             if(U2A->umi == S) dmg = dmg*1.5;
10461             if(U2A->umi == SS) dmg = dmg*2.0;
10462         }else if(U->CL.S_C.typeMOVE == UMI){
10463             if(U2A->riku == A) dmg = dmg*1.2;
10464             if(U2A->riku == B) dmg = dmg*1.0;
10465             if(U2A->riku == C) dmg = dmg*0.6;
10466             if(U2A->riku == D) dmg = dmg*0.2;
10467             if(U2A->riku == E) dmg = 0;
10468             if(U2A->riku == S) dmg = dmg*1.5;
10469             if(U2A->riku == SS) dmg = dmg*2.0;
10470
10471         } if(U->CL.S_C.typeMOVE == CHU){
10472             if(U2A->chu == A) dmg = dmg*1.2;
10473             if(U2A->chu == B) dmg = dmg*1.0;
10474             if(U2A->chu == C) dmg = dmg*0.6;
10475             if(U2A->chu == D) dmg = dmg*0.2;
10476             if(U2A->chu == E) dmg = 0;
10477             if(U2A->chu == S) dmg = dmg*1.5;
10478             if(U2A->chu == SS) dmg = dmg*2.0;
10479         } if(U->CL.S_C.typeMOVE == SORA){
10480             if(U2A->sora == A) dmg = dmg*1.2;
10481             if(U2A->sora == B) dmg = dmg*1.0;
10482             if(U2A->sora == C) dmg = dmg*0.6;
10483             if(U2A->sora == D) dmg = dmg*0.2;
10484             if(U2A->sora == E) dmg = 0;
10485             if(U2A->sora == S) dmg = dmg*1.5;
10486             if(U2A->sora == SS) dmg = dmg*2.0;
10487         }
10488
10489         NSLog(@"ユニットの地形適用後:%g", dmg);
10490
10491         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10492
10493         grazeFlag = false;
10494         omfg = rand()&100;
10495         if(graze > omfg && !healFlag) {dmg = dmg/5;
10496             grazeFlag = true;
10497         }
10498
10499         if(battleDef1Flag) dmg -= dmg*0.5;
10500         battleDef1Flag = false;
10501         dmg = floor(dmg);
10502         if(dmg < 0) dmg = 0;
10503         U->CL.S_C.HP -= dmg;
10504         U->C.S_C.vigor++;
10505
10506         while(1){
10507             if(U->CL.S_C.HP <= 0) {
10508                 U->CL.S_C.HP = 0;
10509                 U2->C.S_C.vigor += 5;
10510
10511                 messageProcess = 2;
10512                 if(U->dead) break;
10513                 U->dead = true;
10514
10515
10516                 if(U->targType1L)
10517                     targType1cnt[0]--;
10518                 if(U->targType2L) {
10519                     targType2cnt[0]--;
10520                     targType2Lflag = true;
10521                 }
10522
10523                 if(U->targType1D)
10524                     targType1cnt[1]--;
10525                 if(U->targType2D) {
10526                     targType2cnt[1]--;
10527                     targType2Dflag = true;
10528                 }
10529
10530                 break;
10531             }
10532             break;
10533         }
10534
10535
10536
10537         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10538
10539         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10540
10541         if(![U2A->msg isEqualToString:@""]){
10542             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10543                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10544         }
10545
10546
10547
10548         if(grazeFlag)
10549             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10550
10551         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10552
10553     }else if(battleDef2Flag){
10554
10555
10556         U = UTop;
10557         while (!(DUN[1] == U->number)) {
10558             U = U->next;
10559         }
10560
10561
10562         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10563
10564
10565     }else if(battleDod2Flag){
10566
10567         U = UTop;
10568         while (!(DUN[1] == U->number)) {
10569             U = U->next;
10570         }
10571
10572         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10573
10574
10575     }else{
10576
10577         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10578     }
10579 SKIP1:
10580     [battleDialog setStringValue:message];
10581
10582     U = UTop;
10583     bLoopFlag = true;
10584     messageProcess++;
10585     return;
10586
10587 }
10588
10589 -(void)DisplayMessageMod2A{//攻撃側モビール
10590
10591     double def2 = (double)31/32;
10592     NSString *message = @"";
10593
10594     enum{
10595         RIKU,
10596         UMI,
10597         CHU,
10598         SORA,
10599     };
10600
10601     enum{
10602         A,
10603         B,
10604         C,
10605         D,
10606         E,
10607         S,
10608         SS
10609     };
10610
10611
10612     if(bLoopFlag) return;
10613     U = UTop;
10614
10615     while (!(DUN[1] == U->number)) {
10616         U = U->next;
10617     }
10618     U2 = U;
10619
10620     U = UTop;
10621     while (!(AUN[1] == U->number)) {
10622         U = U->next;
10623     }
10624
10625     ATTACK *aTop = U->CL.A;
10626     for(int i = 0;i < crCAL1;i++){
10627         U->CL.A = U->CL.A->next;
10628     }
10629
10630
10631     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10632
10633     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10634         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10635
10636         NSString *path = @"data/AttackList/ALdata";
10637
10638         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10639
10640         path = [path stringByAppendingFormat:@"/"];
10641
10642         path = [path stringByAppendingString:U->CL.A->AN.movName];
10643
10644         NSData *AVData = [NSData dataWithContentsOfFile:path];
10645
10646         if(AVData)
10647             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10648
10649
10650         if(!AVpreview){
10651
10652             NSString *path = @"data/AttackList3/IALdata";
10653
10654             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10655
10656             path = [path stringByAppendingFormat:@"/"];
10657
10658             path = [path stringByAppendingString:U->CL.A->AN.movName];
10659
10660
10661             NSData *AVData = [NSData dataWithContentsOfFile:path];
10662
10663             if(AVData)
10664                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10665
10666
10667         }
10668
10669         if(AVpreview) {
10670             AVPV.player = [AVpreview retain];
10671         }else{
10672             goto avAWESOME2A;
10673         }
10674
10675
10676         [AVPV setHidden:NO];
10677         [AVpreview play];
10678         [battleDialog setStringValue:message];
10679
10680         avPlayerFlag1 = true;
10681
10682         U->CL.A = aTop;
10683
10684         U = UTop;
10685         return;
10686     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10687
10688         [battleDialog setStringValue:message];
10689         animationFlag1 = true;
10690         aniFrameCnt = 0;
10691         return;
10692     }
10693
10694 avAWESOME2A:{}
10695
10696     dmg = U->CL.A->totalD;
10697     double val = 1/log(3+U2->C.S_C.MP/64);
10698     if(U2->C.aura){
10699         dmg = dmg*val;
10700     }
10701
10702     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10703     U->CL.S_C.EN -= costMP;
10704
10705     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10706     hitFix = U->CL.A->hitPercent;
10707
10708     U2A = U->CL.A;
10709     U->CL.A = aTop;
10710
10711     U = UTop;
10712     while (!(DUN[1] == U->number)) {
10713         U = U->next;
10714     }
10715
10716     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
10717
10718     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
10719     if(hi < 0) hi = 0;
10720
10721     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
10722     if(hit > 100) hit = 100;
10723     if(U2A->D->sort == 1){
10724         hit = 100;
10725     }
10726     if([self sortEcheck:U2A opponent:U])
10727         hit = 0;
10728
10729     healFlag = false;
10730
10731     int wtf = 100;
10732     if(battleDod2Flag) wtf = 50;
10733     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10734
10735         if(U2A->D->sort == 0){
10736             NSLog(@"修正前のダメージ:%g", dmg);
10737             dmg = [self dmgResist:dmg];
10738             NSLog(@"属性後のダメージ:%g", dmg);
10739             def2 = pow(def2, U->C.S_C.DEF);
10740             int omfg = rand()%100;
10741             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
10742             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
10743             dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
10744             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10745             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10746             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10747
10748             if(U->C.S_C.typeMOVE == RIKU){
10749                 if(U2A->riku == A) dmg = dmg*1.2;
10750                 if(U2A->riku == B) dmg = dmg*1.0;
10751                 if(U2A->riku == C) dmg = dmg*0.6;
10752                 if(U2A->riku == D) dmg = dmg*0.2;
10753                 if(U2A->riku == E) dmg = 0;
10754                 if(U2A->riku == S) dmg = dmg*1.5;
10755                 if(U2A->riku == SS) dmg = dmg*2.0;
10756             } if(U->C.S_C.typeMOVE == UMI &&
10757                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10758                 if(U2A->umi == A) dmg = dmg*1.2;
10759                 if(U2A->umi == B) dmg = dmg*1.0;
10760                 if(U2A->umi == C) dmg = dmg*0.6;
10761                 if(U2A->umi == D) dmg = dmg*0.2;
10762                 if(U2A->umi == E) dmg = 0;
10763                 if(U2A->umi == S) dmg = dmg*1.5;
10764                 if(U2A->umi == SS) dmg = dmg*2.0;
10765             }else if(U->C.S_C.typeMOVE == UMI){
10766                 if(U2A->riku == A) dmg = dmg*1.2;
10767                 if(U2A->riku == B) dmg = dmg*1.0;
10768                 if(U2A->riku == C) dmg = dmg*0.6;
10769                 if(U2A->riku == D) dmg = dmg*0.2;
10770                 if(U2A->riku == E) dmg = 0;
10771                 if(U2A->riku == S) dmg = dmg*1.5;
10772                 if(U2A->riku == SS) dmg = dmg*2.0;
10773
10774             } if(U->C.S_C.typeMOVE == CHU){
10775                 if(U2A->chu == A) dmg = dmg*1.2;
10776                 if(U2A->chu == B) dmg = dmg*1.0;
10777                 if(U2A->chu == C) dmg = dmg*0.6;
10778                 if(U2A->chu == D) dmg = dmg*0.2;
10779                 if(U2A->chu == E) dmg = 0;
10780                 if(U2A->chu == S) dmg = dmg*1.5;
10781                 if(U2A->chu == SS) dmg = dmg*2.0;
10782             } if(U->C.S_C.typeMOVE == SORA){
10783                 if(U2A->sora == A) dmg = dmg*1.2;
10784                 if(U2A->sora == B) dmg = dmg*1.0;
10785                 if(U2A->sora == C) dmg = dmg*0.6;
10786                 if(U2A->sora == D) dmg = dmg*0.2;
10787                 if(U2A->sora == E) dmg = 0;
10788                 if(U2A->sora == S) dmg = dmg*1.5;
10789                 if(U2A->sora == SS) dmg = dmg*2.0;
10790             }
10791
10792             NSLog(@"ユニットの地形適用後:%g", dmg);
10793             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10794             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10795
10796             grazeFlag = false;
10797             omfg = rand()%100;
10798             if(graze > omfg && !healFlag) {dmg = dmg/5;
10799                 grazeFlag = true;
10800             }
10801             if(battleDef2Flag) dmg -= dmg*0.5;
10802             battleDef2Flag = false;
10803             dmg = floor(dmg);
10804             if(dmg < 0) dmg = 0;
10805             U->C.S_C.HP -= dmg;
10806             U->C.S_C.vigor++;
10807
10808         }else if(U2A->D->sort == 1){
10809             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10810             dmg = floor(dmg);
10811
10812             U->CL.S_C.HP += dmg;
10813
10814             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10815             healFlag = true;
10816         }
10817
10818         while(1){
10819             if(U->C.S_C.HP <= 0) {
10820                 U->C.S_C.HP = 0;
10821                 U2->C.S_C.vigor += 5;
10822
10823                 messageProcess = 2;
10824                 if(U->dead) break;
10825                 U->dead = true;
10826
10827
10828                 if(U->targType1L)
10829                     targType1cnt[0]--;
10830                 if(U->targType2L) {
10831                     targType2cnt[0]--;
10832                     targType2Lflag = true;
10833                 }
10834
10835                 if(U->targType1D)
10836                     targType1cnt[1]--;
10837                 if(U->targType2D) {
10838                     targType2cnt[1]--;
10839                     targType2Dflag = true;
10840                 }
10841
10842                 break;
10843             }
10844             break;
10845         }
10846
10847         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
10848         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
10849
10850         if(![U2A->msg isEqualToString:@""]){
10851
10852             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10853                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
10854
10855         }
10856
10857         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10858         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
10859         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
10860     }else if(battleDef1Flag){
10861
10862
10863         U = UTop;
10864         while (!(AUN[1] == U->number)) {
10865             U = U->next;
10866         }
10867
10868
10869         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10870
10871
10872     }else if(battleDod1Flag){
10873
10874         U = UTop;
10875         while (!(AUN[1] == U->number)) {
10876             U = U->next;
10877         }
10878
10879         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10880
10881
10882     }else{
10883
10884         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
10885
10886     }
10887     [battleDialog setStringValue:message];
10888
10889
10890     U = UTop;
10891
10892     bLoopFlag = true;
10893
10894     if(healFlag) {
10895         messageProcess++;
10896     };
10897     messageProcess++;
10898
10899     return;
10900
10901
10902 }
10903
10904 -(void)DisplayMessageMod2B{
10905
10906     double def2 = (double)31/32;
10907     NSString *message = @"";
10908
10909     enum{
10910         RIKU,
10911         UMI,
10912         CHU,
10913         SORA,
10914     };
10915
10916     enum{
10917         A,
10918         B,
10919         C,
10920         D,
10921         E,
10922         S,
10923         SS
10924     };
10925
10926
10927     if(bLoopFlag) return;
10928
10929     U = UTop;
10930     while (!(AUN[1] == U->number)) {
10931         U = U->next;
10932     }
10933     U2 = U;
10934     U = UTop;
10935
10936     U = UTop;
10937     while (!(DUN[1] == U->number)) {
10938         U = U->next;
10939     }
10940
10941     ATTACK *aTop2 = U->C.A;
10942     int mostDmg = 0;
10943     int mostNum = -1;
10944     int num = 0;
10945     int mpCost =0;
10946     if(U->C.A) {
10947         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
10948         costVIG = U->C.A->vigor;
10949         }
10950     while(U->C.A){
10951         costVIG = U->C.A->vigor;
10952
10953         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
10954         if(U->C.A->D)
10955         if(mostDmg < U->C.A->totalD && U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && U->C.A->D->sort != 1 && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->C.A opponent:U2]){
10956             mostDmg = U->C.A->totalD;
10957             mostNum = num;
10958         }
10959         U->C.A = U->C.A->next;
10960         num++;
10961     }
10962
10963     U->C.A = aTop2;
10964
10965     if(!battleSet2PushedFlag){
10966         for(int i = 0;i < mostNumSub;i++){
10967             U->C.A = U->C.A->next;
10968         }
10969
10970         if(mostNum < 0) U->C.A = NULL;
10971     }else{
10972         for(int i = 0;i < crCAL2;i++){
10973             U->C.A = U->C.A->next;
10974         }
10975     }
10976     if(U->C.A){
10977         if(U->C.A->D){
10978     if(U->C.A->rangeA <= U2->atkRange && U->C.A->rangeB >= U2->atkRange && U->C.A->D->sort != 1 && ![self sortEcheck:U->C.A opponent:U2]){
10979     }else while(U->CL.A){
10980         U->C.A = U->C.A->next;
10981     }}
10982     }
10983     if(!U->C.A){
10984         U->C.A = aTop2;
10985         U = UTop;
10986         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10987         goto SKIP1;
10988     }
10989     if(!U->C.A->name){
10990         U->C.A = aTop2;
10991         U = UTop;
10992         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10993         goto SKIP1;
10994     }
10995
10996     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
10997
10998
10999     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
11000         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11001
11002         NSString *path = @"data/AttackList/ALdata";
11003
11004         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11005
11006         path = [path stringByAppendingFormat:@"/"];
11007
11008         path = [path stringByAppendingString:U->C.A->AN.movName];
11009
11010
11011         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11012
11013         if(AVpreview) {
11014             AVPV.player = [AVpreview retain];
11015         }else{
11016             goto avAWESOME2B;
11017         }
11018
11019         [AVPV setControlsStyle:0];
11020         [AVPV setHidden:NO];
11021         [AVpreview play];
11022         [battleDialog setStringValue:message];
11023
11024         avPlayerFlag2 = true;
11025
11026         U->C.A = aTop2;
11027         U = UTop;
11028         return;
11029     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
11030
11031
11032         animationFlag2 = true;
11033         aniFrameCnt = 0;
11034         return;
11035     }
11036
11037
11038 avAWESOME2B:{}
11039
11040
11041     /*
11042     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11043     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11044     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11045     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11046     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11047     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11048     */
11049
11050     double urSupposedToGet;
11051
11052     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11053
11054     double oopsIsRight;
11055     bool lolFlag = false;
11056     if(U->C.A) {
11057     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11058     else oopsIsRight = U->C.S_C.MIS;
11059
11060         if(U->C.A->D){
11061     if(U->C.A->D->type == 0) dmg = (U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11062     if(U->C.A->D->type == 1) dmg = (U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11063     if(U->C.A->D->type == 2) dmg = (U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11064     if(U->C.A->D->type == 3) dmg = (U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11065     if(U->C.A->D->type == 4) {
11066         lolFlag = true;
11067         dmg = (U->C.S_C.CAP + urSupposedToGet)*oopsIsRight/100;
11068     }
11069     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11070         }}
11071         costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11072     U->C.S_C.MP -= costMP;
11073
11074     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11075     hitFix = U->C.A->hitPercent;
11076
11077     U2A = U->C.A;
11078     U->C.A = aTop2;
11079
11080     U = UTop;
11081     while (!(AUN[1] == U->number)) {
11082         U = U->next;
11083     }
11084
11085     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
11086     if(hit > 100) hit = 100;
11087
11088     if([self sortEcheck:U2A opponent:U])
11089         hit = 0;
11090
11091     battleDod1Flag = false;
11092
11093     int omg = 100;
11094     if(battleDod1Flag) omg = 50;
11095
11096     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11097         NSLog(@"修正前のダメージ:%g, %g", dmg, U2A->D->seed);
11098
11099         dmg = [self dmgResist:dmg];
11100         NSLog(@"属性後のダメージ:%g", dmg);
11101         def2 = pow(def2, U->CL.S_C.ARM);
11102         int omfg = rand()%100;
11103         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
11104         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11105         if(lolFlag) dmg = (dmg*omfg/100/10 + dmg);
11106         else dmg = (dmg*omfg/100/10+ dmg - U->CL.S_C.ARM);
11107
11108
11109         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11110         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11111         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11112
11113         if(U->CL.S_C.typeMOVE == RIKU){
11114             if(U2A->riku == A) dmg = dmg*1.2;
11115             if(U2A->riku == B) dmg = dmg*1.0;
11116             if(U2A->riku == C) dmg = dmg*0.6;
11117             if(U2A->riku == D) dmg = dmg*0.2;
11118             if(U2A->riku == E) dmg = 0;
11119             if(U2A->riku == S) dmg = dmg*1.5;
11120             if(U2A->riku == SS) dmg = dmg*2.0;
11121         } if(U->CL.S_C.typeMOVE == UMI &&
11122              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11123             if(U2A->umi == A) dmg = dmg*1.2;
11124             if(U2A->umi == B) dmg = dmg*1.0;
11125             if(U2A->umi == C) dmg = dmg*0.6;
11126             if(U2A->umi == D) dmg = dmg*0.2;
11127             if(U2A->umi == E) dmg = 0;
11128             if(U2A->umi == S) dmg = dmg*1.5;
11129             if(U2A->umi == SS) dmg = dmg*2.0;
11130         }else if(U->CL.S_C.typeMOVE == UMI){
11131             if(U2A->riku == A) dmg = dmg*1.2;
11132             if(U2A->riku == B) dmg = dmg*1.0;
11133             if(U2A->riku == C) dmg = dmg*0.6;
11134             if(U2A->riku == D) dmg = dmg*0.2;
11135             if(U2A->riku == E) dmg = 0;
11136             if(U2A->riku == S) dmg = dmg*1.5;
11137             if(U2A->riku == SS) dmg = dmg*2.0;
11138
11139         } if(U->CL.S_C.typeMOVE == CHU){
11140             if(U2A->chu == A) dmg = dmg*1.2;
11141             if(U2A->chu == B) dmg = dmg*1.0;
11142             if(U2A->chu == C) dmg = dmg*0.6;
11143             if(U2A->chu == D) dmg = dmg*0.2;
11144             if(U2A->chu == E) dmg = 0;
11145             if(U2A->chu == S) dmg = dmg*1.5;
11146             if(U2A->chu == SS) dmg = dmg*2.0;
11147         } if(U->CL.S_C.typeMOVE == SORA){
11148             if(U2A->sora == A) dmg = dmg*1.2;
11149             if(U2A->sora == B) dmg = dmg*1.0;
11150             if(U2A->sora == C) dmg = dmg*0.6;
11151             if(U2A->sora == D) dmg = dmg*0.2;
11152             if(U2A->sora == E) dmg = 0;
11153             if(U2A->sora == S) dmg = dmg*1.5;
11154             if(U2A->sora == SS) dmg = dmg*2.0;
11155         }
11156
11157         NSLog(@"ユニットの地形適用後:%g", dmg);
11158
11159         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11160
11161         grazeFlag = false;
11162         omfg = rand()&100;
11163         if(graze > omfg && !healFlag) {dmg = dmg/5;
11164             grazeFlag = true;
11165         }
11166
11167         if(battleDef1Flag) dmg -= dmg*0.5;
11168         battleDef1Flag = false;
11169         dmg = floor(dmg);
11170         if(dmg < 0) dmg = 0;
11171         U->CL.S_C.HP -= dmg;
11172         U->C.S_C.vigor++;
11173
11174         while(1){
11175             if(U->CL.S_C.HP <= 0) {
11176                 U->CL.S_C.HP = 0;
11177                 U2->C.S_C.vigor += 5;
11178
11179                 messageProcess = 2;
11180                 if(U->dead) break;
11181                 U->dead = true;
11182
11183
11184                 if(U->targType1L)
11185                     targType1cnt[0]--;
11186                 if(U->targType2L) {
11187                     targType2cnt[0]--;
11188                     targType2Lflag = true;
11189                 }
11190
11191                 if(U->targType1D)
11192                     targType1cnt[1]--;
11193                 if(U->targType2D) {
11194                     targType2cnt[1]--;
11195                     targType2Dflag = true;
11196                 }
11197
11198                 break;
11199             }
11200             break;
11201         }
11202
11203
11204
11205         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11206
11207         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11208
11209         if(![U2A->msg isEqualToString:@""]){
11210             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11211                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11212         }
11213
11214
11215
11216         if(grazeFlag)
11217             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11218
11219         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11220
11221     }else if(battleDef2Flag){
11222
11223
11224         U = UTop;
11225         while (!(DUN[1] == U->number)) {
11226             U = U->next;
11227         }
11228
11229
11230         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11231
11232
11233     }else if(battleDod2Flag){
11234
11235         U = UTop;
11236         while (!(DUN[1] == U->number)) {
11237             U = U->next;
11238         }
11239
11240         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11241
11242
11243     }else{
11244
11245         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11246     }
11247 SKIP1:
11248     [battleDialog setStringValue:message];
11249
11250     U = UTop;
11251     bLoopFlag = true;
11252     messageProcess++;
11253     return;
11254
11255
11256 }
11257
11258 -(void)DisplayMessageMod3A{//防御側モビール
11259
11260     double def2 = (double)31/32;
11261     NSString *message = @"";
11262
11263     enum{
11264         RIKU,
11265         UMI,
11266         CHU,
11267         SORA,
11268     };
11269
11270     enum{
11271         A,
11272         B,
11273         C,
11274         D,
11275         E,
11276         S,
11277         SS
11278     };
11279
11280     static bool extentbool3 = false;
11281     static bool extentbool4 = false;
11282     if(!extentbool3 && extentBattleFlag2){
11283         extentbool3 = true;
11284         extentMPcostFlag = false;
11285         DUNnum = 1;
11286     }
11287     if(!extentBattleFlag2){
11288         DUNnum = 1;
11289     }
11290
11291     if(bLoopFlag) return;
11292     U = UTop;
11293     U = UTop;
11294     while (!(DUN[DUNnum] == U->number)) {
11295         U = U->next;
11296     }
11297     U2 = U;
11298
11299     U = UTop;
11300     while (!(AUN[1] == U->number)) {
11301         U = U->next;
11302     }
11303
11304     ATTACK *aTop = U->C.A;
11305     for(int i = 0;i < crCAL1;i++){
11306         U->C.A = U->C.A->next;
11307     }
11308
11309
11310     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
11311
11312
11313     [bplayer2 setImage:U2->CL.imgb];
11314     //[bplayer2 setImageScaling:NSScaleToFit];
11315     [nplayer2 setStringValue:U2->CL.name];
11316     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->CL.S_C.HP, U2->CL.S_M.HP]];
11317     [lplayer2 setIntValue:U2->CL.S_C.HP/U2->CL.S_M.HP*100];
11318     [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
11319     [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
11320     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
11321
11322     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL && DUN[DUNnum] == 1){
11323         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11324
11325         NSString *path = @"data/AttackList/ALdata";
11326
11327         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11328
11329         path = [path stringByAppendingFormat:@"/"];
11330
11331         path = [path stringByAppendingString:U->C.A->AN.movName];
11332
11333         NSData *AVData = [NSData dataWithContentsOfFile:path];
11334
11335         if(AVData)
11336             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11337
11338
11339         if(!AVpreview){
11340
11341             NSString *path = @"data/AttackList3/IALdata";
11342
11343             path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
11344
11345             path = [path stringByAppendingFormat:@"/"];
11346
11347             path = [path stringByAppendingString:U->C.A->AN.movName];
11348
11349
11350             NSData *AVData = [NSData dataWithContentsOfFile:path];
11351
11352             if(AVData)
11353                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11354
11355
11356         }
11357
11358         if(AVpreview) {
11359             AVPV.player = [AVpreview retain];
11360         }else{
11361             goto avAWESOME3A;
11362         }
11363
11364
11365         [AVPV setHidden:NO];
11366         [AVpreview play];
11367         [battleDialog setStringValue:message];
11368
11369         avPlayerFlag1 = true;
11370
11371
11372         U->C.A = aTop;
11373         U = UTop;
11374         return;
11375     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUN[DUNnum] == 1){
11376
11377         [battleDialog setStringValue:message];
11378         animationFlag1 = true;
11379         aniFrameCnt = 0;
11380         return;
11381     }
11382
11383 avAWESOME3A:{}
11384
11385     /*
11386     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11387     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11388     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11389     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11390     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11391     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11392     */
11393
11394     double urSupposedToGet;
11395
11396     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11397
11398     double oopsIsRight;
11399
11400     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11401     else oopsIsRight = U->C.S_C.MIS;
11402     bool lolflag = false;
11403     if(U->C.A->D){
11404     if(U->C.A->D->type == 0) dmg = (U->C.S_C.ATK*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11405     if(U->C.A->D->type == 1) dmg = (U->C.S_C.DEF*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11406     if(U->C.A->D->type == 2) dmg = (U->C.S_C.ACU*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11407     if(U->C.A->D->type == 3) dmg = (U->C.S_C.EVA*U->C.S_C.HP/U->C.S_M.HP + urSupposedToGet)*oopsIsRight/100;
11408
11409     if(U->C.A->D->type == 4){
11410         lolflag = true;
11411         dmg = (U->C.S_C.CAP + U->C.A->totalD)*oopsIsRight/100;
11412
11413     }
11414     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11415     double val2 = log(3+U2->C.S_C.MP/64);
11416         if(U->C.aura){
11417             dmg = dmg*val2;
11418         }
11419     }
11420     costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11421
11422     if(extentMPcostFlag && extentBattleFlag2){
11423
11424     }else{
11425         U->C.S_C.MP -= costMP;
11426         extentMPcostFlag = true;
11427     }
11428
11429     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11430     hitFix = U->C.A->hitPercent;
11431
11432     U2A = U->C.A;
11433     U->C.A = aTop;
11434
11435     U = UTop;
11436     while (!(DUN[DUNnum] == U->number)) {
11437         U = U->next;
11438     }
11439     hit = 60 + hit/(U->CL.S_C.MOB*U->C.S_C.DOD/100)*10 - (U->CL.S_C.MOB*U->C.S_C.DOD/100)/hit*10 + hitFix;
11440     if(hit > 100) hit = 100;
11441     if(U2A->D->sort == 1){
11442         hit = 100;
11443     }
11444     if([self sortEcheck:U2A opponent:U])
11445         hit = 0;
11446
11447     healFlag = false;
11448
11449     int wtf = 100;
11450     if(battleDod2Flag) wtf = 50;
11451     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
11452
11453         if(U2A->D->sort == 0){
11454             NSLog(@"修正前のダメージ:%g", dmg);
11455             dmg = [self dmgResist:dmg];
11456             NSLog(@"属性後のダメージ:%g", dmg);
11457             def2 = pow(def2, U->CL.S_C.ARM);
11458             int omfg = rand()%100;
11459             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, (U->CL.S_C.ARM));
11460             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11461             if(lolflag) dmg = (dmg*omfg/100/10 + dmg);
11462             else dmg = (dmg*omfg/100/10 + dmg - U->CL.S_C.ARM);
11463             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11464             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11465             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11466
11467             if(U->CL.S_C.typeMOVE == RIKU){
11468                 if(U2A->riku == A) dmg = dmg*1.2;
11469                 if(U2A->riku == B) dmg = dmg*1.0;
11470                 if(U2A->riku == C) dmg = dmg*0.6;
11471                 if(U2A->riku == D) dmg = dmg*0.2;
11472                 if(U2A->riku == E) dmg = 0;
11473                 if(U2A->riku == S) dmg = dmg*1.5;
11474                 if(U2A->riku == SS) dmg = dmg*2.0;
11475             } if(U->CL.S_C.typeMOVE == UMI &&
11476                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11477                 if(U2A->umi == A) dmg = dmg*1.2;
11478                 if(U2A->umi == B) dmg = dmg*1.0;
11479                 if(U2A->umi == C) dmg = dmg*0.6;
11480                 if(U2A->umi == D) dmg = dmg*0.2;
11481                 if(U2A->umi == E) dmg = 0;
11482                 if(U2A->umi == S) dmg = dmg*1.5;
11483                 if(U2A->umi == SS) dmg = dmg*2.0;
11484             }else if(U->CL.S_C.typeMOVE == UMI){
11485                 if(U2A->riku == A) dmg = dmg*1.2;
11486                 if(U2A->riku == B) dmg = dmg*1.0;
11487                 if(U2A->riku == C) dmg = dmg*0.6;
11488                 if(U2A->riku == D) dmg = dmg*0.2;
11489                 if(U2A->riku == E) dmg = 0;
11490                 if(U2A->riku == S) dmg = dmg*1.5;
11491                 if(U2A->riku == SS) dmg = dmg*2.0;
11492
11493             } if(U->CL.S_C.typeMOVE == CHU){
11494                 if(U2A->chu == A) dmg = dmg*1.2;
11495                 if(U2A->chu == B) dmg = dmg*1.0;
11496                 if(U2A->chu == C) dmg = dmg*0.6;
11497                 if(U2A->chu == D) dmg = dmg*0.2;
11498                 if(U2A->chu == E) dmg = 0;
11499                 if(U2A->chu == S) dmg = dmg*1.5;
11500                 if(U2A->chu == SS) dmg = dmg*2.0;
11501             } if(U->CL.S_C.typeMOVE == SORA){
11502                 if(U2A->sora == A) dmg = dmg*1.2;
11503                 if(U2A->sora == B) dmg = dmg*1.0;
11504                 if(U2A->sora == C) dmg = dmg*0.6;
11505                 if(U2A->sora == D) dmg = dmg*0.2;
11506                 if(U2A->sora == E) dmg = 0;
11507                 if(U2A->sora == S) dmg = dmg*1.5;
11508                 if(U2A->sora == SS) dmg = dmg*2.0;
11509             }
11510
11511             NSLog(@"ユニットの地形適用後:%g", dmg);
11512             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
11513             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11514
11515             grazeFlag = false;
11516             omfg = rand()%100;
11517             if(graze > omfg && !healFlag) {dmg = dmg/5;
11518                 grazeFlag = true;
11519             }
11520             if(battleDef2Flag) dmg -= dmg*0.5;
11521             battleDef2Flag = false;
11522             dmg = floor(dmg);
11523             if(dmg < 0) dmg = 0;
11524             U->CL.S_C.HP -= dmg;
11525             U->C.S_C.vigor++;
11526
11527         }else if(U2A->D->sort == 1){
11528             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
11529             dmg = floor(dmg);
11530
11531             U->C.S_C.HP += dmg;
11532             if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
11533             healFlag = true;
11534         }
11535
11536         while(1){
11537             if(U->CL.S_C.HP <= 0) {
11538                 U->CL.S_C.HP = 0;
11539                 U2->C.S_C.vigor += 5;
11540
11541                 messageProcess = 2;
11542                 if(U->dead) break;
11543                 U->dead = true;
11544
11545
11546                 if(U->targType1L)
11547                     targType1cnt[0]--;
11548                 if(U->targType2L) {
11549                     targType2cnt[0]--;
11550                     targType2Lflag = true;
11551                 }
11552
11553                 if(U->targType1D)
11554                     targType1cnt[1]--;
11555                 if(U->targType2D) {
11556                     targType2cnt[1]--;
11557                     targType2Dflag = true;
11558                 }
11559
11560                 break;
11561             }
11562             break;
11563         }
11564
11565         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11566         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11567
11568         if(![U2A->msg isEqualToString:@""]){
11569
11570             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11571                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11572
11573         }
11574
11575         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11576         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11577         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
11578     }else if(battleDef1Flag){
11579
11580
11581         U = UTop;
11582         while (!(AUN[1] == U->number)) {
11583             U = U->next;
11584         }
11585
11586
11587         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11588
11589
11590     }else if(battleDod1Flag){
11591
11592         U = UTop;
11593         while (!(AUN[1] == U->number)) {
11594             U = U->next;
11595         }
11596
11597         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11598
11599
11600     }else{
11601
11602         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11603
11604     }
11605     [battleDialog setStringValue:message];
11606
11607
11608     U = UTop;
11609
11610     bLoopFlag = true;
11611
11612     if(!extentBattleFlag2){
11613         if(healFlag) {
11614             messageProcess++;
11615         };
11616         messageProcess++;
11617     }else if(extentBattleFlag2){
11618         DUNnum++;
11619         messageProcess = 1;
11620         if(DUN[DUNnum] <= 0){
11621             DUNnum = 1;
11622             messageProcess++;
11623             messageProcess++;
11624             extentBattleFlag2 = false;
11625             extentbool3 = false;
11626             extentMPcostFlag = false;
11627         }
11628     }
11629     return;
11630
11631 }
11632
11633 -(void)DisplayMessageMod3B{
11634
11635
11636     double def2 = (double)31/32;
11637     NSString *message = @"";
11638
11639     enum{
11640         RIKU,
11641         UMI,
11642         CHU,
11643         SORA,
11644     };
11645
11646     enum{
11647         A,
11648         B,
11649         C,
11650         D,
11651         E,
11652         S,
11653         SS
11654     };
11655
11656
11657     if(bLoopFlag) return;
11658     U = UTop;
11659
11660     U = UTop;
11661     while (!(AUN[1] == U->number)) {
11662         U = U->next;
11663     }
11664     U2 = U;
11665
11666     U = UTop;
11667     while (!(DUN[1] == U->number)) {
11668         U = U->next;
11669     }
11670     ATTACK *aTop2 = U->CL.A;
11671     int mostDmg = 0;
11672     int mostNum = -1;
11673     int num = 0;
11674     int mpCost =0;
11675     if(U->CL.A) {
11676         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11677         costVIG = U->C.A->vigor;
11678     }
11679     while(U->CL.A){
11680         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11681         if(mostDmg < U->CL.A->totalD && U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && U->CL.A->D->sort != 1 && mpCost <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor && ![self sortEcheck:U->CL.A opponent:U2]){
11682             mostDmg = U->CL.A->totalD;
11683             mostNum = num;
11684         }
11685         U->CL.A = U->CL.A->next;
11686         num++;
11687     }
11688
11689     if(mostNum < 0) U->C.A = NULL;
11690
11691     U->CL.A = aTop2;
11692
11693     if(!battleSet2PushedFlag){
11694         for(int i = 0;i < mostNumSub;i++){
11695             U->CL.A = U->CL.A->next;
11696         }
11697
11698
11699     }else{
11700         for(int i = 0;i < crCAL2;i++){
11701             U->CL.A = U->C.A->next;
11702         }
11703     }
11704
11705     if(U->CL.A->rangeA <= U2->atkRange && U->CL.A->rangeB >= U2->atkRange && U->CL.A->D->sort != 1 && ![self sortEcheck:U->CL.A opponent:U2]){
11706     }else while(U->CL.A){
11707         U->CL.A = U->CL.A->next;
11708     }
11709
11710     if(!U->CL.A){
11711         U->CL.A = aTop2;
11712         U = UTop;
11713
11714         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11715         goto SKIP1;
11716     }
11717
11718     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
11719
11720     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
11721         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11722
11723         NSString *path = @"data/AttackList/ALdata";
11724
11725         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11726
11727         path = [path stringByAppendingFormat:@"/"];
11728
11729         path = [path stringByAppendingString:U->CL.A->AN.movName];
11730
11731
11732         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11733
11734         if(AVpreview) {
11735             AVPV.player = [AVpreview retain];
11736         }else{
11737             goto avAWESOME3B;
11738         }
11739
11740         [AVPV setControlsStyle:0];
11741         [AVPV setHidden:NO];
11742         [AVpreview play];
11743         [battleDialog setStringValue:message];
11744
11745         avPlayerFlag2 = true;
11746
11747         U->CL.A = aTop2;
11748         U = UTop;
11749         return;
11750     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
11751
11752
11753         animationFlag2 = true;
11754         aniFrameCnt = 0;
11755         return;
11756     }
11757
11758
11759 avAWESOME3B:{}
11760
11761
11762
11763     dmg = U->CL.A->totalD;
11764
11765     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11766     U->CL.S_C.EN -= costMP;
11767
11768     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
11769     hitFix = U->CL.A->hitPercent;
11770
11771     U2A = U->CL.A;
11772     U->CL.A = aTop2;
11773
11774     U = UTop;
11775     while (!(AUN[1] == U->number)) {
11776         U = U->next;
11777     }
11778
11779     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
11780
11781     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
11782     if(hi < 0) hi = 0;
11783
11784     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
11785     if(hit > 100) hit = 100;
11786
11787     if([self sortEcheck:U2A opponent:U])
11788         hit = 0;
11789
11790     battleDod1Flag = false;
11791
11792     int omg = 100;
11793     if(battleDod1Flag) omg = 50;
11794
11795     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11796         NSLog(@"修正前のダメージ:%g", dmg);
11797         dmg = [self dmgResist:dmg];
11798         NSLog(@"属性後のダメージ:%g", dmg);
11799         def2 = pow(def2, U->C.S_C.DEF);
11800         int omfg = rand()%100;
11801         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
11802         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
11803         dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
11804
11805
11806         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11807         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11808         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11809
11810         if(U->C.S_C.typeMOVE == RIKU){
11811             if(U2A->riku == A) dmg = dmg*1.2;
11812             if(U2A->riku == B) dmg = dmg*1.0;
11813             if(U2A->riku == C) dmg = dmg*0.6;
11814             if(U2A->riku == D) dmg = dmg*0.2;
11815             if(U2A->riku == E) dmg = 0;
11816             if(U2A->riku == S) dmg = dmg*1.5;
11817             if(U2A->riku == SS) dmg = dmg*2.0;
11818         } if(U->C.S_C.typeMOVE == UMI &&
11819              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11820             if(U2A->umi == A) dmg = dmg*1.2;
11821             if(U2A->umi == B) dmg = dmg*1.0;
11822             if(U2A->umi == C) dmg = dmg*0.6;
11823             if(U2A->umi == D) dmg = dmg*0.2;
11824             if(U2A->umi == E) dmg = 0;
11825             if(U2A->umi == S) dmg = dmg*1.5;
11826             if(U2A->umi == SS) dmg = dmg*2.0;
11827         }else if(U->C.S_C.typeMOVE == UMI){
11828             if(U2A->riku == A) dmg = dmg*1.2;
11829             if(U2A->riku == B) dmg = dmg*1.0;
11830             if(U2A->riku == C) dmg = dmg*0.6;
11831             if(U2A->riku == D) dmg = dmg*0.2;
11832             if(U2A->riku == E) dmg = 0;
11833             if(U2A->riku == S) dmg = dmg*1.5;
11834             if(U2A->riku == SS) dmg = dmg*2.0;
11835
11836         } if(U->C.S_C.typeMOVE == CHU){
11837             if(U2A->chu == A) dmg = dmg*1.2;
11838             if(U2A->chu == B) dmg = dmg*1.0;
11839             if(U2A->chu == C) dmg = dmg*0.6;
11840             if(U2A->chu == D) dmg = dmg*0.2;
11841             if(U2A->chu == E) dmg = 0;
11842             if(U2A->chu == S) dmg = dmg*1.5;
11843             if(U2A->chu == SS) dmg = dmg*2.0;
11844         } if(U->C.S_C.typeMOVE == SORA){
11845             if(U2A->sora == A) dmg = dmg*1.2;
11846             if(U2A->sora == B) dmg = dmg*1.0;
11847             if(U2A->sora == C) dmg = dmg*0.6;
11848             if(U2A->sora == D) dmg = dmg*0.2;
11849             if(U2A->sora == E) dmg = 0;
11850             if(U2A->sora == S) dmg = dmg*1.5;
11851             if(U2A->sora == SS) dmg = dmg*2.0;
11852         }
11853
11854         NSLog(@"ユニットの地形適用後:%g", dmg);
11855
11856         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11857
11858         grazeFlag = false;
11859         omfg = rand()&100;
11860         if(graze > omfg && !healFlag) {dmg = dmg/5;
11861             grazeFlag = true;
11862         }
11863
11864         if(battleDef1Flag) dmg -= dmg*0.5;
11865         battleDef1Flag = false;
11866         dmg = floor(dmg);
11867         if(dmg < 0) dmg = 0;
11868         U->C.S_C.HP -= dmg;
11869         U->C.S_C.vigor++;
11870
11871         while(1){
11872             if(U->C.S_C.HP <= 0) {
11873                 U->C.S_C.HP = 0;
11874                 U2->C.S_C.vigor += 5;
11875
11876                 messageProcess = 2;
11877                 if(U->dead) break;
11878                 U->dead = true;
11879
11880
11881                 if(U->targType1L)
11882                     targType1cnt[0]--;
11883                 if(U->targType2L) {
11884                     targType2cnt[0]--;
11885                     targType2Lflag = true;
11886                 }
11887
11888                 if(U->targType1D)
11889                     targType1cnt[1]--;
11890                 if(U->targType2D) {
11891                     targType2cnt[1]--;
11892                     targType2Dflag = true;
11893                 }
11894
11895                 break;
11896             }
11897             break;
11898         }
11899
11900
11901
11902         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
11903
11904         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
11905
11906         if(![U2A->msg isEqualToString:@""]){
11907             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11908                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
11909         }
11910
11911
11912
11913         if(grazeFlag)
11914             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11915
11916         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
11917
11918     }else if(battleDef2Flag){
11919
11920
11921         U = UTop;
11922         while (!(DUN[1] == U->number)) {
11923             U = U->next;
11924         }
11925
11926
11927         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
11928
11929
11930     }else if(battleDod2Flag){
11931
11932         U = UTop;
11933         while (!(DUN[1] == U->number)) {
11934             U = U->next;
11935         }
11936
11937         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
11938
11939
11940     }else{
11941
11942         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
11943     }
11944 SKIP1:
11945     [battleDialog setStringValue:message];
11946
11947     U = UTop;
11948     bLoopFlag = true;
11949     messageProcess++;
11950     return;
11951
11952 }
11953
11954 -(NSString*)originalMessage:(NSString*)str subj:(NSString*)subj obje:(NSString*)obje{
11955
11956     NSString *string;
11957     NSArray *array;
11958     NSString *result = @"";
11959
11960     string = [str copy];
11961
11962     array = [string componentsSeparatedByString:@"$subj"];
11963
11964     for(int i = 0;i < [array count];i++){
11965         if(i != 0)
11966             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", subj]] retain];
11967
11968         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
11969     }
11970
11971     string = [result copy];
11972
11973     array = [string componentsSeparatedByString:@"$obje"];
11974
11975     result = @"";
11976
11977     for(int i = 0;i < [array count];i++){
11978         if(i != 0)
11979             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", obje]] retain];
11980
11981         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
11982     }
11983
11984     //NSLog(@"%@", result);
11985
11986     return result;
11987 }
11988
11989
11990
11991 -(double)dmgResist:(double)DMG{
11992
11993     int sd[22];
11994
11995     sd[0] = U->C.R_C.blow + U->C.R_F.blow;
11996     sd[1] = U->C.R_C.slash + U->C.R_F.slash;
11997     sd[2] = U->C.R_C.stub + U->C.R_F.stub;
11998     sd[3] = U->C.R_C.arrow + U->C.R_F.arrow;
11999     sd[4] = U->C.R_C.gun + U->C.R_F.gun;
12000     sd[5] = U->C.R_C.shell + U->C.R_F.shell;
12001
12002     sd[6] = U->C.R_C.flame + U->C.R_F.flame;
12003     sd[7] = U->C.R_C.cold + U->C.R_F.cold;
12004     sd[8] = U->C.R_C.electoric + U->C.R_F.electoric;
12005     sd[9] = U->C.R_C.air + U->C.R_F.air;
12006     sd[10] = U->C.R_C.water + U->C.R_F.water;
12007     sd[11] = U->C.R_C.gas + U->C.R_F.gas;
12008     sd[12] = U->C.R_C.holy + U->C.R_F.holy;
12009     sd[13] = U->C.R_C.dark + U->C.R_F.dark;
12010     sd[14] = U->C.R_C.explosion + U->C.R_F.explosion;
12011     sd[15] = U->C.R_C.blood + U->C.R_F.blood;
12012
12013     sd[16] = U->C.R_C.paralysis + U->C.R_F.paralysis;
12014     sd[17] = U->C.R_C.confusion + U->C.R_F.confusion;
12015     sd[18] = U->C.R_C.poison + U->C.R_F.poison;
12016     sd[19] = U->C.R_C.sleep + U->C.R_F.sleep;
12017     sd[20] = U->C.R_C.charm + U->C.R_F.charm;
12018     sd[21] = U->C.R_C.silent + U->C.R_F.silent;
12019
12020
12021
12022     for(int i = 0;i <= 21;i++)
12023         sd[i] &= ~(sd[i] >> 31);
12024
12025     if(U2A->D){
12026
12027     if(U2A->D->seed == 0) DMG = DMG * sd[0]/100;
12028     if(U2A->D->seed == 1) DMG = DMG * sd[1]/100;
12029     if(U2A->D->seed == 2) DMG = DMG * sd[2]/100;
12030     if(U2A->D->seed == 3) DMG = DMG * sd[3]/100;
12031     if(U2A->D->seed == 4) DMG = DMG * sd[4]/100;
12032     if(U2A->D->seed == 5) DMG = DMG * sd[5]/100;
12033
12034     if(U2A->D->seed == 6) DMG = DMG * sd[6]/100;
12035     if(U2A->D->seed == 7) DMG = DMG * sd[7]/100;
12036     if(U2A->D->seed == 8) DMG = DMG * sd[8]/100;
12037     if(U2A->D->seed == 9) DMG = DMG * sd[9]/100;
12038     if(U2A->D->seed == 10) DMG = DMG * sd[10]/100;
12039     if(U2A->D->seed == 11) DMG = DMG * sd[11]/100;
12040     if(U2A->D->seed == 12) DMG = DMG * sd[12]/100;
12041     if(U2A->D->seed == 13) DMG = DMG * sd[13]/100;
12042     if(U2A->D->seed == 14) DMG = DMG * sd[14]/100;
12043     if(U2A->D->seed == 15) DMG = DMG * sd[15]/100;
12044
12045     if(U2A->D->seed == 16) DMG = DMG * sd[16]/100;
12046     if(U2A->D->seed == 17) DMG = DMG * sd[17]/100;
12047     if(U2A->D->seed == 18) DMG = DMG * sd[18]/100;
12048     if(U2A->D->seed == 19) DMG = DMG * sd[19]/100;
12049     if(U2A->D->seed == 20) DMG = DMG * sd[20]/100;
12050     if(U2A->D->seed == 21) DMG = DMG * sd[21]/100;
12051     }
12052     return DMG;
12053 }
12054
12055 -(IBAction)battleStart:(id)sender{
12056     battleSetUp = true;
12057     battleSet1Flag = false;
12058     battleSet2Flag = false;
12059     battleSettingFlag = false;
12060
12061     attackingWait = false;
12062     crapBugFixFlag = true;
12063
12064     [battlePanel close];
12065 }
12066
12067
12068 -(void)battleStartCPU{
12069     battleSetUp = true;
12070     battleSet1Flag = false;
12071     battleSet2Flag = false;
12072     battleSettingFlag = false;
12073
12074     crapBugFixFlag = true;
12075
12076     [battlePanel close];
12077 }
12078
12079 -(IBAction)battleSet1:(id)sender{
12080     battleSetFlag = false;
12081     battleSet1Flag = true;
12082     battleDef1Flag = false;
12083     battleDod1Flag = false;
12084     battleSettingFlag = true;
12085     battleSet2PushedFlag = false;
12086
12087     U = UTop;
12088     while (!(AUN[1] == U->number)) {
12089         U = U->next;
12090     }
12091     if(U->chipNumberL >= 0)
12092     {
12093         U = UTop;
12094         [self initCAttackList2];
12095         [self initCAttackSelect2];
12096     }
12097     else if(U->chipNumber >= 0) {
12098         U = UTop;
12099         [self initCAttackList];
12100         [self initCAttackSelect];
12101     }
12102     U = UTop;
12103
12104     [atkPanel makeKeyAndOrderFront:nil];
12105 }
12106 -(IBAction)battleDef1:(id)sender{
12107     battleDef1Flag = true;
12108     battleSet1Flag = false;
12109     battleDod1Flag = false;
12110 }
12111 -(IBAction)battleDod1:(id)sender{
12112     battleDod1Flag = true;
12113     battleDef1Flag = false;
12114     battleSet1Flag = false;
12115 }
12116 -(IBAction)battleSet2:(id)sender{
12117     battleSetFlag = true;
12118     battleSet2Flag = true;
12119     battleDef2Flag = false;
12120     battleDod2Flag = false;
12121     battleSettingFlag = true;
12122     battleSet2PushedFlag = true;
12123
12124     U = UTop;
12125     while (!(DUN[1] == U->number)) {
12126         U = U->next;
12127     }
12128
12129     if(U->chipNumberL >= 0){
12130         U = UTop;
12131         [self initCAttackList2];
12132         [self initCAttackSelect2];
12133     }
12134     else if(U->chipNumber >= 0) {
12135         U = UTop;
12136         [self initCAttackList];
12137         [self initCAttackSelect];
12138     }
12139     U = UTop;
12140     [atkPanel makeKeyAndOrderFront:nil];
12141 }
12142 -(IBAction)battleDef2:(id)sender{
12143     battleDef2Flag = true;
12144     battleSet2Flag = false;
12145     battleDod2Flag = false;
12146 }
12147 -(IBAction)battleDod2:(id)sender{
12148     battleDod2Flag = true;
12149     battleDef2Flag = false;
12150     battleSet2Flag = false;
12151 }
12152
12153 -(IBAction)battleCancel:(id)sender{
12154     battleFlag = false;
12155     battleSettingFlag = false;
12156
12157     battleSet2PushedFlag = false;
12158     attackingWait = false;
12159
12160     [battlePanel close];
12161 }
12162
12163 -(IBAction)researchCancel:(id)sender{
12164     [researchPanel close];
12165 }
12166
12167 -(void)setCommandPanel{
12168
12169     menuPoint.x = [mapWindow frame].origin.x + possionLocalX*32;
12170     menuPoint.y = [mapWindow frame].origin.y + possionLocalY*32 - 180;
12171
12172
12173     if(buildSkillFlag) {
12174         cIncludeCreateFlag = true;
12175         menuPoint.y -= 20;
12176     }else cIncludeCreateFlag = false;
12177     if(summonSkillFlag) {
12178         cIncludeSummonFlag = true;
12179         menuPoint.y -= 20;
12180     }else cIncludeSummonFlag = false;
12181     int plusBtnValue = 0;
12182
12183     if(cIncludeCreateFlag && cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12184
12185         plusBtnValue = 200;
12186         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12187
12188
12189         plusBtnValue -= moveBtn.frame.size.height + 12;
12190         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12191         [[commandPanel contentView] addSubview:moveBtn];
12192
12193         plusBtnValue -= attackBtn.frame.size.height + 2;
12194         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12195         [[commandPanel contentView] addSubview:attackBtn];
12196
12197         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12198         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12199         [[commandPanel contentView] addSubview:stanbyBtn];
12200
12201         [createBtn setTransparent: NO];
12202         [createBtn setEnabled: YES];
12203         plusBtnValue -= createBtn.frame.size.height + 2;
12204         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12205         [[commandPanel contentView] addSubview:createBtn];
12206
12207         [summonBtn setTransparent: NO];
12208         [summonBtn setEnabled: YES];
12209         plusBtnValue -= summonBtn.frame.size.height + 2;
12210         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12211         [[commandPanel contentView] addSubview:summonBtn];
12212
12213         plusBtnValue -= statusBtn.frame.size.height + 2;
12214         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12215         [[commandPanel contentView] addSubview:statusBtn];
12216
12217         plusBtnValue -= cancelBtn.frame.size.height + 2;
12218         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12219         [[commandPanel contentView] addSubview:cancelBtn];
12220
12221     }
12222     else if(cIncludeCreateFlag && !cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag){
12223         plusBtnValue = 180;
12224         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12225
12226         plusBtnValue -= moveBtn.frame.size.height + 12;
12227         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12228         [[commandPanel contentView] addSubview:moveBtn];
12229
12230         plusBtnValue -= attackBtn.frame.size.height + 2;
12231         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12232         [[commandPanel contentView] addSubview:attackBtn];
12233
12234         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12235         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12236         [[commandPanel contentView] addSubview:stanbyBtn];
12237
12238         [createBtn setTransparent: NO];
12239         [createBtn setEnabled: YES];
12240         plusBtnValue -= createBtn.frame.size.height + 2;
12241         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12242         [[commandPanel contentView] addSubview:createBtn];
12243
12244         [summonBtn setTransparent: YES];
12245         [summonBtn setEnabled: NO];
12246
12247         plusBtnValue -= statusBtn.frame.size.height + 2;
12248         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12249         [[commandPanel contentView] addSubview:statusBtn];
12250
12251         plusBtnValue -= cancelBtn.frame.size.height + 2;
12252         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12253         [[commandPanel contentView] addSubview:cancelBtn];
12254
12255
12256     }else if(cIncludeSummonFlag && !cIncludeCreateFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12257
12258         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, 210) display:YES];
12259
12260         plusBtnValue = 180;
12261         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12262
12263
12264         plusBtnValue -= moveBtn.frame.size.height + 12;
12265         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12266         [[commandPanel contentView] addSubview:moveBtn];
12267
12268         plusBtnValue -= attackBtn.frame.size.height + 2;
12269         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12270         [[commandPanel contentView] addSubview:attackBtn];
12271
12272         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12273         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12274         [[commandPanel contentView] addSubview:stanbyBtn];
12275
12276         [createBtn setTransparent: YES];
12277         [createBtn setEnabled: NO];
12278
12279         [summonBtn setTransparent: NO];
12280         [summonBtn setEnabled: YES];
12281         plusBtnValue -= summonBtn.frame.size.height + 2;
12282         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12283         [[commandPanel contentView] addSubview:summonBtn];
12284
12285         plusBtnValue -= statusBtn.frame.size.height + 2;
12286         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12287         [[commandPanel contentView] addSubview:statusBtn];
12288
12289         plusBtnValue -= cancelBtn.frame.size.height + 2;
12290         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12291         [[commandPanel contentView] addSubview:cancelBtn];
12292     }else{
12293
12294         plusBtnValue = 160;
12295         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12296
12297         plusBtnValue -= moveBtn.frame.size.height + 12;
12298         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12299         [[commandPanel contentView] addSubview:moveBtn];
12300
12301         plusBtnValue -= attackBtn.frame.size.height + 2;
12302         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12303         [[commandPanel contentView] addSubview:attackBtn];
12304
12305         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12306         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12307         [[commandPanel contentView] addSubview:stanbyBtn];
12308
12309         [createBtn setTransparent: YES];
12310         [createBtn setEnabled: NO];
12311
12312         [summonBtn setTransparent: YES];
12313         [summonBtn setEnabled: NO];
12314
12315         plusBtnValue -= statusBtn.frame.size.height + 2;
12316         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12317         [[commandPanel contentView] addSubview:statusBtn];
12318
12319         plusBtnValue -= cancelBtn.frame.size.height + 2;
12320         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12321         [[commandPanel contentView] addSubview:cancelBtn];
12322     }
12323
12324
12325 }
12326
12327 -(void)openMessage{
12328     [IVimage setHidden:NO];
12329     [TFname setHidden:NO];
12330     [TFmessage setHidden:NO];
12331     [BXname setHidden:NO];
12332     [BXmessage setHidden:NO];
12333     [IVimage setEnabled:YES];
12334     [TFname setEnabled:YES];
12335     [TFmessage setEnabled:YES];
12336 }
12337
12338 -(void)closeMessage{
12339     [IVimage setHidden:YES];
12340     [TFname setHidden:YES];
12341     [TFmessage setHidden:YES];
12342     [BXname setHidden:YES];
12343     [BXmessage setHidden:YES];
12344     [IVimage setEnabled:NO];
12345     [TFname setEnabled:NO];
12346     [TFmessage setEnabled:NO];
12347 }
12348
12349 -(MAPSCRIPT0*)setMessage:(MAPSCRIPT0*)MS0{
12350
12351
12352     if(!messageDialog){
12353         [self closeMessage];
12354         damnitFixFlag = true;
12355     }else if(MS0->S1.str){
12356         [self openMessage];
12357         damnitFixFlag = false;
12358     NSString *string = @"";
12359
12360         string = [MS0->S1.str retain];
12361         if(!string){
12362             MS0->endFlag = true;
12363             textInstantBugFixFlag = false;
12364             messageEndFlag = false;
12365             messageDialog = false;
12366             return MS0;
12367         }
12368
12369         if(!initStringNum){
12370             msgLvl = 0;
12371             msgCnt = 0;
12372             initStringNum = true;
12373             textInstantBugFixFlag = true;
12374         }
12375
12376         msgMax = (int)[string length];
12377
12378
12379         if(!initImgFlag)
12380         {
12381             [self loadImg];
12382             initImgFlag = true;
12383         }
12384
12385         [IVimage setImage:MS0->S1.img];
12386         if(MS0->S1.name) [TFname setStringValue:MS0->S1.name];
12387         else [TFname setStringValue:@""];
12388
12389         if(msgCnt <= msgMax){
12390             if(string) {
12391                 [TFmessage setStringValue:[string substringToIndex:msgCnt]];
12392                 msgCnt++;
12393             }
12394             else [TFmessage setStringValue:@""];
12395         }
12396         wtRdy3 = true;
12397
12398
12399         if(messageEndFlag){
12400             MS0->endFlag = true;
12401             messageEndFlag = false;
12402             initStringNum = false;
12403             messageDialog = false;
12404             MS0->succeessfulFlag = true;
12405             wtRdy3 = false;
12406             textInstantBugFixFlag = false;
12407             [self setMessage:NULL];
12408         }
12409
12410         return MS0;
12411     }else{
12412         MS0->endFlag = true;
12413         messageEndFlag = false;
12414         messageDialog = false;
12415         initStringNum = false;
12416     }
12417
12418
12419     return MS0;
12420 }
12421
12422 -(void) loadImg{
12423
12424     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
12425     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
12426
12427     NSString *path = @"Map/";
12428     NSString *fileData = nil;
12429     NSArray *fileDataArray;
12430
12431     path = [path stringByAppendingFormat:@"%@"  ,MF[MFselectedRow+1].fileName];
12432
12433     fileData = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:nil];
12434
12435     fileDataArray = [fileData componentsSeparatedByString:@"\n"];
12436
12437     MAPSCRIPT0 *MS00 = MF[MFselectedRow+1].MS.D->P;
12438     MAPSCRIPT0 *m00Top = MS00;
12439     for (int i = 0; i < [fileDataArray count]; i++) {
12440         if(!MS00) break;
12441         NSRange range = [[fileDataArray objectAtIndex:i] rangeOfString:@"◆"];
12442         if(range.location != NSNotFound){
12443
12444             NSArray *array2 = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
12445             if(MS00->type == 1)
12446             {
12447                 MS00->S1.iName = [[array2 objectAtIndex:2] retain];
12448
12449             for(int k = 0; k < UCN;k++){
12450
12451                 if([MS00->S1.iName isEqualToString:UC[k].nameClass]){
12452                     MS00->S1.img = [UC[k].imgb retain];
12453                     MS00 = MS00->next;
12454                     break;
12455                 }
12456
12457             }
12458             }
12459
12460         }
12461     }
12462
12463     MS00 = m00Top;
12464
12465 }
12466
12467
12468 -(MAPSCRIPT0*)setSwitch:(MAPSCRIPT0*)MS0{
12469
12470     if(MS0->switch1)
12471     for(int i = 0;*(MS0->switch1 + i) >0;i++){
12472         Suicchi[*(MS0->switch1+i)] = true;
12473
12474     }
12475     if(MS0->switch2)
12476     for(int i = 0;*(MS0->switch2 + i) >0;i++){
12477         Suicchi[*(MS0->switch2+i)] = false;
12478
12479     }
12480
12481     MS0->succeessfulFlag = true;
12482     MS0->endFlag = true;
12483     return MS0;
12484 }
12485
12486 -(MAPSCRIPT0*)setBranch:(MAPSCRIPT0*)MS0{
12487
12488     MAPSCRIPT0 *CRMS0 = MS0;
12489     bool branchEndFlag = false;
12490     bool branchSuceedFlag = false;
12491     bool trueFlag = true;
12492
12493
12494     if(MS0->endFlag)
12495         return MS0;
12496
12497     if(!Uselected){
12498         MS0->endFlag = true;
12499         return MS0;
12500     }
12501
12502     if(1){
12503
12504         if(MS0->S4.suicchiFlag){
12505             if(MS0->S4.suicchiONOFF == 0){
12506                 if(MS0->S4.suicchi)
12507                 for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12508                     if(!Suicchi[*(MS0->S4.suicchi + i)]){
12509                         trueFlag = false;
12510                     }
12511                 }
12512             }else{
12513                 if(MS0->S4.suicchi)
12514                     for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12515                         if(Suicchi[*(MS0->S4.suicchi + i)]){
12516                             trueFlag = false;
12517                         }
12518                     }
12519             }
12520         }
12521
12522         if(MS0->S4.hensuFlag){
12523
12524             if(MS0->S4.teisuFlag){
12525                 if(MS0->S4.hensuType == 0){
12526                     if([Hensuu[MS0->S4.hensu1] intValue] == MS0->S4.teisuValue){
12527
12528                     }else{
12529                         trueFlag = false;
12530                     }
12531                 }else if(MS0->S4.hensuType == 1){
12532                     if([Hensuu[MS0->S4.hensu1] intValue] >= MS0->S4.teisuValue){
12533
12534                     }else{
12535                         trueFlag = false;
12536                     }
12537                 }else if(MS0->S4.hensuType == 2){
12538                     if([Hensuu[MS0->S4.hensu1] intValue] <= MS0->S4.teisuValue){
12539
12540                     }else{
12541                         trueFlag = false;
12542                     }
12543                 }else if(MS0->S4.hensuType == 3){
12544                     if([Hensuu[MS0->S4.hensu1] intValue] > MS0->S4.teisuValue){
12545
12546                     }else{
12547                         trueFlag = false;
12548                     }
12549                 }else if(MS0->S4.hensuType == 4){
12550                     if([Hensuu[MS0->S4.hensu1] intValue] < MS0->S4.teisuValue){
12551
12552                     }else{
12553                         trueFlag = false;
12554                     }
12555                 }else if(MS0->S4.hensuType == 5){
12556                     if([Hensuu[MS0->S4.hensu1] intValue] != MS0->S4.teisuValue){
12557
12558                     }else{
12559                         trueFlag = false;
12560                     }
12561                 }
12562
12563             }if(MS0->S4.hensu2flag){
12564                 if(MS0->S4.hensuType == 0){
12565                     if([Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12566
12567                     }else{
12568                         trueFlag = false;
12569                     }
12570                 }else if(MS0->S4.hensuType == 1){
12571                     if([Hensuu[MS0->S4.hensu1] intValue] >= [Hensuu[MS0->S4.hensu2] intValue]){
12572
12573                     }else{
12574                         trueFlag = false;
12575                     }
12576                 }else if(MS0->S4.hensuType == 2){
12577                     if([Hensuu[MS0->S4.hensu1] intValue] <= [Hensuu[MS0->S4.hensu2] intValue]){
12578
12579                     }else{
12580                         trueFlag = false;
12581                     }
12582                 }else if(MS0->S4.hensuType == 3){
12583                     if([Hensuu[MS0->S4.hensu1] intValue] > [Hensuu[MS0->S4.hensu2] intValue]){
12584
12585                     }else{
12586                         trueFlag = false;
12587                     }
12588                 }else if(MS0->S4.hensuType == 4){
12589                     if([Hensuu[MS0->S4.hensu1] intValue] < [Hensuu[MS0->S4.hensu2] intValue]){
12590
12591                     }else{
12592                         trueFlag = false;
12593                     }
12594                 }else if(MS0->S4.hensuType == 5){
12595                     if(![Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12596
12597                     }else{
12598                         trueFlag = false;
12599                     }
12600                 }
12601             }
12602
12603         }
12604         if(MS0->S4.timerFlag){
12605
12606             if(MS0->S4.timerType == 0){
12607                 if(MS0->S4.timerMin <= cntTimerMin){
12608
12609                 }else if(MS0->S4.timerSec <= cntTimerSec && MS0->S4.timerMin <= cntTimerMin){
12610
12611                 }else{
12612                     trueFlag = false;
12613                 }
12614
12615
12616
12617             }else{
12618                 if(MS0->S4.timerMin >= cntTimerMin){
12619
12620                 }else if(MS0->S4.timerSec >= cntTimerSec && MS0->S4.timerMin >= cntTimerMin){
12621
12622                 }else{
12623                     trueFlag = false;
12624                 }
12625
12626             }
12627         }
12628
12629
12630
12631         if(MS0->S4.unitNumFlag){
12632
12633
12634             int Unum = 0;
12635             U = UTop;;
12636             while (U) {
12637                 Unum++;
12638                 U = U->next;
12639             }U = UTop;
12640
12641             int objeSCSunitCnt = 0;
12642
12643             if(MS0->S4.objeFlag){
12644
12645                 UNIT2 *objeT = MS0->S4.obje;
12646
12647                 while (MS0->S4.obje) {
12648
12649
12650
12651                     U = UTop;
12652                     static bool okflag = true;
12653                     while(U){
12654                         for (int i = 0;i < 1002;i++) {
12655                             for (int k = 0;k < 1002;k++) {
12656                                 objeR[i][k] = 0;
12657                             }
12658                         }
12659
12660                         U2 = UTop;
12661                         while(U2){
12662                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
12663                                 break;
12664                             }
12665                             U2 = U2->next;
12666                         }
12667
12668                         if(!U2){
12669                             U2 = UTop;
12670                             break;
12671                         }
12672
12673                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
12674
12675                         int Cnum = 0;
12676
12677                         for(int bx=1;bx<=chipWidth;bx++){
12678                             for(int by=1;by<=chipHeight;by++){
12679                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
12680
12681                                     if(objeR[U->x][U->y] > 0){
12682                                         Cnum++;
12683                                         if(Unum < Cnum) goto omfgUnitOver2;
12684
12685
12686
12687
12688
12689                                         if(UP)
12690                                         {
12691                                             if(!UPT){
12692                                                 UPT = UP;
12693                                             }
12694
12695                                             UP = UPT;
12696                                             while (UP) {
12697                                                 if(UP->x == U->x && UP->y == U->y){
12698
12699                                                     break;
12700                                                 }else{
12701                                                     okflag = true;
12702                                                 }
12703
12704                                                 UP = UP->next;
12705                                             }
12706
12707                                         }
12708                                         UP = UPT;
12709
12710                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
12711                                         else if(UP){
12712                                             while(UP->next) UP = UP->next;
12713                                         }
12714                                         if(okflag){
12715                                             UP->x = U->x;
12716                                             UP->y = U->y;
12717                                             UP->next = calloc(1, sizeof(UNITPOINT));
12718                                             okflag = false;
12719                                             objeSCSunitCnt++;
12720                                         }
12721                                     }
12722
12723                                 }
12724                             }
12725                         }
12726
12727                     omfgUnitOver2:
12728                         UP = NULL;
12729                         UPT = NULL;
12730
12731                         //NSLog(@"%@, %d, %d", U->C.name, objeSCSunitCnt, objeR[0][0]);
12732
12733                         U = U->next;
12734                     }U = UTop;
12735                     okflag = true;
12736                     MS0->S4.obje = MS0->S4.obje->next;
12737                 }
12738                 MS0->S4.obje = objeT;
12739             }
12740
12741
12742             if(MS0->S4.buildFlag){
12743                 if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12744
12745                 }
12746
12747                 if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
12748                    BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
12749                    Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12750
12751                 }
12752             }
12753
12754             int team0num = 0;
12755             int team1num = 0;
12756             int team2num = 0;
12757             if(MS0->S4.team == 0){
12758                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12759                 U = UTop;
12760                 while (U) {
12761                     if(U->team == 0 && !U->dead)
12762                         team0num++;
12763                     U = U->next;
12764                 }U = UTop;
12765                 }
12766                 if(MS0->S4.unitType == 0){
12767                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
12768
12769                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12770
12771                     }else if((MS0->S4.unitNum == team0num) && !MS0->S4.objeFlag){
12772
12773                     }else{
12774                         trueFlag = false;
12775                     }
12776                 }else if(MS0->S4.unitType == 1){
12777                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = 65000;
12778
12779                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12780
12781                     }else if((MS0->S4.unitNum <= team0num) && !MS0->S4.objeFlag){
12782
12783                     }else{
12784                         trueFlag = false;
12785                     }
12786                 }else if(MS0->S4.unitType == 2){
12787                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12788
12789                     }else if((MS0->S4.unitNum >= team0num) && !MS0->S4.objeFlag){
12790
12791                     }else{
12792                         trueFlag = false;
12793                     }
12794                 }
12795
12796
12797             }else if(MS0->S4.team == 1){
12798                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12799                 U = UTop;
12800                 while (U) {
12801                     if(U->team == 1 && !U->dead)
12802                         team1num++;
12803                     U = U->next;
12804                 }U = UTop;
12805                 }
12806                 if(MS0->S4.unitType == 0){
12807                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
12808
12809                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12810
12811                     }else if((MS0->S4.unitNum == team1num) && !MS0->S4.objeFlag){
12812
12813                     }else{
12814                         trueFlag = false;
12815                     }
12816                 }else if(MS0->S4.unitType == 1){
12817                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = 65000;
12818                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12819
12820                     }else if((MS0->S4.unitNum <= team1num) && !MS0->S4.objeFlag){
12821
12822                     }else{
12823                         trueFlag = false;
12824                     }
12825                 }else if(MS0->S4.unitType == 2){
12826
12827                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12828
12829                     }else if((MS0->S4.unitNum >= team1num) && !MS0->S4.objeFlag){
12830
12831                     }else{
12832                         trueFlag = false;
12833                     }
12834                 }
12835             }else if(MS0->S4.team == 2){
12836                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12837                 U = UTop;
12838                 while (U) {
12839                     if(U->team == 2 && !U->dead)
12840                         team2num++;
12841                     U = U->next;
12842                 }U = UTop;
12843                 }
12844                 if(MS0->S4.unitType == 0){
12845                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
12846
12847                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12848
12849                     }else if((MS0->S4.unitNum == team2num) && !MS0->S4.objeFlag){
12850
12851                     }else{
12852                         trueFlag = false;
12853                     }
12854                 }else if(MS0->S4.unitType == 1){
12855                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = 65000;
12856
12857                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12858
12859                     }else if((MS0->S4.unitNum <= team2num) && !MS0->S4.objeFlag){
12860
12861                     }else{
12862                         trueFlag = false;
12863                     }
12864                 }else if(MS0->S4.unitType == 2){
12865                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12866
12867                     }else if((MS0->S4.unitNum >= team2num) && !MS0->S4.objeFlag){
12868
12869                     }else{
12870                         trueFlag = false;
12871                     }
12872                 }
12873             }
12874
12875         }
12876
12877
12878
12879         if(MS0->S4.unitTypeFlag && MS0->S4.unitNumFlag){
12880             UNIT2 *sjt = MS0->S4.subj;
12881             UNIT *chosen = NULL;
12882             UNIT *chosenT = NULL;
12883             int cntUnit = 0;
12884             bool lmao = false;
12885             while(MS0->S4.subj){
12886                 U = UTop;
12887                 while(U){
12888                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
12889                         if(chosen){
12890                             chosen->next = calloc(1, sizeof(UNIT));
12891                             if(!lmao){
12892                                 chosenT = chosen;
12893                                 lmao = true;
12894                             }
12895                             chosen = chosen->next;
12896                         }
12897                         if(!chosen){
12898                             chosen = calloc(1, sizeof(UNIT));
12899                         }
12900                         chosen->x = U->x;
12901                         chosen->y = U->y;
12902                         chosen->C.name = U->C.name;
12903
12904                         if(!U->dead)
12905                             cntUnit++;
12906                     }
12907                     U = U->next;
12908                 }U = UTop;
12909                 if(!lmao){
12910                     chosenT = chosen;
12911                     lmao = true;
12912                 }
12913                 MS0->S4.subj = MS0->S4.subj->next;
12914             }MS0->S4.subj = sjt;
12915             chosen = chosenT;
12916
12917             int objeSCSunitCnt = 0;
12918
12919
12920             int Unum = 0;
12921
12922
12923             while (chosen) {
12924                 Unum++;
12925                 chosen = chosen->next;
12926             }chosen = chosenT;
12927
12928             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
12929
12930                 UNIT2 *objeT = MS0->S4.obje;
12931
12932                 while (MS0->S4.obje) {
12933
12934
12935
12936                     chosen = chosenT;
12937                     static bool okflag = true;
12938                     while(chosen){
12939                         for (int i = 0;i < 1002;i++) {
12940                             for (int k = 0;k < 1002;k++) {
12941                                 objeR[i][k] = 0;
12942                             }
12943                         }
12944
12945                         U2 = UTop;
12946                         while(U2){
12947                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
12948                                 break;
12949                             }
12950                             U2 = U2->next;
12951                         }
12952
12953                         if(!U2){
12954                             U2 = UTop;
12955                             break;
12956                         }
12957
12958
12959                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
12960
12961                         int Cnum = 0;
12962
12963                         for(int bx=1;bx<=chipWidth;bx++){
12964                             for(int by=1;by<=chipHeight;by++){
12965                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
12966
12967                                     if(objeR[chosen->x][chosen->y] > 0){
12968                                         Cnum++;
12969                                         if(Unum < Cnum) goto omfgUnitOver3;
12970
12971
12972
12973
12974
12975                                         if(UP)
12976                                         {
12977                                             if(!UPT){
12978                                                 UPT = UP;
12979                                             }
12980
12981                                             UP = UPT;
12982                                             while (UP) {
12983                                                 if(UP->x == chosen->x && UP->y == chosen->y){
12984
12985                                                     break;
12986                                                 }else{
12987                                                     okflag = true;
12988                                                 }
12989
12990                                                 UP = UP->next;
12991                                             }
12992
12993                                         }
12994                                         UP = UPT;
12995
12996                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
12997                                         else if(UP){
12998                                             while(UP->next) UP = UP->next;
12999                                         }
13000                                         if(okflag){
13001                                             UP->x = chosen->x;
13002                                             UP->y = chosen->y;
13003                                             UP->next = calloc(1, sizeof(UNITPOINT));
13004                                             okflag = false;
13005                                             objeSCSunitCnt++;
13006                                         }
13007                                     }
13008
13009                                 }
13010                             }
13011                         }
13012
13013                     omfgUnitOver3:
13014                         UP = NULL;
13015                         UPT = NULL;
13016
13017                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13018
13019                         chosen = chosen->next;
13020                     }chosen = chosenT;
13021                     okflag = true;
13022                     MS0->S4.obje = MS0->S4.obje->next;
13023                 }
13024                 MS0->S4.obje = objeT;
13025             }else if(MS0->S4.objeFlag){
13026
13027                 UNIT2 *objeT = MS0->S4.obje;
13028
13029                 while (MS0->S4.obje) {
13030
13031
13032
13033                     U = UTop;
13034                     static bool okflag = true;
13035                     while(U){
13036                         if(U->team != MS0->S4.team){
13037                             U = U->next;
13038                             continue;
13039                         }
13040                         for (int i = 0;i < 1002;i++) {
13041                             for (int k = 0;k < 1002;k++) {
13042                                 objeR[i][k] = 0;
13043                             }
13044                         }
13045
13046                         U2 = UTop;
13047                         while(U2){
13048                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13049                                 break;
13050                             }
13051                             U2 = U2->next;
13052                         }
13053
13054                         if(!U2){
13055                             U2 = UTop;
13056                             break;
13057                         }
13058
13059                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
13060
13061                         int Cnum = 0;
13062
13063                         for(int bx=1;bx<=chipWidth;bx++){
13064                             for(int by=1;by<=chipHeight;by++){
13065                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13066
13067                                     if(objeR[chosen->x][chosen->y] > 0){
13068                                         Cnum++;
13069                                         if(Unum < Cnum) goto omfgUnitOver30;
13070
13071
13072
13073
13074
13075                                         if(UP)
13076                                         {
13077                                             if(!UPT){
13078                                                 UPT = UP;
13079                                             }
13080
13081                                             UP = UPT;
13082                                             while (UP) {
13083                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13084
13085                                                     break;
13086                                                 }else{
13087                                                     okflag = true;
13088                                                 }
13089
13090                                                 UP = UP->next;
13091                                             }
13092
13093                                         }
13094                                         UP = UPT;
13095
13096                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13097                                         else if(UP){
13098                                             while(UP->next) UP = UP->next;
13099                                         }
13100                                         if(okflag){
13101                                             UP->x = chosen->x;
13102                                             UP->y = chosen->y;
13103                                             UP->next = calloc(1, sizeof(UNITPOINT));
13104                                             okflag = false;
13105                                             objeSCSunitCnt++;
13106                                         }
13107                                     }
13108
13109                                 }
13110                             }
13111                         }
13112
13113                     omfgUnitOver30:
13114                         UP = NULL;
13115                         UPT = NULL;
13116
13117                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13118
13119                         chosen = chosen->next;
13120                     }chosen = chosenT;
13121                     okflag = true;
13122                     MS0->S4.obje = MS0->S4.obje->next;
13123                 }
13124                 MS0->S4.obje = objeT;
13125                 U = UTop;
13126             }
13127
13128
13129             int team0num = 0;
13130             int team1num = 0;
13131             int team2num = 0;
13132             if(MS0->S4.team == 0){
13133                 if(!MS0->S4.unitTypeFlag){
13134                 U = UTop;
13135                 while (U) {
13136                     if(U->team == 0 && !U->dead)
13137                         team0num++;
13138                     U = U->next;
13139                 }U = UTop;
13140                 }
13141                 if(MS0->S4.unitType == 0){
13142                     if(MS0->S4.unitTypeFlag) team0num = MS0->S4.unitNum;
13143
13144                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit)
13145                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13146
13147                     }else if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13148
13149                     }else{
13150                         trueFlag = false;
13151                     }
13152                 }else if(MS0->S4.unitType == 1){
13153                     if(MS0->S4.unitTypeFlag) team0num = 65000;
13154
13155                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit)
13156                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13157
13158                     }else if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13159
13160                     }else{
13161                         trueFlag = false;
13162                     }
13163                 }else if(MS0->S4.unitType == 2){
13164                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit)
13165                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13166
13167                     }else if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13168
13169                     }else{
13170                         trueFlag = false;
13171                     }
13172                 }
13173
13174
13175             }else if(MS0->S4.team == 1){
13176                 if(!MS0->S4.unitTypeFlag){
13177                 U = UTop;
13178                 while (U) {
13179                     if(U->team == 1 && !U->dead)
13180                         team1num++;
13181                     U = U->next;
13182                 }U = UTop;
13183                 }
13184                 if(MS0->S4.unitType == 0){
13185                     if(MS0->S4.unitTypeFlag) team1num = MS0->S4.unitNum;
13186
13187                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit)
13188                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13189
13190                     }else if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13191
13192                     }else{
13193                         trueFlag = false;
13194                     }
13195                 }else if(MS0->S4.unitType == 1){
13196                     if(MS0->S4.unitTypeFlag) team1num = 65000;
13197
13198                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit)
13199                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13200
13201                     }else if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13202
13203                     }else{
13204                         trueFlag = false;
13205                     }
13206                 }else if(MS0->S4.unitType == 2){
13207                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit)
13208                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13209
13210                     }else if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13211
13212                     }else{
13213                         trueFlag = false;
13214                     }
13215                 }
13216             }else if(MS0->S4.team == 2){
13217                 if(!MS0->S4.unitTypeFlag){
13218                 U = UTop;
13219                 while (U) {
13220                     if(U->team == 2 && !U->dead)
13221                         team2num++;
13222                     U = U->next;
13223                 }U = UTop;
13224                 }
13225                 if(MS0->S4.unitType == 0){
13226                     if(MS0->S4.unitTypeFlag) team2num = MS0->S4.unitNum;
13227
13228                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit)
13229                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13230
13231                     }else if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13232
13233                     }else{
13234                         trueFlag = false;
13235                     }
13236                 }else if(MS0->S4.unitType == 1){
13237                     if(MS0->S4.unitTypeFlag) team2num = 65000;
13238
13239                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit)
13240                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13241
13242                     }else if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13243
13244                     }else{
13245                         trueFlag = false;
13246                     }
13247                 }else if(MS0->S4.unitType == 2){
13248                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit)
13249                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13250
13251                     }else if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13252
13253                     }else{
13254                         trueFlag = false;
13255                     }
13256                 }
13257             }
13258
13259
13260
13261
13262
13263
13264         }
13265
13266
13267
13268
13269         if(MS0->S4.placeFlag && MS0->S4.unitNumFlag){
13270             int Unum = 0;
13271             U = UTop;;
13272             while (U) {
13273                 Unum++;
13274                 U = U->next;
13275             }U = UTop;
13276
13277
13278
13279             UNIT2 *sjt = MS0->S4.subj;
13280             UNIT *chosen = NULL;
13281             UNIT *chosenT = NULL;
13282             int cntUnit = 0;
13283             bool lmao = false;
13284             if(MS0->S4.unitTypeFlag){
13285                 while(MS0->S4.subj){
13286                     U = UTop;
13287                     while(U){
13288                         if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13289                             if(chosen){
13290                                 chosen->next = calloc(1, sizeof(UNIT));
13291                                 if(!lmao){
13292                                     chosenT = chosen;
13293                                     lmao = true;
13294                                 }
13295                                 chosen = chosen->next;
13296                             }
13297                             if(!chosen){
13298                                 chosen = calloc(1, sizeof(UNIT));
13299                             }
13300                             chosen->x = U->x;
13301                             chosen->y = U->y;
13302                             chosen->C.name = U->C.name;
13303
13304                             if(!U->dead)
13305                                 cntUnit++;
13306                         }
13307                         U = U->next;
13308                     }U = UTop;
13309                     if(!lmao){
13310                         chosenT = chosen;
13311                         lmao = true;
13312                     }
13313                     MS0->S4.subj = MS0->S4.subj->next;
13314                 }MS0->S4.subj = sjt;
13315                 chosen = chosenT;
13316
13317
13318
13319                 Unum = 0;
13320                 while (chosen) {
13321                     Unum++;
13322                     chosen = chosen->next;
13323                 }chosen = chosenT;
13324
13325             }
13326
13327
13328                 PLACEMENT *wpt = MS0->S4.wayp;
13329                 int waypCnt = 0;
13330                 int waypSCScnt = 0;
13331                 bool waypSCS = false;
13332                 int waypSCSunitCnt = 0;
13333
13334
13335             if(!MS0->S4.unitTypeFlag){
13336
13337             while (MS0->S4.wayp) {
13338                     waypCnt++;
13339
13340
13341
13342
13343                     if(MS0->S4.wayp->type == 0){
13344                     U = UTop;
13345                     while(U){
13346                         if(U->team != MS0->S4.team){
13347                             U = U->next;
13348                             continue;
13349                         }
13350                         if(MS0->S4.wayp->x == U->x && MS0->S4.wayp->y == U->y){
13351                             waypSCScnt++;
13352                             waypSCSunitCnt++;
13353                             break;
13354                         }
13355                         U = U->next;
13356                     }U = UTop;
13357
13358                     }else if(MS0->S4.wayp->type == 1){
13359                         U = UTop;
13360                         static bool okflag = true;
13361                         while(U){
13362                             if(U->team != MS0->S4.team){
13363                                 U = U->next;
13364                                 continue;
13365                             }
13366                             for (int i = 0;i < 1002;i++) {
13367                                 for (int k = 0;k < 1002;k++) {
13368                                     waypR[i][k] = 0;
13369                                 }
13370                             }
13371                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:U scsCnt:&waypSCSunitCnt];
13372
13373                             int Cnum = 0;
13374
13375                             for(int bx=1;bx<=chipWidth;bx++){
13376                                 for(int by=1;by<=chipHeight;by++){
13377                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13378
13379                                         if(waypR[U->x][U->y] > 0){
13380                                             Cnum++;
13381                                             if(Unum < Cnum) goto omfgUnitOver;
13382
13383
13384
13385
13386
13387                                             if(UP)
13388                                             {
13389                                                 if(!UPT){
13390                                                     UPT = UP;
13391                                                 }
13392
13393                                                 UP = UPT;
13394                                                 while (UP) {
13395                                                     if(UP->x == U->x && UP->y == U->y){
13396
13397                                                         break;
13398                                                     }else{
13399                                                         okflag = true;
13400                                                     }
13401
13402                                                     UP = UP->next;
13403                                                 }
13404
13405                                             }
13406                                             UP = UPT;
13407
13408                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13409                                             else if(UP){
13410                                                 while(UP->next) UP = UP->next;
13411                                             }
13412                                             if(okflag){
13413                                                 UP->x = U->x;
13414                                                 UP->y = U->y;
13415                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13416                                                 okflag = false;
13417                                                 waypSCSunitCnt++;
13418                                             }
13419                                         }
13420
13421                                     }
13422                                 }
13423                             }
13424
13425                         omfgUnitOver:
13426                             UP = NULL;
13427                             UPT = NULL;
13428                    //         NSLog(@"%d", waypSCSunitCnt);
13429
13430                              U = U->next;
13431                         }U = UTop;
13432                         okflag = true;
13433
13434
13435
13436                     }else if(MS0->S4.wayp->type == 2){
13437                         U = UTop;
13438                         waypSCSunitCnt = 0;
13439                         static bool okflag = true;
13440                         while(U){
13441                             if(U->team != MS0->S4.team){
13442                                 U = U->next;
13443                                 continue;
13444                             }
13445                             if((MS0->S4.wayp->x <= U->x) && (MS0->S4.wayp->x2 >= U->x) &&
13446                                (MS0->S4.wayp->y <= U->y) && (MS0->S4.wayp->y2 >= U->y)){
13447
13448
13449                                 int Cnum = 0;
13450
13451                                 if(1){
13452                                     Cnum++;
13453                                     if(Unum < Cnum) goto omfgUnitOver;
13454
13455
13456
13457
13458
13459                                     if(UP)
13460                                     {
13461                                         if(!UPT){
13462                                             UPT = UP;
13463                                         }
13464
13465                                         UP = UPT;
13466                                         while (UP) {
13467                                             if(UP->x == U->x && UP->y == U->y){
13468
13469                                                 break;
13470                                             }else{
13471                                                 okflag = true;
13472                                             }
13473
13474                                             UP = UP->next;
13475                                         }
13476
13477                                     }
13478                                     UP = UPT;
13479
13480                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13481                                     else if(UP){
13482                                         while(UP->next) UP = UP->next;
13483                                     }
13484                                     if(okflag){
13485                                         UP->x = U->x;
13486                                         UP->y = U->y;
13487                                         UP->next = calloc(1, sizeof(UNITPOINT));
13488                                         okflag = false;
13489                                         waypSCScnt++;
13490                                         waypSCSunitCnt++;
13491                                     }
13492                                 }
13493
13494
13495
13496
13497                             }
13498                             U = U->next;
13499                         }U = UTop;
13500                         okflag = true;
13501                     }
13502
13503                     MS0->S4.wayp = MS0->S4.wayp->next;
13504                 }MS0->S4.wayp = wpt;
13505            // NSLog(@"%d", waypSCSunitCnt);
13506
13507             if(waypSCScnt >= waypCnt)
13508                 waypSCS = true;
13509
13510             }else if(MS0->S4.unitTypeFlag){
13511
13512                 while (MS0->S4.wayp) {
13513                     waypCnt++;
13514
13515
13516
13517
13518                     if(MS0->S4.wayp->type == 0){
13519                         chosen = chosenT;
13520                         while(chosen){
13521                             if(MS0->S4.wayp->x == chosen->x && MS0->S4.wayp->y == chosen->y){
13522                                 waypSCScnt++;
13523                                 waypSCSunitCnt++;
13524                                 break;
13525                             }
13526                             chosen = chosen->next;
13527                         }chosen = chosenT;
13528
13529                     }else if(MS0->S4.wayp->type == 1){
13530                         chosen = chosenT;
13531                         static bool okflag = true;
13532                         while(chosen){
13533                             for (int i = 0;i < 1002;i++) {
13534                                 for (int k = 0;k < 1002;k++) {
13535                                     waypR[i][k] = 0;
13536                                 }
13537                             }
13538                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:chosen scsCnt:&waypSCSunitCnt];
13539
13540                             int Cnum = 0;
13541
13542                             for(int bx=1;bx<=chipWidth;bx++){
13543                                 for(int by=1;by<=chipHeight;by++){
13544                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13545
13546                                         if(waypR[chosen->x][chosen->y] > 0){
13547                                             Cnum++;
13548                                             if(Unum < Cnum) goto omfgUnitOver5;
13549
13550
13551
13552
13553
13554                                             if(UP)
13555                                             {
13556                                                 if(!UPT){
13557                                                     UPT = UP;
13558                                                 }
13559
13560                                                 UP = UPT;
13561                                                 while (UP) {
13562                                                     if(UP->x == chosen->x && UP->y == chosen->y){
13563
13564                                                         break;
13565                                                     }else{
13566                                                         okflag = true;
13567                                                     }
13568
13569                                                     UP = UP->next;
13570                                                 }
13571
13572                                             }
13573                                             UP = UPT;
13574
13575                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13576                                             else if(UP){
13577                                                 while(UP->next) UP = UP->next;
13578                                             }
13579                                             if(okflag){
13580                                                 UP->x = chosen->x;
13581                                                 UP->y = chosen->y;
13582                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13583                                                 okflag = false;
13584                                                 waypSCSunitCnt++;
13585                                             }
13586                                         }
13587
13588                                     }
13589                                 }
13590                             }
13591
13592                         omfgUnitOver5:
13593                             UP = NULL;
13594                             UPT = NULL;
13595
13596                           //           NSLog(@"%d", waypSCSunitCnt);
13597
13598                             chosen = chosen->next;
13599                         }chosen = chosenT;
13600                         okflag = true;
13601
13602
13603
13604                     }else if(MS0->S4.wayp->type == 2){
13605                         chosen = chosenT;
13606                         waypSCSunitCnt = 0;
13607                         static bool okflag = true;
13608                         while(chosen){
13609                             if((MS0->S4.wayp->x <= chosen->x) && (MS0->S4.wayp->x2 >= chosen->x) &&
13610                                (MS0->S4.wayp->y <= chosen->y) && (MS0->S4.wayp->y2 >= chosen->y)){
13611
13612
13613                                 int Cnum = 0;
13614
13615                                 if(1){
13616                                     Cnum++;
13617                                     if(Unum < Cnum) goto omfgUnitOver;
13618
13619
13620
13621
13622
13623                                     if(UP)
13624                                     {
13625                                         if(!UPT){
13626                                             UPT = UP;
13627                                         }
13628
13629                                         UP = UPT;
13630                                         while (UP) {
13631                                             if(UP->x == chosen->x && UP->y == chosen->y){
13632
13633                                                 break;
13634                                             }else{
13635                                                 okflag = true;
13636                                             }
13637
13638                                             UP = UP->next;
13639                                         }
13640
13641                                     }
13642                                     UP = UPT;
13643
13644                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13645                                     else if(UP){
13646                                         while(UP->next) UP = UP->next;
13647                                     }
13648                                     if(okflag){
13649                                         UP->x = chosen->x;
13650                                         UP->y = chosen->y;
13651                                         UP->next = calloc(1, sizeof(UNITPOINT));
13652                                         okflag = false;
13653                                         waypSCScnt++;
13654                                         waypSCSunitCnt++;
13655                                     }
13656                                 }
13657
13658
13659
13660
13661                             }
13662                             chosen = chosen->next;
13663                         }chosen = chosenT;
13664                         okflag = true;
13665                     }
13666
13667                     MS0->S4.wayp = MS0->S4.wayp->next;
13668                 }MS0->S4.wayp = wpt;
13669               //  NSLog(@"%d", waypSCSunitCnt);
13670
13671                 if(waypSCScnt >= waypCnt)
13672                     waypSCS = true;
13673
13674
13675
13676
13677
13678             }
13679
13680             int team0num = 0;
13681             int team1num = 0;
13682             int team2num = 0;
13683             if(MS0->S4.team == 0){
13684                 if(!MS0->S4.placeFlag){
13685                 U = UTop;
13686                 while (U) {
13687                     if(U->team == 0 && !U->dead)
13688                         team0num++;
13689                     U = U->next;
13690                 }U = UTop;
13691                 }
13692                 if(MS0->S4.unitType == 0){
13693                     if(MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
13694
13695                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13696
13697                     }else{
13698                         trueFlag = false;
13699                     }
13700                 }else if(MS0->S4.unitType == 1){
13701                     if(MS0->S4.placeFlag) team0num = 65000;
13702
13703                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13704
13705                     }else{
13706                         trueFlag = false;
13707                     }
13708                 }else if(MS0->S4.unitType == 2){
13709                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13710
13711                     }else{
13712                         trueFlag = false;
13713                     }
13714                 }
13715
13716
13717             }else if(MS0->S4.team == 1){
13718                 if(!MS0->S4.placeFlag){
13719                 U = UTop;
13720                 while (U) {
13721                     if(U->team == 1 && !U->dead)
13722                         team1num++;
13723                     U = U->next;
13724                 }U = UTop;
13725                 }
13726                 if(MS0->S4.unitType == 0){
13727                     if(MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
13728
13729                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum = waypSCSunitCnt)){
13730
13731                     }else{
13732                         trueFlag = false;
13733                     }
13734                 }else if(MS0->S4.unitType == 1){
13735                     if(MS0->S4.placeFlag) team1num = 65000;
13736
13737                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13738
13739                     }else{
13740                         trueFlag = false;
13741                     }
13742                 }else if(MS0->S4.unitType == 2){
13743                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13744
13745                     }else{
13746                         trueFlag = false;
13747                     }
13748                 }
13749             }else if(MS0->S4.team == 2){
13750                 if(!MS0->S4.placeFlag){
13751                 U = UTop;
13752                 while (U) {
13753                     if(U->team == 2 && !U->dead)
13754                         team2num++;
13755                     U = U->next;
13756                 }U = UTop;
13757                 }
13758                 if(MS0->S4.unitType == 0){
13759                     if(MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
13760
13761                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13762
13763                     }else{
13764                         trueFlag = false;
13765                     }
13766                 }else if(MS0->S4.unitType == 1){
13767                     if(MS0->S4.placeFlag) team2num = 65000;
13768
13769                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13770
13771                     }else{
13772                         trueFlag = false;
13773                     }
13774                 }else if(MS0->S4.unitType == 2){
13775                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13776
13777                     }else{
13778                         trueFlag = false;
13779                     }
13780                 }
13781             }
13782
13783         }
13784
13785
13786         if(MS0->S4.unitCMDflag){
13787
13788             UNIT2 *sjt = MS0->S4.subj;
13789             UNIT *chosen = NULL;
13790             UNIT *chosenT = NULL;
13791             int cntUnit = 0;
13792             bool lmao = false;
13793             while(MS0->S4.subj){
13794                 U = UTop;
13795                 while(U){
13796                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13797                         if(chosen){
13798                             chosen->next = calloc(1, sizeof(UNIT));
13799                             if(!lmao){
13800                                 chosenT = chosen;
13801                                 lmao = true;
13802                             }
13803                             chosen = chosen->next;
13804                         }
13805                         if(!chosen){
13806                             chosen = calloc(1, sizeof(UNIT));
13807                         }
13808                         chosen->x = U->x;
13809                         chosen->y = U->y;
13810                         chosen->C.name = U->C.name;
13811
13812                         if(!U->dead)
13813                             cntUnit++;
13814                     }
13815                     U = U->next;
13816                 }U = UTop;
13817                 if(!lmao){
13818                     chosenT = chosen;
13819                     lmao = true;
13820                 }
13821                 MS0->S4.subj = MS0->S4.subj->next;
13822             }MS0->S4.subj = sjt;
13823             chosen = chosenT;
13824
13825             int objeSCSunitCnt = 0;
13826
13827
13828             int Unum = 0;
13829
13830
13831             while (chosen) {
13832                 Unum++;
13833                 chosen = chosen->next;
13834             }chosen = chosenT;
13835
13836             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
13837
13838                 UNIT2 *objeT = MS0->S4.obje;
13839
13840                 while (MS0->S4.obje) {
13841
13842
13843
13844                     chosen = chosenT;
13845                     static bool okflag = true;
13846                     while(chosen){
13847                         for (int i = 0;i < 1002;i++) {
13848                             for (int k = 0;k < 1002;k++) {
13849                                 objeR[i][k] = 0;
13850                             }
13851                         }
13852
13853                         U2 = UTop;
13854                         while(U2){
13855                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13856                                 break;
13857                             }
13858                             U2 = U2->next;
13859                         }
13860
13861                         if(!U2){
13862                             U2 = UTop;
13863                             break;
13864                         }
13865
13866                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
13867
13868                         int Cnum = 0;
13869
13870                         for(int bx=1;bx<=chipWidth;bx++){
13871                             for(int by=1;by<=chipHeight;by++){
13872                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13873
13874                                     if(objeR[chosen->x][chosen->y] > 0){
13875                                         Cnum++;
13876                                         if(Unum < Cnum) goto omfgUnitOver31;
13877
13878
13879
13880
13881
13882                                         if(UP)
13883                                         {
13884                                             if(!UPT){
13885                                                 UPT = UP;
13886                                             }
13887
13888                                             UP = UPT;
13889                                             while (UP) {
13890                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13891
13892                                                     break;
13893                                                 }else{
13894                                                     okflag = true;
13895                                                 }
13896
13897                                                 UP = UP->next;
13898                                             }
13899
13900                                         }
13901                                         UP = UPT;
13902
13903                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13904                                         else if(UP){
13905                                             while(UP->next) UP = UP->next;
13906                                         }
13907                                         if(okflag){
13908                                             UP->x = chosen->x;
13909                                             UP->y = chosen->y;
13910                                             UP->next = calloc(1, sizeof(UNITPOINT));
13911                                             okflag = false;
13912                                             objeSCSunitCnt++;
13913                                         }
13914                                     }
13915
13916                                 }
13917                             }
13918                         }
13919
13920                     omfgUnitOver31:
13921                         UP = NULL;
13922                         UPT = NULL;
13923
13924                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13925
13926                         chosen = chosen->next;
13927                     }chosen = chosenT;
13928                     okflag = true;
13929                     MS0->S4.obje = MS0->S4.obje->next;
13930                 }
13931                 MS0->S4.obje = objeT;
13932             }else if(MS0->S4.objeFlag){
13933
13934                 UNIT2 *objeT = MS0->S4.obje;
13935
13936                 while (MS0->S4.obje) {
13937
13938
13939
13940                     U = UTop;
13941                     static bool okflag = true;
13942                     while(U){
13943                         if(U->team != MS0->S4.team){
13944                             U = U->next;
13945                             continue;
13946                         }
13947                         for (int i = 0;i < 1002;i++) {
13948                             for (int k = 0;k < 1002;k++) {
13949                                 objeR[i][k] = 0;
13950                             }
13951                         }
13952
13953                         U2 = UTop;
13954                         while(U2){
13955                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13956                                 break;
13957                             }
13958                             U2 = U2->next;
13959                         }
13960
13961                         if(!U2){
13962                             U2 = UTop;
13963                             break;
13964                         }
13965
13966                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
13967
13968                         int Cnum = 0;
13969
13970                         for(int bx=1;bx<=chipWidth;bx++){
13971                             for(int by=1;by<=chipHeight;by++){
13972                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13973
13974                                     if(objeR[chosen->x][chosen->y] > 0){
13975                                         Cnum++;
13976                                         if(Unum < Cnum) goto omfgUnitOver32;
13977
13978
13979
13980
13981
13982                                         if(UP)
13983                                         {
13984                                             if(!UPT){
13985                                                 UPT = UP;
13986                                             }
13987
13988                                             UP = UPT;
13989                                             while (UP) {
13990                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13991
13992                                                     break;
13993                                                 }else{
13994                                                     okflag = true;
13995                                                 }
13996
13997                                                 UP = UP->next;
13998                                             }
13999
14000                                         }
14001                                         UP = UPT;
14002
14003                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
14004                                         else if(UP){
14005                                             while(UP->next) UP = UP->next;
14006                                         }
14007                                         if(okflag){
14008                                             UP->x = chosen->x;
14009                                             UP->y = chosen->y;
14010                                             UP->next = calloc(1, sizeof(UNITPOINT));
14011                                             okflag = false;
14012                                             objeSCSunitCnt++;
14013                                         }
14014                                     }
14015
14016                                 }
14017                             }
14018                         }
14019
14020                     omfgUnitOver32:
14021                         UP = NULL;
14022                         UPT = NULL;
14023
14024                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
14025
14026                         chosen = chosen->next;
14027                     }chosen = chosenT;
14028                     okflag = true;
14029                     MS0->S4.obje = MS0->S4.obje->next;
14030                 }
14031                 MS0->S4.obje = objeT;
14032                 U = UTop;
14033             }
14034
14035             if(MS0->S4.team == 0){
14036
14037                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14038
14039                 if(MS0->S4.unitCMD == 0){
14040                     if(pushStanbyFlag){
14041
14042                     }else{
14043                         trueFlag = false;
14044                     }
14045                 }else if(MS0->S4.unitCMD == 1){
14046                     if(battleSetUp){
14047                         battleSetUpIgnore = true;
14048                     }else{
14049                         trueFlag = false;
14050                     }
14051                 }else if(MS0->S4.unitCMD == 2){
14052
14053                 }
14054
14055
14056                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build){
14057
14058
14059
14060                     BUILD2 *bldt = MS0->S4.build;
14061
14062                     while(MS0->S4.build){
14063                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14064
14065                         if(MS0->S4.unitCMD == 0){
14066                             if(pushStanbyFlag){
14067
14068                             }else{
14069                                 trueFlag = false;
14070                             }
14071                         }else if(MS0->S4.unitCMD == 1){
14072                             if(battleSetUp){
14073                                 battleSetUpIgnore = true;
14074                             }else{
14075                                 trueFlag = false;
14076
14077                             }
14078
14079                         }else if(MS0->S4.unitCMD == 2){
14080
14081
14082                         }
14083                     }else{
14084                         trueFlag = false;
14085                     }
14086                         MS0->S4.build = MS0->S4.build->next;
14087                     }MS0->S4.build = bldt;
14088
14089
14090                 }else if(MS0->S4.subj && !MS0->S4.obje){
14091
14092
14093                     UNIT2 *sbjt = MS0->S4.subj;
14094
14095                     while(MS0->S4.subj){
14096                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14097
14098                     if(MS0->S4.unitCMD == 0){
14099                         if(pushStanbyFlag){
14100
14101                         }else{
14102                             trueFlag = false;
14103                         }
14104                     }else if(MS0->S4.unitCMD == 1){
14105                         if(battleSetUp){
14106                             battleSetUpIgnore = true;
14107                         }else{
14108                             trueFlag = false;
14109
14110                         }
14111
14112                     }else if(MS0->S4.unitCMD == 2){
14113
14114
14115                     }
14116                     }else{
14117                         trueFlag = false;
14118                     }
14119
14120                         MS0->S4.subj = MS0->S4.subj->next;
14121                     }MS0->S4.subj = sbjt;
14122
14123
14124                 }
14125                 else if(MS0->S4.subj && MS0->S4.obje){
14126
14127                     UNIT2 *sbjt = MS0->S4.subj;
14128                     UNIT2 *objt = MS0->S4.obje;
14129
14130                     while(MS0->S4.subj){
14131                         while(MS0->S4.obje){
14132                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14133                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14134
14135                     if(MS0->S4.unitCMD == 0){
14136
14137                         if(MS0->S4.unitType == 0){
14138                         if(objeSCSunitCnt == MS0->S4.unitNum){
14139
14140                             if(pushStanbyFlag){
14141
14142                             }else{
14143                                 trueFlag = false;
14144                             }
14145                         }
14146
14147                         }else if(MS0->S4.unitType == 1){
14148                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14149
14150                                 if(pushStanbyFlag){
14151
14152                                 }else{
14153                                     trueFlag = false;
14154                                 }
14155                             }
14156
14157                         }else if(MS0->S4.unitType == 2){
14158                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14159
14160                                 if(pushStanbyFlag){
14161
14162                                 }else{
14163                                     trueFlag = false;
14164                                 }
14165                             }
14166                         }
14167
14168                     }else if(MS0->S4.unitCMD == 1){
14169
14170                         if(MS0->S4.unitType == 0){
14171                             if(objeSCSunitCnt == MS0->S4.unitNum){
14172
14173                                 if(battleSetUp){
14174                                     battleSetUpIgnore = true;
14175                                 }else{
14176                                     trueFlag = false;
14177                                 }
14178                             }
14179
14180                         }else if(MS0->S4.unitType == 1){
14181                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14182
14183                                 if(battleSetUp){
14184                                     battleSetUpIgnore = true;
14185                                 }else{
14186                                     trueFlag = false;
14187                                 }
14188                             }
14189
14190                         }else if(MS0->S4.unitType == 2){
14191                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14192
14193                                 if(battleSetUp){
14194                                     battleSetUpIgnore = true;
14195                                 }else{
14196                                     trueFlag = false;
14197                                 }
14198                             }
14199                         }
14200
14201                     }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14202
14203
14204                     }
14205
14206
14207
14208
14209
14210                     }else{
14211                         trueFlag = false;
14212                     }
14213                         MS0->S4.obje = MS0->S4.obje->next;
14214                         }MS0->S4.obje = objt;
14215                         MS0->S4.subj = MS0->S4.subj->next;
14216                     }MS0->S4.subj = sbjt;
14217
14218                 }if(MS0->S4.subj && MS0->S4.build){
14219
14220
14221                     UNIT2 *sbjt = MS0->S4.subj;
14222                     BUILD2 *bldt = MS0->S4.build;
14223
14224                     while(MS0->S4.subj){
14225                         while(MS0->S4.build){
14226                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14227                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14228                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14229
14230                         if(MS0->S4.unitCMD == 0){
14231                             if(pushStanbyFlag){
14232
14233                             }else{
14234                                 trueFlag = false;
14235                             }
14236                         }else if(MS0->S4.unitCMD == 1){
14237                             if(battleSetUp){
14238                                 battleSetUpIgnore = true;
14239                             }else{
14240                                 trueFlag = false;
14241
14242                             }
14243
14244                         }else if(MS0->S4.unitCMD == 2){
14245
14246
14247                         }
14248
14249
14250                     }else{
14251                         trueFlag = false;
14252                     }
14253                         MS0->S4.build = MS0->S4.build->next;
14254                         }MS0->S4.build = bldt;
14255
14256                         MS0->S4.subj = MS0->S4.subj->next;
14257                 }
14258                    MS0->S4.subj = sbjt;
14259
14260                 }
14261             }else if(MS0->S4.team == 1){
14262                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14263
14264                     if(MS0->S4.unitCMD == 0){
14265                         if(pushStanbyFlag){
14266
14267                         }else{
14268                             trueFlag = false;
14269                         }
14270                     }else if(MS0->S4.unitCMD == 1){
14271                         if(battleSetUp){
14272                             battleSetUpIgnore = true;
14273                         }else{
14274                             trueFlag = false;
14275                         }
14276                     }else if(MS0->S4.unitCMD == 2){
14277
14278                     }
14279
14280
14281                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build){
14282
14283
14284
14285                     BUILD2 *bldt = MS0->S4.build;
14286                     while(MS0->S4.build){
14287                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14288
14289                         if(MS0->S4.unitCMD == 0){
14290                             if(pushStanbyFlag){
14291
14292                             }else{
14293                                 trueFlag = false;
14294                             }
14295                         }else if(MS0->S4.unitCMD == 1){
14296                             if(battleSetUp){
14297                                 battleSetUpIgnore = true;
14298                             }else{
14299                                 trueFlag = false;
14300
14301                             }
14302
14303                         }else if(MS0->S4.unitCMD == 2){
14304
14305
14306                         }
14307                     }else{
14308                         trueFlag = false;
14309                     }
14310                         MS0->S4.build = MS0->S4.build->next;
14311                     }MS0->S4.build = bldt;
14312
14313
14314                 }else if(MS0->S4.subj && !MS0->S4.obje){
14315
14316
14317
14318                     UNIT2 *sbjt = MS0->S4.subj;
14319
14320                     while(MS0->S4.subj){
14321                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14322
14323                         if(MS0->S4.unitCMD == 0){
14324                             if(pushStanbyFlag){
14325
14326                             }else{
14327                                 trueFlag = false;
14328                             }
14329                         }else if(MS0->S4.unitCMD == 1){
14330                             if(battleSetUp){
14331                                 battleSetUpIgnore = true;
14332                             }else{
14333                                 trueFlag = false;
14334
14335                             }
14336
14337                         }else if(MS0->S4.unitCMD == 2){
14338
14339
14340                         }
14341                     }else{
14342                         trueFlag = false;
14343                     }
14344
14345                         MS0->S4.subj = MS0->S4.subj->next;
14346                     }MS0->S4.subj = sbjt;
14347
14348                 }else if(MS0->S4.subj && MS0->S4.obje){
14349
14350                     UNIT2 *sbjt = MS0->S4.subj;
14351                     UNIT2 *objt = MS0->S4.obje;
14352
14353                     while(MS0->S4.subj){
14354                         while(MS0->S4.obje){
14355                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14356                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14357
14358                         if(MS0->S4.unitCMD == 0){
14359
14360                             if(MS0->S4.unitType == 0){
14361                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14362
14363                                     if(pushStanbyFlag){
14364
14365                                     }else{
14366                                         trueFlag = false;
14367                                     }
14368                                 }
14369
14370                             }else if(MS0->S4.unitType == 1){
14371                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14372
14373                                     if(pushStanbyFlag){
14374
14375                                     }else{
14376                                         trueFlag = false;
14377                                     }
14378                                 }
14379
14380                             }else if(MS0->S4.unitType == 2){
14381                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14382
14383                                     if(pushStanbyFlag){
14384
14385                                     }else{
14386                                         trueFlag = false;
14387                                     }
14388                                 }
14389                             }
14390
14391                         }else if(MS0->S4.unitCMD == 1){
14392
14393                             if(MS0->S4.unitType == 0){
14394                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14395
14396                                     if(battleSetUp){
14397                                         battleSetUpIgnore = true;
14398                                     }else{
14399                                         trueFlag = false;
14400                                     }
14401                                 }
14402
14403                             }else if(MS0->S4.unitType == 1){
14404                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14405
14406                                     if(battleSetUp){
14407                                         battleSetUpIgnore = true;
14408                                     }else{
14409                                         trueFlag = false;
14410                                     }
14411                                 }
14412
14413                             }else if(MS0->S4.unitType == 2){
14414                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14415
14416                                     if(battleSetUp){
14417                                         battleSetUpIgnore = true;
14418                                     }else{
14419                                         trueFlag = false;
14420                                     }
14421                                 }
14422                             }
14423
14424                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14425
14426
14427                         }
14428
14429
14430
14431
14432                     }else{
14433                         trueFlag = false;
14434                     }
14435
14436
14437                             MS0->S4.obje = MS0->S4.obje->next;
14438                         }MS0->S4.obje = objt;
14439                         MS0->S4.subj = MS0->S4.subj->next;
14440                     }MS0->S4.subj = sbjt;
14441
14442                 }if(MS0->S4.subj && MS0->S4.build){
14443
14444                     UNIT2 *sbjt = MS0->S4.subj;
14445                     BUILD2 *bldt = MS0->S4.build;
14446                     while(MS0->S4.subj){
14447                         while(MS0->S4.build){
14448                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14449                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14450                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14451
14452                         if(MS0->S4.unitCMD == 0){
14453                             if(pushStanbyFlag){
14454
14455                             }else{
14456                                 trueFlag = false;
14457                             }
14458                         }else if(MS0->S4.unitCMD == 1){
14459                             if(battleSetUp){
14460                                 battleSetUpIgnore = true;
14461                             }else{
14462                                 trueFlag = false;
14463
14464                             }
14465
14466                         }else if(MS0->S4.unitCMD == 2){
14467
14468
14469                         }
14470
14471
14472                     }else{
14473                         trueFlag = false;
14474                     }
14475                         MS0->S4.build = MS0->S4.build->next;
14476                         }MS0->S4.build = bldt;
14477                         MS0->S4.subj = MS0->S4.subj->next;
14478                     }MS0->S4.subj = sbjt;
14479                 }
14480             }else if(MS0->S4.team == 2){
14481                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14482
14483                     if(MS0->S4.unitCMD == 0){
14484                         if(pushStanbyFlag){
14485
14486                         }else{
14487                             trueFlag = false;
14488                         }
14489                     }else if(MS0->S4.unitCMD == 1){
14490                         if(battleSetUp){
14491                             battleSetUpIgnore = true;
14492                         }else{
14493                             trueFlag = false;
14494                         }
14495                     }else if(MS0->S4.unitCMD == 2){
14496
14497                     }
14498
14499
14500                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build){
14501
14502
14503
14504                     BUILD2 *bldt = MS0->S4.build;
14505                     while(MS0->S4.build){
14506                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14507
14508                         if(MS0->S4.unitCMD == 0){
14509                             if(pushStanbyFlag){
14510
14511                             }else{
14512                                 trueFlag = false;
14513                             }
14514                         }else if(MS0->S4.unitCMD == 1){
14515                             if(battleSetUp){
14516                                 battleSetUpIgnore = true;
14517                             }else{
14518                                 trueFlag = false;
14519
14520                             }
14521
14522                         }else if(MS0->S4.unitCMD == 2){
14523
14524
14525                         }
14526                     }else{
14527                         trueFlag = false;
14528                     }
14529                         MS0->S4.build = MS0->S4.build->next;
14530                     }MS0->S4.build = bldt;
14531
14532
14533                 }else if(MS0->S4.subj && !MS0->S4.obje){
14534
14535                     UNIT2 *sbjt = MS0->S4.subj;
14536
14537                     while(MS0->S4.subj){
14538                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14539
14540                         if(MS0->S4.unitCMD == 0){
14541                             if(pushStanbyFlag){
14542
14543                             }else{
14544                                 trueFlag = false;
14545                             }
14546                         }else if(MS0->S4.unitCMD == 1){
14547                             if(battleSetUp){
14548                                 battleSetUpIgnore = true;
14549                             }else{
14550                                 trueFlag = false;
14551
14552                             }
14553
14554                         }else if(MS0->S4.unitCMD == 2){
14555
14556
14557                         }
14558                     }else{
14559                         trueFlag = false;
14560                     }
14561                       MS0->S4.subj = MS0->S4.subj->next;
14562                     }MS0->S4.subj = sbjt;
14563
14564                 }else if(MS0->S4.subj && MS0->S4.obje){
14565
14566                     UNIT2 *sbjt = MS0->S4.subj;
14567                     UNIT2 *objt = MS0->S4.obje;
14568
14569                     while(MS0->S4.subj){
14570                         while(MS0->S4.obje){
14571                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14572                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14573
14574                         if(MS0->S4.unitCMD == 0){
14575
14576                             if(MS0->S4.unitType == 0){
14577                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14578
14579                                     if(pushStanbyFlag){
14580
14581                                     }else{
14582                                         trueFlag = false;
14583                                     }
14584                                 }
14585
14586                             }else if(MS0->S4.unitType == 1){
14587                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14588
14589                                     if(pushStanbyFlag){
14590
14591                                     }else{
14592                                         trueFlag = false;
14593                                     }
14594                                 }
14595
14596                             }else if(MS0->S4.unitType == 2){
14597                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14598
14599                                     if(pushStanbyFlag){
14600
14601                                     }else{
14602                                         trueFlag = false;
14603                                     }
14604                                 }
14605                             }
14606
14607                         }else if(MS0->S4.unitCMD == 1){
14608
14609                             if(MS0->S4.unitType == 0){
14610                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14611
14612                                     if(battleSetUp){
14613                                         battleSetUpIgnore = true;
14614                                     }else{
14615                                         trueFlag = false;
14616                                     }
14617                                 }
14618
14619                             }else if(MS0->S4.unitType == 1){
14620                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14621
14622                                     if(battleSetUp){
14623                                         battleSetUpIgnore = true;
14624                                     }else{
14625                                         trueFlag = false;
14626                                     }
14627                                 }
14628
14629                             }else if(MS0->S4.unitType == 2){
14630                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14631
14632                                     if(battleSetUp){
14633                                         battleSetUpIgnore = true;
14634                                     }else{
14635                                         trueFlag = false;
14636                                     }
14637                                 }
14638                             }
14639
14640                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14641
14642
14643                         }
14644
14645                     }else{
14646                         trueFlag = false;
14647                     }
14648                             MS0->S4.obje = MS0->S4.obje->next;
14649                         }MS0->S4.obje = objt;
14650                         MS0->S4.subj = MS0->S4.subj->next;
14651                     }MS0->S4.subj = sbjt;
14652                 }if(MS0->S4.subj && MS0->S4.build){
14653
14654                     UNIT2 *sbjt = MS0->S4.subj;
14655                     BUILD2 *bldt = MS0->S4.build;
14656                     while(MS0->S4.subj){
14657                         while(MS0->S4.build){
14658                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14659                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14660                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14661
14662                         if(MS0->S4.unitCMD == 0){
14663                             if(pushStanbyFlag){
14664
14665                             }else{
14666                                 trueFlag = false;
14667                             }
14668                         }else if(MS0->S4.unitCMD == 1){
14669                             if(battleSetUp){
14670                                 battleSetUpIgnore = true;
14671                             }else{
14672                                 trueFlag = false;
14673
14674                             }
14675
14676                         }else if(MS0->S4.unitCMD == 2){
14677
14678
14679                         }
14680
14681
14682                     }else{
14683                         trueFlag = false;
14684                     }
14685                         MS0->S4.build = MS0->S4.build->next;
14686                         }MS0->S4.build = bldt;
14687                         MS0->S4.subj = MS0->S4.subj->next;
14688                     }MS0->S4.subj = sbjt;
14689                 }
14690             }
14691         }
14692
14693
14694
14695
14696
14697
14698
14699
14700
14701
14702
14703
14704
14705
14706
14707
14708
14709
14710
14711
14712
14713
14714
14715
14716
14717     }
14718
14719
14720
14721
14722
14723
14724
14725
14726     branchEndFlag = true;
14727     MS0->succeessfulFlag = false;
14728     if(trueFlag){
14729         branchSuceedFlag = true;
14730         MS0->succeessfulFlag = true;
14731     }else{
14732         MS0->succeessfulFlag = false;
14733     }
14734
14735     CRMS0 = MS0;
14736     if(branchEndFlag){
14737         if(!branchSuceedFlag){
14738             MS0 = MSDPtop;
14739             while(MS0){
14740                 MS0->endFlag = false;
14741                 MS0 = MS0->next;
14742             }
14743
14744             MS0 = CRMS0;
14745             MS0->endFlag = true;
14746             MS0 = MSDPtop;
14747
14748             if([CRMS0->S4.FAILrabel isEqualToString:MS0->label] && 0){
14749                 //ここはどうやら使えない
14750                 MS0->succeessfulFlag = false;
14751                 MS0->endFlag = false;
14752             }else{
14753
14754                 while (MS0) {
14755
14756                     if(MS0->next)
14757                         if([CRMS0->S4.FAILrabel isEqualToString:MS0->next->label]){
14758
14759                             if(MS0->type == 6 && MS0->endFlag){
14760
14761                             }else{
14762                                 MS0->succeessfulFlag = true;
14763                             }
14764                             MS0->endFlag = true;
14765                             MS0 = MS0->next;
14766                             break;
14767                         }
14768                     if(MS0->type == 6 && MS0->endFlag){
14769
14770                     }else{
14771                         MS0->succeessfulFlag = true;
14772                     }
14773                     MS0->endFlag = true;
14774                     MS0 = MS0->next;
14775                 }
14776             }
14777
14778             if(!MS0){
14779                 MS0 = CRMS0;
14780                 //MS0->endFlag = true;
14781                 return MS0;
14782             }
14783
14784         }else if(branchSuceedFlag){
14785             MS0 = MSDPtop;
14786             while(MS0){
14787                 MS0->endFlag = false;
14788                 MS0 = MS0->next;
14789             }
14790
14791             MS0 = CRMS0;
14792             MS0->endFlag = true;
14793
14794             MS0 = MSDPtop;
14795
14796             if([CRMS0->S4.COMPrabel isEqualToString:MS0->label] && 0){
14797                 MS0->succeessfulFlag = false;
14798                 MS0->endFlag = false;
14799             }else{
14800
14801                 while (MS0) {
14802
14803                     if(MS0->next)
14804                         if([CRMS0->S4.COMPrabel isEqualToString:MS0->next->label]){
14805
14806                             if(MS0->type == 6 && MS0->endFlag){
14807
14808                             }else{
14809                                 MS0->succeessfulFlag = true;
14810                             }
14811                             MS0->endFlag = true;
14812                             MS0 = MS0->next;
14813                             break;
14814                         }
14815
14816                     if(MS0->type == 6 && MS0->endFlag){
14817
14818                     }else{
14819                         MS0->succeessfulFlag = true;
14820                     }
14821                     MS0->endFlag = true;
14822                     MS0 = MS0->next;
14823                 }
14824             }
14825
14826             if(!MS0){
14827                 MS0 = CRMS0;
14828                 //MS0->endFlag = true;
14829                 return MS0;
14830             }
14831         }
14832     }
14833
14834     //NSLog(@"%g", eventTime);
14835     //NSLog(@"%d", MSDPtop->succeessfulFlag);
14836     //MS0->endFlag = true;
14837     return MS0;
14838 }
14839
14840
14841 -(void)checkPlaceHani:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap u:(UNIT*)u scsCnt:(int*)scsCnt{
14842
14843     if(cnsPow < 0) return;
14844
14845     int i0;
14846     int *j0 = scsCnt;
14847     if(aMap[startY][startX] <= cnsPow)
14848         aMap[startY][startX] = cnsPow;
14849
14850     if(startY < 0) startY = 0;
14851     if(startX < 0) startX = 0;
14852     if(cnsPow < 0) cnsPow = 0;
14853
14854     i0 = cnsPow - 1;
14855
14856     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
14857         [self checkPlaceHani:i0 tX:startX tY:startY-1 aMap:aMap u:u scsCnt:j0];
14858
14859     i0 = cnsPow - 1;
14860     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
14861         [self checkPlaceHani:i0 tX:startX tY:startY+1 aMap:aMap u:u scsCnt:j0];
14862
14863     i0 = cnsPow - 1;
14864     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
14865         [self checkPlaceHani:i0 tX:startX-1 tY:startY aMap:aMap u:u scsCnt:j0];
14866
14867     i0 = cnsPow - 1;
14868     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
14869         [self checkPlaceHani:i0 tX:startX+1 tY:startY aMap:aMap u:u scsCnt:j0];
14870
14871
14872 }
14873
14874 -(MAPSCRIPT0*)setLabelJump:(MAPSCRIPT0*)MS0{
14875
14876     MAPSCRIPT0 *CRMS0 = MS0;
14877     MS0 = MSDPtop;
14878     while(MS0){
14879         MS0->endFlag = false;
14880         MS0 = MS0->next;
14881     }
14882     MS0 = CRMS0;
14883     MS0->endFlag = true;
14884     MS0->succeessfulFlag = true;
14885
14886     MS0 = MSDPtop;
14887
14888     if([CRMS0->labelJump isEqualToString:MS0->label]){
14889         MS0->succeessfulFlag = false;
14890         MS0->endFlag = false;
14891     }else{
14892
14893         while (MS0) {
14894
14895             if(MS0->next)
14896                 if([CRMS0->labelJump isEqualToString:MS0->next->label]){
14897                     if(MS0->type == 6 && MS0->endFlag){
14898
14899                     }else{
14900                         MS0->succeessfulFlag = true;
14901                     }
14902                     MS0->endFlag = true;
14903                     MS0 = MS0->next;
14904                     break;
14905                 }
14906             if(MS0->type == 6 && MS0->endFlag){
14907
14908             }else{
14909                 MS0->succeessfulFlag = true;
14910             }
14911             MS0->endFlag = true;
14912                 MS0 = MS0->next;
14913         }
14914     }
14915     if(!MS0){
14916         MS0 = CRMS0;
14917         return MS0;
14918     }
14919
14920     return MS0;
14921 }
14922
14923 -(MAPSCRIPT0*)setDefault:(MAPSCRIPT0*)MS0{
14924
14925     MS0->succeessfulFlag = true;
14926     MS0->endFlag = true;
14927     return MS0;
14928 }
14929
14930 -(MAPSCRIPT0*)setResource:(MAPSCRIPT0*)MS0{
14931
14932     if(MS0->S6.team == 0){
14933
14934         if(MS0->S6.RCsupply){
14935             if(MS0->S6.RCsupplyS){
14936                 if(MS0->S6.RCsupplyAdd)
14937                     P[0].resource += MS0->S6.RCsupplyValue;
14938                 else
14939                     P[0].resource -= MS0->S6.RCsupplyValue;
14940             }else{
14941                 if(MS0->S6.RCsupplyAdd)
14942                     P[0].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
14943                 else
14944                     P[0].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
14945             }
14946         }
14947         if(MS0->S6.RCfood){
14948             if(MS0->S6.RCfoodS){
14949                 if(MS0->S6.RCfoodAdd)
14950                     P[0].food += MS0->S6.RCfoodValue;
14951                 else
14952                     P[0].food -= MS0->S6.RCfoodValue;
14953             }else{
14954                 if(MS0->S6.RCfoodAdd)
14955                     P[0].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
14956                 else
14957                     P[0].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
14958             }
14959         }
14960         if(MS0->S6.RCmoney){
14961             if(MS0->S6.RCmoneyS){
14962                 if(MS0->S6.RCmoneyAdd)
14963                     P[0].money += MS0->S6.RCmoneyValue;
14964                 else
14965                     P[0].money -= MS0->S6.RCmoneyValue;
14966             }else{
14967                 if(MS0->S6.RCmoneyAdd)
14968                     P[0].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
14969                 else
14970                     P[0].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
14971             }
14972         }
14973
14974     }else if(MS0->S6.team == 1){
14975         if(MS0->S6.RCsupply){
14976         if(MS0->S6.RCsupplyS){
14977             if(MS0->S6.RCsupplyAdd)
14978                 P[1].resource += MS0->S6.RCsupplyValue;
14979             else
14980                 P[1].resource -= MS0->S6.RCsupplyValue;
14981         }else{
14982             if(MS0->S6.RCsupplyAdd)
14983                 P[1].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
14984             else
14985                 P[1].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
14986         }
14987         }
14988     if(MS0->S6.RCfood){
14989         if(MS0->S6.RCfoodS){
14990             if(MS0->S6.RCfoodAdd)
14991                 P[1].food += MS0->S6.RCfoodValue;
14992             else
14993                 P[1].food -= MS0->S6.RCfoodValue;
14994         }else{
14995             if(MS0->S6.RCfoodAdd)
14996                 P[1].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
14997             else
14998                 P[1].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
14999         }
15000     }
15001     if(MS0->S6.RCmoney){
15002         if(MS0->S6.RCmoneyS){
15003             if(MS0->S6.RCmoneyAdd)
15004                 P[1].money += MS0->S6.RCmoneyValue;
15005             else
15006                 P[1].money -= MS0->S6.RCmoneyValue;
15007         }else{
15008             if(MS0->S6.RCmoneyAdd)
15009                 P[1].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
15010             else
15011                 P[1].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
15012         }
15013     }
15014     }else if(MS0->S6.team == 2){
15015         if(MS0->S6.RCsupply){
15016         if(MS0->S6.RCsupplyS){
15017             if(MS0->S6.RCsupplyAdd)
15018                 P[2].resource += MS0->S6.RCsupplyValue;
15019             else
15020                 P[2].resource -= MS0->S6.RCsupplyValue;
15021         }else{
15022             if(MS0->S6.RCsupplyAdd)
15023                 P[2].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
15024             else
15025                 P[2].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
15026         }
15027         }
15028
15029     if(MS0->S6.RCfood){
15030         if(MS0->S6.RCfoodS){
15031             if(MS0->S6.RCfoodAdd)
15032                 P[2].food += MS0->S6.RCfoodValue;
15033             else
15034                 P[2].food -= MS0->S6.RCfoodValue;
15035         }else{
15036             if(MS0->S6.RCfoodAdd)
15037                 P[2].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
15038             else
15039                 P[2].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
15040         }
15041     }
15042     if(MS0->S6.RCmoney){
15043         if(MS0->S6.RCmoneyS){
15044             if(MS0->S6.RCmoneyAdd)
15045                 P[2].money += MS0->S6.RCmoneyValue;
15046             else
15047                 P[2].money -= MS0->S6.RCmoneyValue;
15048         }else{
15049             if(MS0->S6.RCmoneyAdd)
15050                 P[2].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
15051             else
15052                 P[2].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
15053         }
15054     }
15055     }
15056
15057     if(P[0].resource < 0) P[0].resource = 0;
15058     if(P[1].resource < 0) P[1].resource = 0;
15059     if(P[2].resource < 0) P[2].resource = 0;
15060
15061     if(P[0].food < 0) P[0].food = 0;
15062     if(P[1].food < 0) P[1].food = 0;
15063     if(P[2].food < 0) P[2].food = 0;
15064
15065     if(P[0].money < 0) P[0].money = 0;
15066     if(P[1].money < 0) P[1].money = 0;
15067     if(P[2].money < 0) P[2].money = 0;
15068
15069     MS0->succeessfulFlag = true;
15070     MS0->endFlag = true;
15071     return MS0;
15072 }
15073
15074 -(MAPSCRIPT0*)setLabel:(MAPSCRIPT0*)MS0{
15075
15076     //NSLog(@"%d", MSDP0top->succeessfulFlag);
15077     MS0->succeessfulFlag = true;
15078     MS0->endFlag = true;
15079     return MS0;
15080 }
15081
15082 -(MAPSCRIPT0*)setComment:(MAPSCRIPT0*)MS0{
15083
15084     MS0->succeessfulFlag = true;
15085     MS0->endFlag = true;
15086     return MS0;
15087 }
15088
15089
15090 -(MAPSCRIPT0*)setSelection:(MAPSCRIPT0*)MS0{
15091
15092     static bool initFlag = false;
15093
15094     if(!initFlag){
15095         initFlag = true;
15096
15097         MAPSCRIPT2 *MS2top = MS0->S2;
15098
15099         slctPoint.x = [mapWindow frame].origin.x + 100;
15100         slctPoint.y = [mapWindow frame].origin.y + 300;
15101
15102         [slctBtn1 setHidden:YES];
15103         [slctBtn2 setHidden:YES];
15104         [slctBtn3 setHidden:YES];
15105         [slctBtn4 setHidden:YES];
15106         [slctBtn5 setHidden:YES];
15107         [slctBtn6 setHidden:YES];
15108         [slctBtn7 setHidden:YES];
15109         [slctBtn8 setHidden:YES];
15110         [slctBtn9 setHidden:YES];
15111
15112         for(int i = 1;MS0->S2;i++){
15113
15114             if(i == 1){
15115                 [slctBtn1 setTitle:MS0->S2->selection];
15116                 [slctBtn1 setHidden:NO];
15117                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 60) display:YES];
15118             }
15119             if(i == 2){
15120                 [slctBtn2 setTitle:MS0->S2->selection];
15121                 [slctBtn2 setHidden:NO];
15122                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 90) display:YES];
15123             }
15124             if(i == 3){
15125                 [slctBtn3 setTitle:MS0->S2->selection];
15126                 [slctBtn3 setHidden:NO];
15127                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 120) display:YES];
15128             }
15129
15130             if(i == 4){
15131                 [slctBtn4 setTitle:MS0->S2->selection];
15132                 [slctBtn4 setHidden:NO];
15133                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 150) display:YES];
15134             }
15135             if(i == 5){
15136                 [slctBtn5 setTitle:MS0->S2->selection];
15137                 [slctBtn5 setHidden:NO];
15138                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 180) display:YES];
15139             }
15140             if(i == 6){
15141                 [slctBtn6 setTitle:MS0->S2->selection];
15142                 [slctBtn6 setHidden:NO];
15143                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 210) display:YES];
15144             }
15145             if(i == 7){
15146                 [slctBtn7 setTitle:MS0->S2->selection];
15147                 [slctBtn7 setHidden:NO];
15148                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 240) display:YES];
15149             }
15150             if(i == 8){
15151                 [slctBtn8 setTitle:MS0->S2->selection];
15152                 [slctBtn8 setHidden:NO];
15153                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 270) display:YES];
15154             }
15155             if(i == 9){
15156                 [slctBtn9 setTitle:MS0->S2->selection];
15157                 [slctBtn9 setHidden:NO];
15158                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 300) display:YES];
15159             }
15160             slctBtnNum = i;
15161             if(slctBtnNum > 9)
15162                 slctBtnNum = 9;
15163             MS0->S2 = MS0->S2->next;
15164         }
15165         MS0->S2 = MS2top;
15166
15167
15168
15169         [selectionWindow makeKeyAndOrderFront:nil];
15170     }
15171
15172
15173     if(slctedBtnNum > 0){
15174         MAPSCRIPT0 *CRMS0 = MS0;
15175
15176         MS0 = MSDPtop;
15177         while(MS0){
15178             MS0->endFlag = false;
15179             MS0 = MS0->next;
15180         }MS0 = CRMS0;
15181
15182         MAPSCRIPT2 *MS2top = MS0->S2;
15183         MAPSCRIPT2 *CRMS2;
15184
15185         for(int i = 1;i < slctedBtnNum;i++){
15186             MS0->S2 = MS0->S2->next;
15187         }
15188             CRMS2 = MS0->S2;
15189
15190         MS0->S2 = MS2top;
15191
15192         MS0 = MSDPtop;
15193         if([CRMS2->labelJump isEqualToString:MS0->label]){
15194             MS0->endFlag = false;
15195         }else{
15196
15197             while (MS0) {
15198
15199                 if(MS0->next)
15200                     if([CRMS2->labelJump isEqualToString:MS0->next->label]){
15201                         if(MS0->type == 6 && MS0->endFlag){
15202
15203                         }else{
15204                             MS0->succeessfulFlag = true;
15205                         }
15206                         MS0->endFlag = true;
15207                         MS0 = MS0->next;
15208                         break;
15209                     }
15210                 if(MS0->type == 6 && MS0->endFlag){
15211
15212                 }else{
15213                     MS0->succeessfulFlag = true;
15214                 }
15215                 MS0->endFlag = true;
15216                 MS0 = MS0->next;
15217             }
15218         }
15219         if(!MS0){
15220             MS0 = CRMS0;
15221             return MS0;
15222         }
15223
15224         MS0->endFlag = true;
15225         MS0->succeessfulFlag = true;
15226         initFlag = false;
15227         slctedBtnNum = 0;
15228         }
15229
15230     return MS0;
15231 }
15232
15233 -(MAPSCRIPT0*)setAppearance:(MAPSCRIPT0*)MS0{
15234
15235     MS3T = MS0->S3;
15236     while(MS0->S3){
15237         int x, y;
15238         UNITCHIP u;
15239         u = MS0->S3->U;
15240         x = MS0->S3->x;
15241         y = MS0->S3->y;
15242
15243         if(unitNum[x][y] == -1){
15244
15245             if(MS0->S3->flag){
15246
15247
15248             }else{
15249                 unitTeam[x][y] = MS0->S3->team;
15250                 unitNum[x][y] = u.chipNumb;
15251                 loadNum[x][y] = u.chipNumb;
15252                 [self addAppearanceStatus:u x:x y:y];
15253             }
15254         }else{
15255
15256             if(MS0->S3->flag){
15257
15258
15259             }else{
15260                 int *p = calloc(1, sizeof(int));
15261                 int *o = calloc(1, sizeof(int));
15262                 appearanceSAIKIflag = false;
15263                 wtflag = 0;
15264
15265                 for (int i = 0;i < 1002;i++) {
15266                     for (int k = 0;k < 1002;k++) {
15267                         apprR[i][k] = 0;
15268                     }
15269                 }
15270
15271                 [self checkAppearanceRange:5 tX:y tY:x aMap:apprR];
15272
15273                 int postInt = 0;
15274                 for (int i = 0;i < 1002;i++) {
15275                     for (int k = 0;k < 1002;k++) {
15276                         if(apprR[i][k] > postInt && unitNum[i][k] == -1){
15277                             postInt = apprR[i][k];
15278                             *p = i;
15279                             *o = k;
15280                         }
15281                     }
15282                 }
15283
15284                 if(*p > 0 && *o >0){
15285                     x = *p;
15286                     y = *o;
15287                     unitTeam[x][y] = MS0->S3->team;
15288                     unitNum[x][y] = u.chipNumb;
15289                     loadNum[x][y] = u.chipNumb;
15290                     [self addAppearanceStatus:u x:x y:y];
15291                 }else{
15292                     MS0->succeessfulFlag = false;
15293                     MS0->endFlag = true;
15294                     MS0->S3 = MS3T;
15295                     return MS0;
15296                 }
15297             }
15298         }
15299         MS0->S3 = MS0->S3->next;
15300     }MS0->S3 = MS3T;
15301     unitColorInitFlag = true;
15302
15303     MS0->succeessfulFlag = true;
15304     MS0->endFlag = true;
15305     return MS0;
15306 }
15307
15308 -(MAPSCRIPT0*)setDissappearance:(MAPSCRIPT0*)MS0{
15309
15310     MS5T = MS0->S5;
15311     while(MS0->S5){
15312         int x, y;
15313         UNITCHIP u;
15314         u = MS0->S5->U;
15315         x = MS0->S5->x;
15316         y = MS0->S5->y;
15317
15318         if(1){
15319
15320
15321             if(MS0->S5->unitNum >= 0){
15322                 unitNum[x][y] = -1;
15323                 unitTeam[x][y] = -1;
15324                 unitNum[x][y] = -1;
15325                 loadNum[x][y] = -1;
15326
15327                 U = UTop;
15328                 while(U){
15329                     if(U->ix == x && U->iy == y)
15330                         break;
15331                     U = U->next;
15332                 }
15333                 if(U)
15334                     U->dead = true;
15335
15336                 U = UTop;
15337
15338             }else{
15339                 MS0->succeessfulFlag = false;
15340                 MS0->endFlag = true;
15341                 MS0->S5 = MS5T;
15342                 return MS0;
15343             }
15344
15345         }
15346         MS0->S5 = MS0->S5->next;
15347     }MS0->S5 = MS5T;
15348     unitColorInitFlag = true;
15349
15350     MS0->succeessfulFlag = true;
15351     MS0->endFlag = true;
15352     return MS0;
15353 }
15354
15355
15356 -(void)checkAppearanceRange:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap{
15357
15358     if(cnsPow < 0) return;
15359
15360     int i0;
15361     if(aMap[startY][startX] <= cnsPow)
15362         aMap[startY][startX] = cnsPow;
15363
15364     if(startY < 0) startY = 0;
15365     if(startX < 0) startX = 0;
15366     if(cnsPow < 0) cnsPow = 0;
15367
15368     i0 = cnsPow - 1;
15369
15370     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
15371         [self checkAppearanceRange:i0 tX:startX tY:startY-1 aMap:aMap];
15372
15373     i0 = cnsPow - 1;
15374     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
15375         [self checkAppearanceRange:i0 tX:startX tY:startY+1 aMap:aMap];
15376
15377     i0 = cnsPow - 1;
15378     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
15379         [self checkAppearanceRange:i0 tX:startX-1 tY:startY aMap:aMap];
15380
15381     i0 = cnsPow - 1;
15382     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
15383         [self checkAppearanceRange:i0 tX:startX+1 tY:startY aMap:aMap];
15384
15385 }
15386
15387 -(void)addAppearanceStatus:(UNITCHIP)u x:(int)x y:(int)y{
15388     registerNum++;
15389
15390     int omgCnt = 0;
15391     U = UTop;
15392     while (U->next) {omgCnt++;
15393         U = U->next;
15394     }
15395     U->next = calloc(1, sizeof(UNIT));
15396     U = U->next;
15397     U->next = NULL;
15398     if(omgCnt == 0) U = UTop;
15399     U->number = registerNum;
15400     U->chipNumber = -1;
15401     U->chipNumberL = -1;
15402     U->C.chipNumb = -1;
15403     U->CL.chipNumb = -1;
15404
15405     U->x = x;
15406     U->y = y;
15407
15408     U->C = u;
15409     if(unitTeam[x][y] == 0 || unitTeam[x][y] == 1){
15410         U->team = 0;
15411         if(unitTeam[x][y] == 1){
15412             U->joinArmyFromNext = true;
15413             U->persuasion = true;
15414         }
15415         if(MF[MFselectedRow+1].MS.playerSet1 == 2)
15416             U->CPU = true;
15417
15418     }
15419     if(unitTeam[x][y] == 2 || unitTeam[x][y] == 3){
15420         U->team = 2;
15421         if(unitTeam[x][y] == 3){
15422             U->joinArmyFromNext = true;
15423             U->persuasion = true;
15424         }
15425         if(MF[MFselectedRow+1].MS.playerSet2 == 2)
15426             U->CPU = true;
15427
15428     }
15429     if(unitTeam[x][y] == 4 || unitTeam[x][y] == 5){
15430         U->team = 1;
15431         if(unitTeam[x][y] == 5){
15432             U->joinArmyFromNext = true;
15433             U->persuasion = true;
15434         }
15435         U->CPU = true;
15436     }
15437     if(unitTeam[x][y] == -1){
15438         U->team = -1;
15439         if(unitTeam[x][y] == 0){
15440             U->joinArmyFromNext = false;
15441             U->persuasion = true;
15442         }
15443         U->CPU = true;
15444     }
15445     unitNum[x][y] = u.chipNumb;
15446     [self SetUnitStatus:unitNum[x][y]];
15447
15448     for(int i = 0;i < UCN;i++){
15449         if([U->C.nameID isEqualToString:UC[i].nameID])
15450             U->chipNumber = i;
15451     }
15452     for(int i = 0;i < LCN;i++){
15453         if([U->CL.nameID isEqualToString:LC[i].nameID])
15454             U->chipNumberL = i;
15455     }
15456     for(int i = 0;i < UCN;i++){
15457         if([U->C.nameID isEqualToString:UC[i].nameID])
15458             U->C.chipNumb = i;
15459     }
15460     for(int i = 0;i < LCN;i++){
15461         if([U->CL.nameID isEqualToString:LC[i].nameID])
15462             U->CL.chipNumb = i;
15463     }
15464
15465     registerNum++;
15466     U = UTop;
15467
15468 }
15469
15470
15471 -(MAPSCRIPT0*)setWait:(MAPSCRIPT0*)MS0{
15472
15473     static bool waitin = false;
15474
15475     if(!waitin){
15476         waitinTime = 0;
15477         waitinTime = MS0->wait;
15478
15479         waitin = true;
15480     }
15481
15482     waitSwtichFlag = true;
15483
15484     if(waitAllOverFlag){
15485         MS0->succeessfulFlag = true;
15486         MS0->endFlag = true;
15487         waitAllOverFlag = false;
15488         waitSwtichFlag = false;
15489         waitin = false;
15490         waitx10flag = false;
15491         waitinTime = 0;
15492     }
15493
15494     return MS0;
15495 }
15496
15497 -(MAPSCRIPT0*)setBGM:(MAPSCRIPT0*)MS0{
15498
15499     if(BGMsub)
15500         BGMsub = NULL;
15501
15502     BGMsub = [MS0->BGM.snd retain];
15503
15504     [BGMsub setLoops:NO];
15505     [BGMsub play];
15506
15507     MS0->succeessfulFlag = true;
15508     MS0->endFlag = true;
15509
15510     return MS0;
15511 }
15512
15513 -(MAPSCRIPT0*)setSE:(MAPSCRIPT0*)MS0{
15514
15515     if(SEsub)
15516         [SEsub stop];
15517     SEsub = [MS0->SE.snd retain];
15518
15519     [SEsub play];
15520
15521     MS0->succeessfulFlag = true;
15522     MS0->endFlag = true;
15523
15524     return MS0;
15525 }
15526
15527 -(MAPSCRIPT0*)setTitleBack:(MAPSCRIPT0*)MS0{
15528
15529     backTitleFlag = true;
15530     battleBegin = false;
15531
15532     MS0->succeessfulFlag = true;
15533     MS0->endFlag = true;
15534
15535     return MS0;
15536 }
15537
15538 -(MAPSCRIPT0*)setStageClear:(MAPSCRIPT0*)MS0{
15539
15540     stageClearFlag = true;
15541
15542     if(MS0->sc.edcdFlag)
15543         stageClearFlag2 = true;
15544     battleBegin = false;
15545
15546     MS0->succeessfulFlag = true;
15547     MS0->endFlag = true;
15548
15549     return MS0;
15550 }
15551
15552 -(MAPSCRIPT0*)setGameOver:(MAPSCRIPT0*)MS0{
15553
15554     gaov.img = MS0->gaov.img;
15555
15556     gameOverFlag = true;
15557     battleBegin = false;
15558
15559     MS0->succeessfulFlag = true;
15560     MS0->endFlag = true;
15561
15562     return MS0;
15563 }
15564
15565 -(IBAction)gameOverSubmit:(id)sender{
15566
15567
15568     gaov.img = nil;
15569
15570     [BGMsub stop];
15571     BGMsub = NULL;
15572
15573     [GameOverWindow close];
15574     [titleWindow makeKeyAndOrderFront:nil];
15575
15576 }
15577
15578 -(IBAction)battleReadyUpStartBtn:(id)sender{
15579
15580
15581     P[0].resource = [battleReadyUpSupply1 intValue];
15582     P[0].food = [battleReadyUpFood1 intValue];
15583     P[0].money = [battleReadyUpMoney1 intValue];
15584
15585     P[1].resource = [battleReadyUpSupply2 intValue];
15586     P[1].food = [battleReadyUpFood2 intValue];
15587     P[1].money = [battleReadyUpMoney2 intValue];
15588
15589     setBattleModeFlag = false;
15590     [bsWindow close];
15591
15592 }
15593
15594 -(IBAction)battleReadyUpState1:(id)sender{
15595     retardhelp1 = true;
15596 }
15597 -(IBAction)battleReadyUpState2:(id)sender{
15598     retardhelp2 = true;
15599 }
15600
15601
15602
15603
15604
15605
15606
15607 -(IBAction)selectionBtn1:(id)sender{
15608     slctedBtnNum = 1;
15609     [selectionWindow close];
15610 }
15611 -(IBAction)selectionBtn2:(id)sender{
15612     slctedBtnNum = 2;
15613     [selectionWindow close];
15614 }
15615 -(IBAction)selectionBtn3:(id)sender{
15616     slctedBtnNum = 3;
15617     [selectionWindow close];
15618 }
15619 -(IBAction)selectionBtn4:(id)sender{
15620     slctedBtnNum = 4;
15621     [selectionWindow close];
15622 }
15623 -(IBAction)selectionBtn5:(id)sender{
15624     slctedBtnNum = 5;
15625     [selectionWindow close];
15626 }
15627 -(IBAction)selectionBtn6:(id)sender{
15628     slctedBtnNum = 6;
15629     [selectionWindow close];
15630 }
15631 -(IBAction)selectionBtn7:(id)sender{
15632     slctedBtnNum = 7;
15633     [selectionWindow close];
15634 }
15635 -(IBAction)selectionBtn8:(id)sender{
15636     slctedBtnNum = 8;
15637     [selectionWindow close];
15638 }
15639 -(IBAction)selectionBtn9:(id)sender{
15640     slctedBtnNum = 9;
15641     [selectionWindow close];
15642 }
15643
15644
15645
15646 -(void)HensuuLoad{
15647
15648     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
15649     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
15650
15651
15652     NSData *InitialData = [NSData dataWithContentsOfFile:@"data/Others/var.txt"];
15653     NSString *pathVar = @"data/Others/var.txt";
15654     NSString *fileData = @"";
15655
15656     if(!InitialData){
15657         [[NSFileManager defaultManager] createFileAtPath:pathVar contents:nil attributes:nil];
15658     }
15659
15660     HensuuNum = 0;
15661     fileData = [NSString stringWithContentsOfFile:pathVar encoding:NSUTF8StringEncoding error:nil];
15662     NSArray *fileDataArray = [fileData componentsSeparatedByString:@"\n"];
15663
15664     for(int i = 0;i < [fileDataArray count];i++){
15665
15666         NSArray *item = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
15667
15668         Hensuu[i] = [[item objectAtIndex:1] retain];
15669         HensuuName[i] = [[item objectAtIndex:2] retain];
15670         HensuuNum++;
15671     }
15672
15673
15674 }
15675
15676
15677 -(void)displaySideMenu{
15678
15679     [FSMenu setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - FSMenu.frame.size.width/2,
15680                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - FSMenu.frame.size.height/2)];
15681     [menuPanel close];
15682     moveFlag = false;
15683     attackFlag = false;
15684     summonFlag = false;
15685     menuDisplayFlag = false;
15686     [FSMenu makeKeyAndOrderFront:nil];
15687
15688     coolTime = true;
15689 }
15690
15691 -(IBAction)FSVsave:(id)sender{
15692
15693     [saveGamePanel setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - saveGamePanel.frame.size.width/2,
15694                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - saveGamePanel.frame.size.height/2)];
15695
15696     [self saveGameDataDatViewImage];
15697
15698     [saveGameTF setStringValue:@""];
15699
15700     [saveGamePanel makeKeyAndOrderFront:nil];
15701
15702 }
15703
15704 -(IBAction)FSVtitle:(id)sender{
15705
15706     stopByFSVmenuFlag = false;
15707     [BGMsub stop];
15708     BGMsub = NULL;
15709     if(titleBGM) [titleBGM play];
15710
15711     [titleWindow makeKeyAndOrderFront:nil];
15712     [fsWindow close];
15713     [FSMenu close];
15714
15715     esSceneProc = 0;
15716
15717
15718     endGameCondition = false;
15719     initMapFlag = false;
15720     TeamCountFlag = false;
15721     initStatusFlag = false;
15722     battleBegin = false;
15723     startES = false;
15724
15725     cpuModeMOVEflag = false;
15726     cpuModeATTACKflag = false;
15727
15728     redWinFlag = false;
15729     blueWinFlag = false;
15730     cpuAImodeflag = false;
15731     cpuTurnEndFlag = true;
15732     backTitleFlag = false;
15733     backTitleFlag2 = true;
15734     waitSwtichFlag = false;
15735     battleReadyUpFlag = false;
15736     setBattleModeFlag = false;
15737     mapChipDataLoadProc = 0;
15738
15739     wtRdy = false;
15740     wtRdy2 = false;
15741
15742     Uselected = NULL;
15743
15744 }
15745 -(IBAction)FSVcancel:(id)sender{
15746
15747     stopByFSVmenuFlag = false;
15748     coolTime = false;
15749     [FSMenu close];
15750
15751 }
15752
15753
15754 -(void)displaySaveFileDialog{
15755
15756     [saveDataList initFileDirectory];
15757     [self initSaveFileInputList];
15758     [saveFileDialog makeKeyAndOrderFront:nil];
15759 }
15760
15761
15762 -(IBAction)saveFileInputSubmit:(id)sender{
15763
15764     if([saveFileInputTF stringValue] == nil || [[saveFileInputTF stringValue] isEqualToString:@""]){
15765         return;
15766     }
15767
15768     saveFileNameSDL = [[saveFileInputTF stringValue] retain];
15769     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
15770     [saveDataList saveSaveList];
15771     [levelList saveLevelList];
15772
15773     [titleWindow makeKeyAndOrderFront:nil];
15774     [saveFileInputPanel close];
15775 }
15776 -(IBAction)saveFileInputCancel:(id)sender{
15777
15778
15779     [titleWindow makeKeyAndOrderFront:nil];
15780     [saveFileInputPanel close];
15781 }
15782
15783 -(IBAction)saveFileDialogSubmit:(id)sender{
15784
15785     saveFileFlag = true;
15786     [saveFileInputPanel makeKeyAndOrderFront:nil];
15787     [fsWindow close];
15788     [saveFileDialog close];
15789
15790 }
15791 -(IBAction)saveFileDialogCancel:(id)sender{
15792
15793     saveFileNameSDL = [@"preset.txt" retain];
15794     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
15795     [saveDataList saveSaveList];
15796
15797     saveFileFlag = true;
15798     [titleWindow makeKeyAndOrderFront:nil];
15799
15800     [fsWindow close];
15801     [saveFileDialog close];
15802
15803 }
15804
15805 -(void)initSaveFileInputList{
15806
15807     [self willChangeValueForKey:@"saveFileInputListMA"];
15808     [saveFileInputListMA removeAllObjects];
15809     [self didChangeValueForKey:@"saveFileInputListMA"];
15810
15811
15812     for(int i = 1;i <= saveNumb;i++){
15813
15814
15815         NSMutableDictionary* dict = [NSMutableDictionary new];
15816         [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
15817         [self willChangeValueForKey:@"saveFileInputListMA"];
15818         [saveFileInputListMA addObject:dict];
15819         [self didChangeValueForKey:@"saveFileInputListMA"];
15820     }
15821
15822 }
15823
15824 -(void)initLoadFileOutputList{
15825
15826     [self willChangeValueForKey:@"loadFileOutputListMA"];
15827     [loadFileOutputListMA removeAllObjects];
15828     [self didChangeValueForKey:@"loadFileOutputListMA"];
15829
15830
15831     for(int i = 1;i <= saveNumb;i++){
15832
15833
15834         if([SC[storyNumb].name isEqualToString:SDL[i].levelName]){
15835             NSMutableDictionary* dict = [NSMutableDictionary new];
15836             [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
15837             [self willChangeValueForKey:@"loadFileOutputListMA"];
15838             [loadFileOutputListMA addObject:dict];
15839             [self didChangeValueForKey:@"loadFileOutputListMA"];
15840         }
15841     }
15842
15843     LFOLrow = -1;
15844     [loadFileOutputListAC setSelectionIndex:9999];
15845
15846     [loadFileOutputTF setStringValue:[NSString stringWithFormat:@""]];
15847
15848     [loadFileOutputPanel makeKeyAndOrderFront:nil];
15849
15850 }
15851
15852 -(IBAction)loadFileOutputSubmit:(id)sender{
15853
15854     if(LFOLrow < 0)
15855         return;
15856
15857     SC[storyNumb].saveFileName = [SDL[SDLrow+1].name retain];
15858     SC[storyNumb].CrntLevelName = [SDL[SDLrow+1].levelName retain];
15859     SC[storyNumb].scenarioNumbCrnt[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbCrnt];
15860     SC[storyNumb].scenarioNumbNext[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbNext];
15861
15862     [levelList saveLevelList];
15863     [scenarioList initFileDirectory];
15864     [mapEditor initFileDirectoryOthers];
15865     [scenarioList setScenarioList:selectNumb];
15866
15867     [loadFileOutputPanel close];
15868 }
15869
15870 -(void)initFileOutPutListSet{
15871
15872     SC[storyNumb].saveFileName = NULL;
15873
15874     [levelList saveLevelList];
15875     [scenarioList setScenarioList:selectNumb];
15876 }
15877
15878 -(IBAction)loadFileOutputCancel:(id)sender{
15879
15880     [loadFileOutputPanel close];
15881 }
15882
15883
15884
15885
15886
15887
15888
15889
15890 -(IBAction)saveGameSubmit:(id)sender{
15891
15892     if([[saveGameTF stringValue] isEqualToString:@""])
15893         return;
15894
15895     sdd.name = [[saveGameTF stringValue] retain];
15896     datFilePath = calloc(255, sizeof(char));
15897     strcpy(datFilePath, [sdd.name UTF8String]);
15898
15899     [self saveGameDataDatViewImage];
15900     [self saveGameDataDat];
15901     [saveDataList initSaveList];
15902
15903     [saveGamePanel close];
15904
15905 }
15906
15907 -(void)saveGameDataDatViewImage{
15908
15909     NSString *directoryPath;
15910
15911     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
15912     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
15913
15914     [fieldView lockFocus];
15915     NSBitmapImageRep* rep = [fieldView bitmapImageRepForCachingDisplayInRect:fieldView.bounds];
15916     [fieldView cacheDisplayInRect:fieldView.bounds toBitmapImageRep:rep];
15917     [fieldView unlockFocus];
15918
15919     NSMutableData* data = [rep representationUsingType:NSPNGFileType properties:nil];
15920     sdd.img = [[[NSImage alloc] initWithData:data] retain];
15921
15922     [saveGameIV setImage:sdd.img];
15923     [saveGameIV setImageScaling:NSScaleToFit];
15924
15925
15926     NSString *path = @"SaveData/";
15927
15928     NSArray *ary = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:nil];
15929
15930     [SAV removeAllObjects];
15931     for(NSString *name in ary){
15932
15933         NSArray *arr = [name componentsSeparatedByString:@".sav"];
15934
15935         if([arr count] > 1){
15936             [SAV addObject:name];
15937         }
15938     }
15939
15940     [self willChangeValueForKey:@"saveGameListMA"];
15941     [saveGameListMA removeAllObjects];
15942     [self didChangeValueForKey:@"saveGameListMA"];
15943
15944     for(int i = 0;i < [SAV count];i++){
15945
15946         NSMutableDictionary* dict = [NSMutableDictionary new];
15947         [dict setValue:[NSString stringWithFormat:@"%@", SAV[i]] forKey:@"name"];
15948
15949         [self willChangeValueForKey:@"saveGameListMA"];
15950         [saveGameListMA addObject:dict];
15951         [self didChangeValueForKey:@"saveGameListMA"];
15952
15953     }
15954
15955     [saveGameListAC setSelectionIndex:9999];
15956
15957 }
15958
15959 -(void)loadGameDataDat{
15960
15961     if(!datFilePath)
15962         return;
15963
15964
15965
15966     [self loadStruct];
15967
15968
15969     NSString *directoryPath;
15970     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
15971     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
15972
15973
15974     NSString *path = @"SaveData/";
15975     path = [path stringByAppendingString:SAV[SDLrow]];
15976
15977     NSData *data = [[NSData alloc] initWithContentsOfFile:path];
15978
15979     MFselectedRow = sdd2[datRow].MFselectedRow;
15980     MF[MFselectedRow+1].fileName = sdd2[datRow].mapfileName;
15981
15982     storyNumb = sdd2[datRow].storyNumb;
15983     scenarioNumb = sdd2[datRow].scenarioNumb;
15984
15985     SC[storyNumb].name = sdd2[datRow].levelName;
15986     SC[storyNumb].nameMAP[scenarioNumb] = sdd2[datRow].scenarioName;
15987
15988     posX = sdd2[datRow].posX;
15989     posX = sdd2[datRow].posY;
15990
15991     chipHeight = sdd2[datRow].chipHeight;
15992     chipWidth = sdd2[datRow].chipWidth;
15993     eSlctX = sdd2[datRow].eSlctX;
15994     eSlctY = sdd2[datRow].eSlctY;
15995
15996     registerNum = sdd2[datRow].registerNum;
15997     registerNumB = sdd2[datRow].registerNumB;
15998
15999     esSceneProc = sdd2[datRow].esSceneProc;
16000
16001     endGameCondition = sdd2[datRow].endGameCondition;
16002     initMapFlag = sdd2[datRow].initMapFlag;
16003     TeamCountFlag = sdd2[datRow].TeamCountFlag;
16004     initStatusFlag = sdd2[datRow].initStatusFlag;
16005     battleBegin = sdd2[datRow].battleBegin;
16006     startES = sdd2[datRow].startES;
16007
16008     cpuAImodeflag = sdd2[datRow].cpuAImodeflag;
16009     cpuTurnEndFlag = sdd2[datRow].cpuTurnEndFlag;
16010     cpuModeMOVEflag = sdd2[datRow].cpuModeMOVEflag;
16011     cpuModeATTACKflag = sdd2[datRow].cpuModeATTACKflag;
16012     waitSwtichFlag = sdd2[datRow].waitSwtichFlag;
16013     battleReadyUpFlag = sdd2[datRow].battleReadyUpFlag;
16014     setBattleModeFlag = sdd2[datRow].setBattleModeFlag;
16015
16016     wtRdy = sdd2[datRow].wtRdy;
16017     wtRdy2 = sdd2[datRow].wtRdy2;
16018     wtRdy3 = sdd2[datRow].wtRdy3;
16019
16020     wtMovedFlag = sdd2[datRow].wtMovedFlag;
16021     wtAttackedFlag = sdd2[datRow].wtAttackedFlag;
16022     unitMoveEndFlag = sdd2[datRow].unitMoveEndFlag;
16023     battleSetUp = sdd2[datRow].battleSetUp;
16024     pushStanbyFlag = sdd2[datRow].pushStanbyFlag;
16025     battleEndFlag = sdd2[datRow].battleEndFlag;
16026     wtUnitNum = sdd2[datRow].wtUnitNum;
16027     messageDialog = sdd2[datRow].messageDialog;
16028
16029 /*
16030     for(int i = 0;i < 1002;i++){
16031         for(int j = 0;j < 1002;j++){
16032             chipNum[i][j] = sdd2[datRow].chipNum[i][j];
16033         }
16034     }
16035
16036     for(int i = 0;i < 1002;i++){
16037         for(int j = 0;j < 1002;j++){
16038             buildNum[i][j] = sdd2[datRow].buildNum[i][j];
16039         }
16040     }
16041
16042     for(int i = 0;i < 1002;i++){
16043         for(int j = 0;j < 1002;j++){
16044             unitNum[i][j] = sdd2[datRow].unitNum[i][j];
16045         }
16046     }
16047
16048     for(int i = 0;i < 1002;i++){
16049         for(int j = 0;j < 1002;j++){
16050             loadNum[i][j] = sdd2[datRow].loadNum[i][j];
16051         }
16052     }
16053
16054     for(int i = 0;i < 1002;i++){
16055         for(int j = 0;j < 1002;j++){
16056             buildTeam[i][j] = sdd2[datRow].buildTeam[i][j];
16057         }
16058     }
16059
16060     for(int i = 0;i < 1002;i++){
16061         for(int j = 0;j < 1002;j++){
16062             unitTeam[i][j] = sdd2[datRow].unitTeam[i][j];
16063         }
16064     }
16065 */
16066
16067     P[0] = sdd2[datRow].P[0];
16068     P[1] = sdd2[datRow].P[1];
16069     P[2] = sdd2[datRow].P[2];
16070
16071     for(int i = 0;i < 9999;i++)
16072         Suicchi[i] = sdd2[datRow].Suicchi[i];
16073
16074     sdd.HensuuNum = HensuuNum;
16075     for(int i = 0;i < 65000;i++)
16076         Hensuu[i] = [sdd2[datRow].Hensuu[i] retain];
16077     for(int i = 0;i < 65000;i++)
16078         HensuuName[i] = [sdd2[datRow].HensuuName[i] retain];
16079
16080     MF[MFselectedRow+1].MS = sdd2[datRow].MS;
16081     MF[MFselectedRow+1].MS.D = sdd2[datRow].MS.D;
16082
16083     /*
16084      UTop = sdd.UTop;
16085      BTop = sdd.BTop;
16086
16087
16088      Uselected = sdd.Uselected;
16089      unitBreak = sdd.unitBreak;
16090      Utarget = sdd.Utarget;
16091
16092      */
16093
16094     //NSLog(@"%d", MF[MFselectedRow+1].MS.playerSet1);
16095 }
16096
16097 -(void)saveGameDataDat{
16098     //おまんこ
16099
16100
16101     sdd.name = [[saveGameTF stringValue] retain];
16102
16103     sdd.MFselectedRow = MFselectedRow;
16104     sdd.storyNumb = storyNumb;
16105     sdd.scenarioNumb = scenarioNumb;
16106
16107     sdd.mapfileName = [MF[MFselectedRow+1].fileName retain];
16108     sdd.levelName = [SC[storyNumb].name retain];
16109     sdd.scenarioName = [SC[storyNumb].nameMAP[scenarioNumb] retain];
16110
16111     sdd.posX = posX;
16112     sdd.posX = posY;
16113
16114     sdd.chipHeight = chipHeight;
16115     sdd.chipWidth = chipWidth;
16116     sdd.eSlctX = eSlctX;
16117     sdd.eSlctY = eSlctY;
16118
16119     sdd.registerNum = registerNum;
16120     sdd.registerNumB = registerNumB;
16121
16122     sdd.esSceneProc = esSceneProc;
16123
16124     sdd.endGameCondition = endGameCondition;
16125     sdd.initMapFlag = initMapFlag;
16126     sdd.TeamCountFlag = TeamCountFlag;
16127     sdd.initStatusFlag = initStatusFlag;
16128     sdd.battleBegin = battleBegin;
16129     sdd.startES = startES;
16130
16131     sdd.cpuModeMOVEflag = cpuModeMOVEflag;
16132     sdd.cpuModeATTACKflag = cpuModeATTACKflag;
16133
16134     sdd.cpuAImodeflag = cpuAImodeflag;
16135     sdd.cpuTurnEndFlag = cpuTurnEndFlag;
16136     sdd.waitSwtichFlag = waitSwtichFlag;
16137     sdd.battleReadyUpFlag = battleReadyUpFlag;
16138     sdd.setBattleModeFlag = setBattleModeFlag;
16139
16140
16141     sdd.wtRdy = wtRdy;
16142     sdd.wtRdy2 = wtRdy2;
16143     sdd.wtRdy3 = wtRdy3;
16144
16145
16146     sdd.wtMovedFlag = wtMovedFlag;
16147     sdd.wtAttackedFlag = wtAttackedFlag;
16148     sdd.unitMoveEndFlag = unitMoveEndFlag;
16149     sdd.battleSetUp = battleSetUp;
16150     sdd.pushStanbyFlag = pushStanbyFlag;
16151     sdd.battleEndFlag = battleEndFlag;
16152     sdd.wtUnitNum = wtUnitNum;
16153     sdd.messageDialog = messageDialog;
16154
16155     /*
16156     for(int i = 0;i < 1002;i++){
16157         for(int j = 0;j < 1002;j++){
16158             sdd.chipNum[i][j] = chipNum[i][j];
16159         }
16160     }
16161
16162     for(int i = 0;i < 1002;i++){
16163         for(int j = 0;j < 1002;j++){
16164             sdd.buildNum[i][j] = buildNum[i][j];
16165         }
16166     }
16167
16168     for(int i = 0;i < 1002;i++){
16169         for(int j = 0;j < 1002;j++){
16170             sdd.unitNum[i][j] = unitNum[i][j];
16171         }
16172     }
16173
16174     for(int i = 0;i < 1002;i++){
16175         for(int j = 0;j < 1002;j++){
16176             sdd.loadNum[i][j] = loadNum[i][j];
16177         }
16178     }
16179
16180     for(int i = 0;i < 1002;i++){
16181         for(int j = 0;j < 1002;j++){
16182             sdd.buildTeam[i][j] = buildTeam[i][j];
16183         }
16184     }
16185
16186     for(int i = 0;i < 1002;i++){
16187         for(int j = 0;j < 1002;j++){
16188             sdd.unitTeam[i][j] = unitTeam[i][j];
16189         }
16190     }
16191     */
16192
16193     U = UTop;
16194     int r = 0;
16195     while(U && r < registerNum){
16196         sdd.dU[r].CPU = U->CPU;
16197         sdd.dU[r].number = U->number;
16198         sdd.dU[r].team = U->team;
16199         sdd.dU[r].chipNumber = U->chipNumber;
16200         sdd.dU[r].chipNumberL = U->chipNumberL;
16201
16202         sdd.dU[r].x = U->x;
16203         sdd.dU[r].y = U->y;
16204         sdd.dU[r].z = U->z;
16205
16206         sdd.dU[r].ix = U->ix;
16207         sdd.dU[r].iy = U->iy;
16208         sdd.dU[r].iz = U->iz;
16209
16210         sdd.dU[r].dead = U->dead;
16211
16212         sdd.dU[r].loadChipFlag = U->loadChipFlag;
16213
16214         sdd.dU[r].unControlable = U->unControlable;
16215         sdd.dU[r].joinArmyFromNext = U->joinArmyFromNext;
16216         sdd.dU[r].persuasion = U->persuasion;
16217
16218         sdd.dU[r].targType1L = U->targType1L;
16219         sdd.dU[r].targType2L = U->targType2L;
16220         sdd.dU[r].targType1D = U->targType1D;
16221         sdd.dU[r].targType2D = U->targType2D;
16222
16223         sdd.dU[r].army = U->army;
16224         sdd.dU[r].img = [U->img retain];
16225
16226         sdd.dU[r].C.chipNumb = U->C.chipNumb;
16227         sdd.dU[r].C.name = [U->C.name retain];
16228         sdd.dU[r].C.nameNick = [U->C.nameNick retain];
16229         sdd.dU[r].C.nameClass = [U->C.nameClass retain];
16230         sdd.dU[r].C.nameID = [U->C.nameID retain];
16231
16232         sdd.dU[r].C.R_C = U->C.R_C;
16233         sdd.dU[r].C.S_C = U->C.S_C;
16234
16235         U = U->next;
16236         r++;
16237     }U = UTop;
16238
16239     B = BTop;
16240     r = 0;
16241     while(B && r < registerNumB){
16242         sdd.dB[r].number = B->number;
16243         sdd.dB[r].team = B->team;
16244         sdd.dB[r].chipNumber = B->chipNumber;
16245         sdd.dB[r].makeLv = B->makeLv;
16246
16247         sdd.dB[r].x = B->x;
16248         sdd.dB[r].y = B->y;
16249         sdd.dB[r].z = B->z;
16250
16251         sdd.dB[r].dead = B->dead;
16252
16253         sdd.dB[r].img = [B->img retain];
16254         sdd.dB[r].C.chipNumb = B->C.chipNumb;
16255         sdd.dB[r].C.name = [B->C.name retain];
16256         sdd.dB[r].C.nameID = [B->C.nameID retain];
16257         sdd.dB[r].C.S_C = B->C.S_C;
16258
16259         B = B->next;
16260         r++;
16261     }B = BTop;
16262
16263     sdd.P[0] = P[0];
16264     sdd.P[1] = P[1];
16265     sdd.P[2] = P[2];
16266
16267
16268     for(int i = 0;i < 9999;i++)
16269         sdd.Suicchi[i] = Suicchi[i];
16270
16271     sdd.HensuuNum = HensuuNum;
16272     for(int i = 0;i < 65000;i++)
16273         sdd.Hensuu[i] = [Hensuu[i] retain];
16274     for(int i = 0;i < 65000;i++)
16275         sdd.HensuuName[i] = [HensuuName[i] retain];
16276
16277     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
16278
16279      sdd.MS = MS;
16280
16281     /*
16282      sdd->UTop = UTop;
16283      sdd->BTop = BTop;
16284      */
16285
16286
16287     [self saveStruct];
16288 }
16289
16290 -(NSData *)sddToNSData:(NSString *) path{
16291
16292     /*
16293     NSData *archivedData = [NSKeyedArchiver archivedDataWithRootObject:sdd];
16294
16295     [archivedData writeToFile:path atomically:YES];
16296
16297     return archivedData;
16298     */
16299
16300
16301 }
16302
16303 -(IBAction)saveGameCancel:(id)sender{
16304
16305     [saveGamePanel close];
16306
16307 }
16308
16309 @end
16310
16311
16312
16313
16314
16315 @implementation FieldSceneEF
16316
16317
16318 -(BOOL)isFlipped{
16319     return YES;
16320 }
16321
16322 - (id)initWithFrame:(NSRect)frame
16323 {
16324     self = [super initWithFrame:frame];
16325     if (self) {
16326         // Initialization code here.
16327         time  = [NSTimer
16328                  scheduledTimerWithTimeInterval:0.015
16329                  target:self
16330                  selector:@selector(EventLoopBV:)
16331                  userInfo:nil
16332                  repeats:YES
16333                  ];
16334     }
16335
16336     return self;
16337 }
16338
16339 -(void)scrollWheel:(NSEvent *)theEvent{
16340
16341     theEvent = NULL;
16342
16343 }
16344
16345 -(void)EventLoopBV:(NSTimer*)timer{
16346
16347     [battleView setNeedsDisplay:YES];
16348
16349     static int aniFrame = 0;
16350
16351     if(animationFlag3){
16352         aniFrame = 0;
16353         aniFrameCnt = 0;
16354         return;
16355     }
16356
16357     if(!animationFlag1 && !animationFlag2){
16358         aniFrame = 0;
16359         aniFrameCnt = 0;
16360         return;
16361     }
16362
16363     U = effCun;
16364
16365     if(animationFlag1)
16366         U->C.A = attackCR;
16367     if(animationFlag2)
16368         U->C.A = attackCR2;
16369
16370     static bool pussyMikoto = false;
16371
16372     if(aniFrame == 0){
16373
16374         ani = U->C.A->AN.ANI;
16375         ANI *aniTop = ani;
16376
16377         for (int i = 0; i < aniFrameCnt;i++) {
16378             ani = ani->next;
16379         }
16380
16381         if(ani->snd){
16382             [ani->snd setCurrentTime:0];
16383             [ani->snd play];
16384             ani->snd.loops = NO;
16385         }
16386         if(!ani->next){
16387             pussyMikoto = true;
16388         }
16389         ani = aniTop;
16390
16391         U->C.A->AN.ANI = ani;
16392     }
16393
16394     if(aniFrame < U->C.A->AN.frame){
16395         aniFrame++;
16396     }else{
16397         aniFrame = 0;
16398         aniFrameCnt++;
16399         if(pussyMikoto){
16400             pussyMikoto = false;
16401             animationFlag3 = true;
16402         }
16403     }
16404
16405
16406
16407
16408
16409     [self setNeedsDisplay:YES];
16410
16411
16412 }
16413
16414 -(void)DrawImage:(NSImage*)image x:(float)x y:(float)y a:(float)a{
16415     NSRect frRect;
16416     frRect.size.height = image.size.height;
16417     frRect.size.width = image.size.width;
16418
16419     frRect.origin.x = 0;
16420     frRect.origin.y = 0;
16421
16422     NSRect drRect;
16423     drRect.origin.x = x;
16424     drRect.origin.y = y;
16425     drRect.size.height = image.size.height;
16426     drRect.size.width = image.size.width;
16427
16428     [image drawInRect:drRect fromRect:frRect operation:NSCompositeSourceOver fraction:a respectFlipped:YES hints:nil];
16429
16430 }
16431
16432 - (void)drawRect:(NSRect)dirtyRect
16433 {
16434     // Drawing code here.
16435     if(animationFlag3) return;
16436
16437
16438
16439
16440     if(animationFlag1 || animationFlag2){
16441         U = effCun;
16442
16443         if(animationFlag1)
16444                 U->C.A = attackCR;
16445         if(animationFlag2)
16446             U->C.A = attackCR2;
16447
16448     ani = U->C.A->AN.ANI;
16449
16450     ANI *aniTop = ani;
16451
16452
16453     for (int i = 0; i < aniFrameCnt;i++) {
16454         ani = ani->next;
16455     }
16456         if(!ani)
16457         {
16458             ani = aniTop;
16459             return;
16460         }
16461     [self DrawImage:ani->img x:ani->x + ani->ax y:ani->y + ani->ay a:1.0f];
16462     ani = aniTop;
16463     }
16464
16465
16466
16467
16468 }
16469
16470
16471
16472
16473
16474
16475
16476
16477
16478
16479 @end
16480
16481
16482
16483
16484
16485
16486
16487
16488