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
4148             if(!(AVpreview.rate > 0) && !animationFlag1 && !animationFlag2)
4149                 oopsCnt--;
4150             if(oopsCnt > 0)
4151                 return;
4152             else{
4153                 //cpu攻撃ナビ
4154             }
4155
4156             bLoopFlag = false;
4157         }
4158     }
4159     damnitFixFlag = true;
4160     if(!datFileLoadCompFromTitle && initMapFlag && !battleIsProcFlag){
4161         [self EventFunc:true];
4162         if(crapBugFixFlag){
4163             crapBugFixFlag = false;
4164             return;
4165         }
4166     }
4167
4168     if(damnitFixFlag)
4169     if(battleSetUp && fuckingLoadBugFix && Uselected && !attackingWait){
4170         if(!battleSetUpIgnore && fuckingLoadBugFix){
4171             [self AttackDisplay];
4172
4173             windowPoint.x = [mapWindow frame].origin.x;
4174             windowPoint.y = [mapWindow frame].origin.y;
4175             [battleWindow setFrameOrigin:windowPoint];
4176             [battleWindow makeKeyAndOrderFront:nil];
4177         }else if(battleSetUpIgnore){
4178             [mapWindow makeKeyAndOrderFront:nil];
4179         }else{
4180             /*
4181             windowPoint.x = [mapWindow frame].origin.x;
4182             windowPoint.y = [mapWindow frame].origin.y;
4183             [battleWindow setFrameOrigin:windowPoint];
4184             [battleWindow makeKeyAndOrderFront:nil];*/
4185
4186         }
4187
4188     }
4189
4190     U = UTop;
4191
4192     if(battleRdy && battleSetUp && fuckingLoadBugFix && !battleSetUpIgnore){
4193         [self DisplayMessage];
4194     }
4195
4196     if(wtRdy3)
4197         return;
4198     U = UTop;
4199     U = unitBreak;
4200     if(battleBegin && !wtRdy2 && !battleFlag)
4201         while (!wtRdy) {
4202             wtPx = 0;
4203             wtPy = 0;
4204             //NSLog(@"eventTime%g", eventTime);
4205
4206             while (U) {
4207                 if(!U->dead && U->C.S_C.WT > 0) U->C.S_C.WT -= 1;
4208                 if(U->dead) {
4209                     U->C.S_C.WT = 999999;
4210                     //goto lolwtfshit;
4211                 }
4212                 if(U->C.S_C.WT <= 0 && !U->dead){//WTターン周り
4213                     battleEndFlag = false;
4214                     U->C.S_C.WT = 0;
4215
4216
4217                     wtUnitNum = U->number;
4218                     wtPx = U->x;
4219                     wtPy = U->y;
4220                     wtRdy = true;
4221                     wtRdy2 = true;
4222                     unitBreak = U;
4223                     Uselected = U;
4224                     possionX = unitBreak->x;
4225                     possionY = unitBreak->y;
4226                     //おまんちん
4227                     stanbyFlag = false;
4228                     wtMovedFlag = false;
4229                     wtAttackedFlag = false;
4230                     guildRE1 = false;
4231                     guildRE2 = false;
4232
4233                     [fieldView scrollPoint:NSMakePoint((wtPx-8)*32, (wtPy-8)*32)];
4234
4235
4236                     if(buildNum[U->x][U->y] >= 0){
4237                         B = BTop;
4238                         while(B){
4239
4240                             if(B->x == U->x && B->y == U->y){
4241                                 break;
4242                             }
4243                             B = B->next;
4244                         }
4245
4246                         if(!B){
4247                             B = BTop;
4248                             goto wtfshit;
4249
4250                         }
4251
4252                         if(B->C.recHP > 0){
4253                             U->C.S_C.HP += floor(U->C.S_M.HP*B->C.recHP/100);
4254                             if(U->C.S_C.HP >= U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
4255                         }
4256
4257                         if(B->C.recMP > 0){
4258                             U->C.S_C.MP += floor(U->C.S_M.MP*B->C.recMP/100);
4259                             if(U->C.S_C.MP >= U->C.S_M.MP) U->C.S_C.MP = U->C.S_M.MP;
4260                         }
4261
4262                         if(B->C.recEN > 0){
4263                             U->CL.S_C.EN += floor(U->CL.S_M.EN*B->C.recEN/100);
4264                             if(U->CL.S_C.EN >= U->CL.S_M.EN) U->CL.S_C.EN = U->CL.S_M.EN;
4265                         }
4266
4267                         if(B->C.recHPL > 0){
4268                             U->CL.S_C.HP += floor(U->CL.S_M.HP*B->C.recHPL/100);
4269                             if(U->CL.S_C.HP >= U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
4270                         }
4271
4272
4273                         B = BTop;
4274                     }
4275
4276
4277                     U = UTop;
4278
4279                     [self EventFunc:false];
4280                     pussyCumsOnlyOnceFlag = false;
4281
4282                     goto lolwtfshit;
4283                 }
4284
4285             wtfshit:{}
4286
4287                 U = U->next;
4288                 if(!U) {
4289                     BTop = B;
4290                     while(B){
4291                         if(!B->dead) B->C.S_C.WTE -= 1;
4292                         if(B->C.S_C.WTE <= 0){
4293
4294                             if(B->team == 0){
4295                                 P[0].resource += B->C.Esupply;
4296                                 P[0].food += B->C.Efood;
4297                                 P[0].money += B->C.Emoney;
4298                             }
4299                             if(B->team == 2){
4300                                 P[1].resource += B->C.Esupply;
4301                                 P[1].food += B->C.Efood;
4302                                 P[1].money += B->C.Emoney;
4303                             }
4304                             if(B->team == 1){
4305                                 P[2].resource += B->C.Esupply;
4306                                 P[2].food += B->C.Efood;
4307                                 P[2].money += B->C.Emoney;
4308                             }
4309
4310                             B->C.S_C.WTE = B->C.S_M.WTE;
4311                         }
4312                         B = B->next;
4313                     }B = BTop;
4314                 }
4315             }
4316             eventTime++;
4317             U = UTop;
4318
4319             //NSLog(@"%g", eventTime);
4320             [self EventFunc:false];
4321
4322             pussyCumsOnlyOnceFlag = false;
4323             wtRdy = false;
4324             //NSLog(@"eventTime%g", eventTime);
4325             if(!U) break;
4326             //if(wtRdy3) break;
4327
4328         }
4329     lolwtfshit:{}
4330     U = UTop;
4331
4332
4333
4334
4335
4336
4337
4338
4339
4340     if(buildSelectedFlag){
4341         windowPoint.x = [mapWindow frame].origin.x;
4342         windowPoint.y = [mapWindow frame].origin.y;
4343         [researchPanel setFrameOrigin:windowPoint];
4344         if([self setBuildList]){
4345             [researchPanel makeKeyAndOrderFront:nil];
4346         };
4347         buildSelectedFlag = false;
4348     }
4349
4350     if(TeamCountFlag && !endGameCondition){
4351         U = UTop;
4352         TeamCount0 = 0;
4353         TeamCount2 = 0;
4354         while(U){
4355             if((U->team == 0 || U->team == 1) && !U->dead){
4356                 TeamCount0++;
4357             }
4358             else if(U->team == 2 && !U->dead){
4359                 TeamCount2++;
4360             }
4361             U = U->next;
4362         }
4363         U = UTop;
4364
4365
4366         if(targType1cnt[1] == 0 || targType2cnt[1] == 0){
4367             endGameCondition = true;
4368             redWinFlag = true;
4369             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4370
4371         }
4372         if(targType1cnt[0] == 0 || targType2cnt[0] == 0){
4373             endGameCondition = true;
4374             blueWinFlag = true;
4375             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4376
4377         }
4378
4379         if(targType2Dflag){
4380             endGameCondition = true;
4381             redWinFlag = true;
4382             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4383
4384         }
4385         if(targType2Lflag){
4386             endGameCondition = true;
4387             blueWinFlag = true;
4388             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4389
4390         }
4391
4392         if(TeamCount0 == 0 && (MF[MFselectedRow+1].MS.EGCdark.endType1 == 2 || MF[MFselectedRow+1].MS.EGCdark.endType2 == 2)){
4393             endGameCondition = true;
4394             redWinFlag = true;
4395             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4396         }
4397         if(TeamCount2 == 0 && (MF[MFselectedRow+1].MS.EGClight.endType1 == 1 || MF[MFselectedRow+1].MS.EGClight.endType2 == 1)){
4398             endGameCondition = true;
4399             blueWinFlag = true;
4400             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4401
4402         }
4403     }
4404
4405
4406     static int endGamePanelWait = 100;
4407
4408     if(endGameCondition && !battleRdy){
4409
4410         if(redWinFlag && blueWinFlag){
4411
4412
4413         }else{
4414             windowPoint.x = [mapWindow frame].origin.x+30;
4415             windowPoint.y = [mapWindow frame].origin.y+200;
4416             [endGamePanel setFrameOrigin:windowPoint];
4417             [endGamePanel makeKeyAndOrderFront:nil];
4418             endGamePanelWait--;
4419             if(endGamePanelWait > 0) return;
4420         }
4421
4422         [endGamePanel close];
4423
4424         [fsWindow close];
4425
4426         esSceneProc = 0;
4427
4428         [BGMsub stop];
4429         BGMsub = NULL;
4430
4431         endGameCondition = false;
4432         initMapFlag = false;
4433         TeamCountFlag = false;
4434         initStatusFlag = false;
4435         battleBegin = false;
4436         startES = true;
4437
4438         cpuModeMOVEflag = false;
4439         cpuModeATTACKflag = false;
4440
4441         redWinFlag = false;
4442         blueWinFlag = false;
4443         cpuAImodeflag = false;
4444         cpuTurnEndFlag = true;
4445         waitSwtichFlag = false;
4446
4447         wtRdy = false;
4448         wtRdy2 = false;
4449         Uselected = NULL;
4450
4451         endGamePanelWait = 100;
4452         stageClearFlag = false;
4453         stageClearFlag2 = false;
4454         battleReadyUpFlag = false;
4455         setBattleModeFlag = false;
4456     }
4457     if(backTitleFlag){
4458
4459         [titleWindow makeKeyAndOrderFront:nil];
4460         [fsWindow close];
4461
4462         esSceneProc = 0;
4463
4464         [BGMsub stop];
4465         BGMsub = NULL;
4466
4467         endGameCondition = false;
4468         initMapFlag = false;
4469         TeamCountFlag = false;
4470         initStatusFlag = false;
4471         battleBegin = false;
4472         startES = false;
4473
4474         cpuModeMOVEflag = false;
4475         cpuModeATTACKflag = false;
4476
4477         redWinFlag = false;
4478         blueWinFlag = false;
4479         cpuAImodeflag = false;
4480         cpuTurnEndFlag = true;
4481         backTitleFlag = false;
4482         backTitleFlag2 = true;
4483         waitSwtichFlag = false;
4484         battleReadyUpFlag = false;
4485         setBattleModeFlag = false;
4486
4487
4488         wtRdy = false;
4489         wtRdy2 = false;
4490
4491         Uselected = NULL;
4492
4493     }if(stageClearFlag){
4494
4495         if(stageClearFlag2){
4496
4497             endGameCondition = true;
4498             blueWinFlag = true;
4499             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4500
4501
4502
4503             return;
4504         }
4505
4506         [fsWindow close];
4507
4508         esSceneProc = 0;
4509
4510         [BGMsub stop];
4511         BGMsub = NULL;
4512
4513         endGameCondition = false;
4514         initMapFlag = false;
4515         TeamCountFlag = false;
4516         initStatusFlag = false;
4517         battleBegin = false;
4518         startES = true;
4519
4520         cpuModeMOVEflag = false;
4521         cpuModeATTACKflag = false;
4522
4523         redWinFlag = false;
4524         blueWinFlag = false;
4525         cpuAImodeflag = false;
4526         cpuTurnEndFlag = true;
4527         stageClearFlag = false;
4528         waitSwtichFlag = false;
4529         battleReadyUpFlag = false;
4530         setBattleModeFlag = false;
4531
4532         wtRdy = false;
4533         wtRdy2 = false;
4534
4535
4536         Uselected = NULL;
4537
4538     }
4539
4540     if(gameOverFlag){
4541
4542
4543         [GameOverIV setImage:gaov.img];
4544
4545
4546         [GameOverWindow makeKeyAndOrderFront:nil];
4547         [fsWindow close];
4548
4549         endGameCondition = false;
4550         initMapFlag = false;
4551         TeamCountFlag = false;
4552         initStatusFlag = false;
4553         battleBegin = false;
4554         startES = true;
4555
4556         cpuModeMOVEflag = false;
4557         cpuModeATTACKflag = false;
4558
4559         redWinFlag = false;
4560         blueWinFlag = false;
4561         cpuAImodeflag = false;
4562         cpuTurnEndFlag = true;
4563         backTitleFlag = false;
4564         gameOverFlag = false;
4565         gameOverFlag2 = true;
4566         waitSwtichFlag = false;
4567         battleReadyUpFlag = false;
4568         setBattleModeFlag = false;
4569
4570         wtRdy = false;
4571         wtRdy2 = false;
4572         Uselected = NULL;
4573
4574     }
4575
4576     /*
4577     if(Uselected)
4578         if(!Uselected->dead){
4579
4580             U = UTop;
4581
4582             while (U->number != wtUnitNum) {
4583                 U = U->next;
4584             }
4585
4586             if(!wtMovedFlag && !wtAttackedFlag){
4587                 U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
4588             }else if(wtMovedFlag && wtAttackedFlag){
4589                 U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
4590             }else if(wtMovedFlag){
4591                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4592             }else if(wtAttackedFlag){
4593                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4594             }
4595
4596             U = UTop;
4597
4598             wtRdy = false;
4599         }
4600     */
4601     if(summonRdyFlag){
4602         U = UTop;
4603
4604
4605         U = UTop;
4606         [self addSummonStatus];
4607
4608         U = CSLU;
4609
4610         if(U->team == 0){
4611
4612             SKILL *sTop = U->C.S;
4613
4614             while (U->C.S) {
4615                 if(U->C.S->type == 2) break;
4616                 U->C.S = U->C.S->next;
4617             }
4618
4619             U->C.S_C.MP -= U->C.S->cost[crCSL];
4620
4621             if(!U->C.S){
4622                 U->C.S = sTop;
4623                 U = UTop;
4624                 return;
4625             }
4626
4627
4628             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4629             unitTeam[possionX][possionY] = 0;
4630
4631             U->C.S = sTop;
4632             unitColorInitFlag = true;
4633         }
4634         if(U->team == 2){
4635
4636             SKILL *sTop = U->C.S;
4637
4638             while (U->C.S) {
4639                 if(U->C.S->type == 2) break;
4640                 U->C.S = U->C.S->next;
4641             }
4642
4643             U->C.S_C.MP -= U->C.S->cost[crCSL];
4644
4645             if(!U->C.S){
4646                 U->C.S = sTop;
4647                 U = UTop;
4648                 return;
4649             }
4650
4651             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4652             unitTeam[possionX][possionY] = 2;
4653
4654             U->C.S = sTop;
4655             unitColorInitFlag = true;
4656         }
4657
4658         summonRdyFlag = false;
4659         cslRdy = false;
4660
4661         U = UTop;
4662     }
4663
4664
4665
4666     if(unitMoveEndFlag){
4667         //pussyLoopFlag = false;
4668     }
4669
4670
4671     w000p:
4672
4673
4674     if(displayBattleCheckPanelFlag == 1){
4675         displayBattleCheckPanelFlag = 2;
4676         battleFlag = true;
4677         windowPoint.x = [mapWindow frame].origin.x;
4678         windowPoint.y = [mapWindow frame].origin.y;
4679         [atkPanel setFrameOrigin:windowPoint];
4680     }
4681
4682
4683
4684     U = UTop;
4685
4686
4687
4688
4689
4690 }
4691
4692 -(void)EventFunc:(bool)eventLoopProcFlag{
4693
4694
4695
4696
4697     if(battleSetUp){
4698         pussyLoopFlag = false;
4699     }
4700
4701
4702     if(attackingWait){
4703         return;
4704     }
4705
4706
4707     if(battleBegin && !pussyLoopFlag){
4708         //wtRdy3 = true;
4709         bool proccessTrue = false;
4710         static bool onlyBigin = false;
4711         MAPSCRIPT MS = MF[MFselectedRow+1].MS;
4712         MAPSCRIPTD *MSDtop;
4713         MSDtop = MSDTO;
4714         if(!MSDtop){
4715             wtRdy3 = false;
4716             return;
4717         }
4718
4719
4720         if(!onlyBigin){
4721             MSDP0top = MS.D->P;
4722             onlyBigin = true;
4723         }
4724
4725
4726
4727         while (MS.D) {
4728             int proccesType = -1;
4729
4730             bool EventFailFlag = false;
4731             static bool PtopFlag = false;
4732
4733
4734             enum{
4735                 ENTIRE_MAP,
4736                 CENTER_POINT
4737             };
4738
4739
4740             while(MS.D){
4741                 if(MS.D->endFlag){
4742                     MS.D = MS.D->next;
4743                 }
4744                 else
4745                     break;
4746             }
4747
4748             if(!MS.D) {
4749                 break;
4750             }
4751
4752             PtopFlag = false;
4753
4754             if(!PtopFlag){
4755                 MSDPtop = MS.D->P;
4756                 PtopFlag = true;
4757             }
4758
4759             if(MS.D)
4760                 while(MS.D->P){
4761                     if(MS.D->P->endFlag)
4762                         MS.D->P = MS.D->P->next;
4763                     else
4764                         break;
4765                 }
4766
4767                 while(MS.D->P){
4768                     if(!eventLoopProcFlag && MS.D->P->type == 0){
4769                         proccessTrue = false;
4770                         MS.D->P = MS.D->P->next;
4771                         continue;
4772                     }
4773                     break;
4774                 }
4775
4776             if(!MS.D->P){
4777                 MS.D->endFlag = true;
4778                 messageDialog = false;
4779                 [self setMessage:NULL];
4780                 MS.D->P = MSDPtop;
4781                 PtopFlag = false;
4782
4783
4784                 MAPSCRIPT0 *MSDPT = MS.D->P;
4785
4786                 if(MS.D->ETtype == 0){
4787
4788                 }else if(MS.D->ETtype == 1){
4789                     bool resultFailFlag = false;
4790                     while(MS.D->P){
4791                         if(!MS.D->P->endFlag)
4792                             resultFailFlag = true;
4793                         MS.D->P = MS.D->P->next;
4794                     }MS.D->P = MSDPT;
4795
4796                     if(resultFailFlag)
4797                         while(MS.D->P){
4798                             MS.D->P->endFlag = false;
4799                             MS.D->P = MS.D->P->next;
4800                         }MS.D->P = MSDPT;
4801
4802                 }else if(MS.D->ETtype == 2){
4803
4804                     bool resultFailFlag = false;
4805                     while(MS.D->P){
4806                         if(!MS.D->P->succeessfulFlag)
4807                             resultFailFlag = true;
4808                         MS.D->P = MS.D->P->next;
4809                     }MS.D->P = MSDPT;
4810
4811                     if(resultFailFlag)
4812                         while(MS.D->P){
4813                             MS.D->P->endFlag = false;
4814                             MS.D->P = MS.D->P->next;
4815                         }MS.D->P = MSDPT;
4816                 }else if(MS.D->ETtype == 3){
4817
4818                     bool resultFailFlag = false;
4819                     while(MS.D->P){
4820                         if(!MS.D->P->succeessfulFlag){
4821                             resultFailFlag = false;
4822                             break;
4823                         }
4824                         MS.D->P = MS.D->P->next;
4825                         resultFailFlag = true;
4826                     }MS.D->P = MSDPT;
4827
4828                     if(resultFailFlag)
4829                         while(MS.D->P){
4830                             MS.D->P->endFlag = false;
4831                             MS.D->P = MS.D->P->next;
4832                         }MS.D->P = MSDPT;
4833                     //NSLog(@"%d", UTop->x);
4834                 }else if(MS.D->ETtype == 4){
4835                     while(MS.D->P){
4836                         MS.D->P->endFlag = false;
4837                         MS.D->P = MS.D->P->next;
4838                     }MS.D->P = MSDPT;
4839                 }
4840
4841             }
4842             if(!MS.D) {
4843
4844                 break;
4845             }
4846
4847             if(!PtopFlag){
4848                 MSDPtop = MS.D->P;
4849                 PtopFlag = true;
4850             }
4851
4852             if(MS.D->switch1)
4853                 for(int i = 0;*(MS.D->switch1+i)>0;i++){
4854                     if(Suicchi[*(MS.D->switch1+i)])
4855                         continue;
4856
4857                     EventFailFlag = true;
4858                 }
4859
4860             if(MS.D->switch2)
4861                 for(int i = 0;*(MS.D->switch2+i)>0;i++){
4862                     if(!Suicchi[*(MS.D->switch2+i)])
4863                         continue;
4864
4865                     EventFailFlag = true;
4866                 }
4867             //NSLog(@"%g", eventTime);
4868
4869             //if(!MS.D->endFlag)
4870             if(eventTime == MS.D->ET4 || MS.D->ET4 == 0 || MS.D->initialDeleyedFlag){
4871
4872                 if(MS.D->P->type == 6){
4873                 if(eventTime == MS.D->ET4){
4874                     MS.D->P->S4.lagFixFlag = false;
4875                 }
4876                 else if(unitMoveEndFlag){
4877                     MS.D->P->S4.lagFixFlag = false;
4878                 }
4879                 else if(battleSetUp){
4880                     MS.D->P->S4.lagFixFlag = false;
4881                 }
4882                 else if(pushStanbyFlag){
4883                     MS.D->P->S4.lagFixFlag = false;
4884                 }
4885                 else if(battleEndFlag){
4886                     MS.D->P->S4.lagFixFlag = false;
4887                 }
4888                 else if(!MS.D->P->S4.lagFixFlag && MS.D->ET4 == 0){
4889                         MS.D->P->S4.lagFixFlag = true;
4890                     }
4891                 }
4892
4893                 if(MS.D->P->S4.lagFixFlag){
4894                     //NSLog(@"%g", eventTime);
4895                     proccessTrue = false;
4896                     goto jonny;
4897                 }
4898
4899                 proccessTrue = true;
4900                 if(MS.D->ET4 > 0){
4901
4902                     double deltaET = floor(MS.D->ET2) - floor(MS.D->ET1);
4903                     int deltaR = 0;
4904                     if(deltaET < 0) deltaET = 0;
4905
4906                     if(MS.D->ET1 <= eventTime && MS.D->ET2 >= eventTime){
4907                         if(deltaET > 0) deltaR = rand()%(int)deltaET;
4908                     }
4909
4910                     MS.D->ET3 = MS.D->ET1 + (double)deltaR;
4911
4912                     if(!MS.D->onlyInitialDeley) {
4913                         MS.D->ET4 += MS.D->ET3;
4914                     }else{
4915                         MS.D->initialDeleyedFlag = true;
4916                     }
4917                 }
4918
4919                // NSLog(@"%g %d", eventTime, P[0].resource);
4920             }else{
4921
4922                 if(wtRdy3){
4923                     proccessTrue = true;
4924                     goto jonny;
4925                 }
4926
4927                 MS.D = MS.D->next;
4928
4929                 continue;
4930             }
4931
4932         jonny:{}
4933
4934             if(MS.D->type == -1 && !EventFailFlag)
4935                 proccesType = ENTIRE_MAP;
4936             if(MS.D->type == 0 && pushStanbyFlag && (Uselected->x == MS.D->x && Uselected->y == MS.D->y) && !EventFailFlag)
4937                 proccesType = CENTER_POINT;
4938             else if(MS.D->type == 0){
4939                 proccesType = CENTER_POINT;
4940                 proccessTrue = false;
4941                 EventFailFlag = true;
4942             }
4943
4944             if(MS.D->endFlag){
4945                 MS.D = MS.D->next;
4946                 continue;
4947             }
4948
4949             if(MS.D->ET4 != 0 && pussyCumsOnlyOnceFlag){
4950                 EventFailFlag = true;
4951             }
4952
4953             marry:{}
4954             if(EventFailFlag  || !proccessTrue){
4955                 MS.D->P = MSDPtop;
4956                 MS.D = MS.D->next;
4957                 continue;
4958             }
4959
4960             if(!eventLoopProcFlag && MS.D->P->type == 0)
4961                 proccessTrue = false;
4962
4963             if(proccessTrue)
4964                 switch (proccesType) {
4965                     case ENTIRE_MAP:
4966                         MS.D->P = [self setEvent:MS.D->P];
4967
4968                         if(messageDialog){
4969                             MS.D->P = MSDPtop;
4970                             MS.D = MSDtop;
4971                             return;
4972                         }
4973                         if(waitSwtichFlag) {
4974                             MS.D->P = MSDPtop;
4975                             MS.D = MSDtop;
4976                             return;
4977                         }if(backTitleFlag){
4978                             MS.D->P = MSDPtop;
4979                             MS.D = MSDtop;
4980                             return;
4981
4982                         }if(stageClearFlag){
4983                             MS.D->P = MSDPtop;
4984                             MS.D = MSDtop;
4985                             return;
4986
4987                         }if(gameOverFlag){
4988                             MS.D->P = MSDPtop;
4989                             MS.D = MSDtop;
4990                             return;
4991
4992                         }
4993                         MS.D->P = MSDPtop;
4994                         break;
4995                     case CENTER_POINT:
4996                         MS.D->P = [self setEvent:MS.D->P];
4997                         if(messageDialog){
4998                             MS.D->P = MSDPtop;
4999                             MS.D = MSDtop;
5000                             return;
5001                         }
5002                         if(waitSwtichFlag) {
5003                             MS.D->P = MSDPtop;
5004                             MS.D = MSDtop;
5005                             return;
5006                         }if(backTitleFlag){
5007                             MS.D->P = MSDPtop;
5008                             MS.D = MSDtop;
5009                             return;
5010
5011                         }if(stageClearFlag){
5012                             MS.D->P = MSDPtop;
5013                             MS.D = MSDtop;
5014                             return;
5015
5016                         }if(gameOverFlag){
5017                             MS.D->P = MSDPtop;
5018                             MS.D = MSDtop;
5019                             return;
5020
5021                         }
5022                         MS.D->P = MSDPtop;
5023                         break;
5024
5025                     default:
5026                         MS.D->P = MSDPtop;
5027                         break;
5028                 }
5029
5030             MS.D->P = MSDPtop;
5031
5032
5033             bool PnextFlag = false;
5034
5035             MS.D->P = MSDPtop;
5036             while (MS.D->P) {
5037                 if(MS.D->P->endFlag){
5038                     MS.D->P = MS.D->P->next;
5039                 }else{
5040                     break;
5041                 }
5042                 if(!MS.D->P){
5043                     PnextFlag = true;
5044                 }
5045             }
5046
5047             MS.D->P = MSDPtop;
5048             PtopFlag = true;
5049             if(PnextFlag){
5050                 MS.D = MS.D->next;
5051                 PtopFlag = false;
5052             }
5053
5054             continue;
5055         }
5056         MS.D = MSDtop;
5057
5058         while(MS.D){
5059
5060             MAPSCRIPT0 *MSDPT = MS.D->P;
5061             if(MS.D->ETtype == 0){
5062                 while(MS.D->P){
5063                     MS.D->P->succeessfulFlag = true;
5064                     MS.D->endFlag = true;
5065                     MS.D->P = MS.D->P->next;
5066                 }MS.D->P = MSDPT;
5067             }else if(MS.D->ETtype == 1){
5068                 bool resultFailFlag = false;
5069                 while(MS.D->P){
5070                     if(!MS.D->P->endFlag)
5071                         resultFailFlag = true;
5072                     MS.D->P = MS.D->P->next;
5073                 }MS.D->P = MSDPT;
5074
5075                 if(resultFailFlag)
5076                     while(MS.D->P){
5077                         MS.D->P->succeessfulFlag = false;
5078                         MS.D->endFlag = false;
5079                         MS.D->P->endFlag = false;
5080                         MS.D->P = MS.D->P->next;
5081                     }MS.D->P = MSDPT;
5082
5083             }else if(MS.D->ETtype == 2){
5084
5085                 bool resultFailFlag = false;
5086                 while(MS.D->P){
5087                     if(!MS.D->P->succeessfulFlag)
5088                         resultFailFlag = true;
5089                     MS.D->P = MS.D->P->next;
5090                 }MS.D->P = MSDPT;
5091
5092                 if(resultFailFlag)
5093                     while(MS.D->P){
5094                         MS.D->P->succeessfulFlag = false;
5095                         MS.D->endFlag = false;
5096                         MS.D->P->endFlag = false;
5097                         MS.D->P = MS.D->P->next;
5098                     }MS.D->P = MSDPT;
5099             }else if(MS.D->ETtype == 3){
5100
5101                 bool resultFailFlag = false;
5102                 while(MS.D->P){
5103                     if(!MS.D->P->succeessfulFlag){
5104                         resultFailFlag = false;
5105                         break;
5106                     }
5107                     resultFailFlag = true;
5108                     MS.D->P = MS.D->P->next;
5109                 }MS.D->P = MSDPT;
5110
5111                 if(resultFailFlag)
5112                     while(MS.D->P){
5113                         MS.D->P->succeessfulFlag = false;
5114                         MS.D->endFlag = false;
5115                         MS.D->P->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->P->endFlag = false;
5122                     MS.D->endFlag = false;
5123                     MS.D->P = MS.D->P->next;
5124                 }MS.D->P = MSDPT;
5125             }
5126
5127             MS.D->P = MSDPT;
5128             MS.D = MS.D->next;
5129         }
5130
5131         MS.D = MSDtop;
5132
5133
5134
5135         MF[MFselectedRow+1].MS.D = MS.D;
5136
5137         cpuTurnEndFlag = false;
5138         battleSetUpIgnore = false;
5139         if(!eventLoopProcFlag){
5140             pussyCumsOnlyOnceFlag = true;
5141
5142         }else
5143             fuckingLoadBugFix = true;
5144         //wtRdy3 = false;
5145     }
5146
5147
5148 }
5149
5150 -(MAPSCRIPT0*)setEvent:(MAPSCRIPT0*)MS0{
5151
5152     enum{
5153         MESSAGE_FLAG,
5154         SELECTION_FLAG,
5155         INPUTNUMBER_FLAG,
5156         SWITCH_FLAG,
5157         VALUE_FLAG,
5158         TIMER_FLAG,
5159         BRANCH_FLAG,
5160         LABEL_FLAG,
5161         LABELJUMP_FLAG,
5162         COMMENT_FLAG,
5163         RESOURCE_FLAG,
5164         STATUS_FLAG = 15,
5165         APPEARANCE_FLAG = 22,
5166         DISSAPPEARANCE_FLAG = 23,
5167         WAIT_FLAG = 25,
5168         BGM_FLAG =28,
5169         SE_FLAG =30,
5170         GAMEOVER_FLAG = 35,
5171         STAGECLEAR_FLAG = 36,
5172         TITLE_FLAG = 37,
5173     };
5174
5175     int Proc = -1;
5176
5177     if(MS0->type == 0)
5178         Proc = MESSAGE_FLAG;
5179     if(MS0->type == 1)
5180         Proc = SELECTION_FLAG;
5181     if(MS0->type == 2)
5182         Proc = INPUTNUMBER_FLAG;
5183     if(MS0->type == 3)
5184         Proc = SWITCH_FLAG;
5185     if(MS0->type == 4)
5186         Proc = VALUE_FLAG;
5187     if(MS0->type == 5)
5188         Proc = TIMER_FLAG;
5189     if(MS0->type == 6)
5190         Proc = BRANCH_FLAG;
5191     if(MS0->type == 7)
5192         Proc = LABEL_FLAG;
5193     if(MS0->type == 8)
5194         Proc = LABELJUMP_FLAG;
5195     if(MS0->type == 9)
5196         Proc = COMMENT_FLAG;
5197     if(MS0->type == 10)
5198         Proc = RESOURCE_FLAG;
5199     if(MS0->type == 15)
5200         Proc = STATUS_FLAG;
5201     if(MS0->type == 22)
5202         Proc = APPEARANCE_FLAG;
5203     if(MS0->type == 23)
5204         Proc = DISSAPPEARANCE_FLAG;
5205     if(MS0->type == 25)
5206         Proc = WAIT_FLAG;
5207     if(MS0->type == 28)
5208         Proc = BGM_FLAG;
5209     if(MS0->type == 30)
5210         Proc = SE_FLAG;
5211     if(MS0->type == 35)
5212         Proc = GAMEOVER_FLAG;
5213     if(MS0->type == 36)
5214         Proc = STAGECLEAR_FLAG;
5215     if(MS0->type == 37)
5216         Proc = TITLE_FLAG;
5217
5218
5219
5220
5221     switch(Proc){
5222
5223         case MESSAGE_FLAG:
5224             messageDialog = true;
5225             [self setMessage:MS0];
5226             coolTime = true;
5227             fuckingLoadBugFix = false;
5228             break;
5229         case SELECTION_FLAG:
5230
5231             MS0 = [self setSelection:MS0];
5232             coolTime = true;
5233             break;
5234         case INPUTNUMBER_FLAG:
5235             MS0 = [self setDefault:MS0];
5236             coolTime = true;
5237             break;
5238
5239         case SWITCH_FLAG:
5240             MS0 = [self setSwitch:MS0];
5241             break;
5242         case VALUE_FLAG:
5243             MS0 = [self setDefault:MS0];
5244             break;
5245         case TIMER_FLAG:
5246             MS0 = [self setDefault:MS0];
5247             break;
5248         case BRANCH_FLAG:
5249             MS0 = [self setBranch:MS0];
5250             break;
5251         case LABEL_FLAG:
5252             MS0 = [self setLabel:MS0];
5253             break;
5254         case LABELJUMP_FLAG:
5255             MS0 = [self setLabelJump:MS0];
5256             break;
5257         case COMMENT_FLAG:
5258             MS0 = [self setComment:MS0];
5259             break;
5260         case RESOURCE_FLAG:
5261             MS0 = [self setResource:MS0];
5262             break;
5263         case STATUS_FLAG:
5264             MS0 = [self setStatus:MS0];
5265             break;
5266         case APPEARANCE_FLAG:
5267             MS0 = [self setAppearance:MS0];
5268             break;
5269         case DISSAPPEARANCE_FLAG:
5270             MS0 = [self setDissappearance:MS0];
5271             break;
5272         case WAIT_FLAG:
5273             MS0 = [self setWait:MS0];
5274             break;
5275         case BGM_FLAG:
5276             MS0 = [self setBGM:MS0];
5277             break;
5278         case SE_FLAG:
5279             MS0 = [self setSE:MS0];
5280             break;
5281         case GAMEOVER_FLAG:
5282             MS0 = [self setGameOver:MS0];
5283             coolTime = true;
5284             break;
5285         case STAGECLEAR_FLAG:
5286             MS0 = [self setStageClear:MS0];
5287             break;
5288         case TITLE_FLAG:
5289             MS0 = [self setTitleBack:MS0];
5290             break;
5291
5292     }
5293
5294
5295     return MS0;
5296 }
5297 -(void)setTargetListDat{
5298     targType1cnt[0] = -1;
5299     targType1cnt[1] = -1;
5300     targType2cnt[0] = -1;
5301     targType2cnt[1] = -1;
5302     targType2Lflag = false;
5303     targType2Dflag = false;
5304
5305     /*
5306     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5307
5308     while(1) {
5309
5310         for (int i = 0;i < 64;i++) {
5311             if(!MS.EGClight.etValue1[i]) break;
5312             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5313             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5314
5315             int Tx = [[array2 objectAtIndex:0] intValue];
5316             int Ty = [[array2 objectAtIndex:1] intValue];
5317             if(MS.EGClight.endType1 == 3){
5318                 U = UTop;
5319                 while (U) {
5320                     if(U->x == Tx && U->y == Ty){
5321                         U->targType1L = true;
5322                         if(targType1cnt[0] < 0)
5323                             targType1cnt[0] = 0;
5324                         targType1cnt[0]++;
5325                         break;
5326                     }
5327                     U = U->next;
5328                 }U = UTop;
5329             }
5330             if(MS.EGClight.endType1 == 4){
5331                 U = UTop;
5332                 while (U) {
5333                     if(U->x == Tx && U->y == Ty){
5334                         U->targType2L = true;
5335                         if(targType2cnt[0] < 0)
5336                             targType2cnt[0] = 0;
5337                         targType2cnt[0]++;
5338                         break;
5339                     }
5340                     U = U->next;
5341                 }U = UTop;
5342             }
5343         }
5344         for (int i = 0;i < 64;i++) {
5345             if(!MS.EGClight.etValue2[i]) break;
5346             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5347             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5348
5349             int Tx = [[array2 objectAtIndex:0] intValue];
5350             int Ty = [[array2 objectAtIndex:1] intValue];
5351
5352             if(MS.EGClight.endType2 == 3){
5353                 U = UTop;
5354                 while (U) {
5355                     if(U->x == Tx && U->y == Ty){
5356                         U->targType1L = true;
5357                         if(targType1cnt[0] < 0)
5358                             targType1cnt[0] = 0;
5359                         targType1cnt[0]++;
5360                         break;
5361                     }
5362                     U = U->next;
5363                 }U = UTop;
5364             }
5365             if(MS.EGClight.endType2 == 4){
5366                 U = UTop;
5367                 while (U) {
5368                     if(U->x == Tx && U->y == Ty){
5369                         U->targType2L = true;
5370                         if(targType2cnt[0] < 0)
5371                             targType2cnt[0] = 0;
5372                         targType2cnt[0]++;
5373                         break;
5374                     }
5375                     U = U->next;
5376                 }U = UTop;
5377             }
5378         }
5379         for (int i = 0;i < 64;i++) {
5380             if(!MS.EGCdark.etValue1[i]) break;
5381             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5382             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5383
5384             int Tx = [[array2 objectAtIndex:0] intValue];
5385             int Ty = [[array2 objectAtIndex:1] intValue];
5386
5387             if(MS.EGCdark.endType1 == 3){
5388                 U = UTop;
5389                 while (U) {
5390                     if(U->x == Tx && U->y == Ty){
5391                         U->targType1D = true;
5392                         if(targType1cnt[1] < 0)
5393                             targType1cnt[1] = 0;
5394                         targType1cnt[1]++;
5395                         break;
5396                     }
5397                     U = U->next;
5398                 }U = UTop;
5399             }
5400             if(MS.EGCdark.endType1 == 4){
5401                 U = UTop;
5402                 while (U) {
5403                     if(U->x == Tx && U->y == Ty){
5404                         U->targType2D = true;
5405                         if(targType2cnt[1] < 0)
5406                             targType2cnt[1] = 0;
5407                         targType2cnt[1]++;
5408                         break;
5409                     }
5410                     U = U->next;
5411                 }U = UTop;
5412             }
5413         }
5414         for (int i = 0;i < 64;i++) {
5415             if(!MS.EGCdark.etValue2[i]) break;
5416             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5417             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5418
5419             int Tx = [[array2 objectAtIndex:0] intValue];
5420             int Ty = [[array2 objectAtIndex:1] intValue];
5421
5422             if(MS.EGCdark.endType2 == 3){
5423                 U = UTop;
5424                 while (U) {
5425                     if(U->x == Tx && U->y == Ty){
5426                         U->targType1D = true;
5427                         if(targType1cnt[1] < 0)
5428                             targType1cnt[1] = 0;
5429                         targType1cnt[1]++;
5430                         break;
5431                     }
5432                     U = U->next;
5433                 }U = UTop;
5434             }
5435             if(MS.EGCdark.endType2 == 4){
5436                 U = UTop;
5437                 while (U) {
5438                     if(U->x == Tx && U->y == Ty){
5439                         U->targType2D = true;
5440                         if(targType2cnt[1] < 0)
5441                             targType2cnt[1] = 0;
5442                         targType2cnt[1]++;
5443                         break;
5444                     }
5445                     U = U->next;
5446                 }U = UTop;
5447             }
5448         }
5449         break;
5450     }
5451 */
5452
5453
5454 }
5455
5456 -(void)setTargetList{
5457
5458     targType1cnt[0] = -1;
5459     targType1cnt[1] = -1;
5460     targType2cnt[0] = -1;
5461     targType2cnt[1] = -1;
5462     targType2Lflag = false;
5463     targType2Dflag = false;
5464
5465
5466     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5467
5468     while(1) {
5469
5470         for (int i = 0;i < 64;i++) {
5471             if(!MS.EGClight.etValue1[i] || [MS.EGClight.etValue1[i] isEqualToString:@""]) break;
5472             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5473             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5474
5475             int Tx = [[array2 objectAtIndex:0] intValue];
5476             int Ty = [[array2 objectAtIndex:1] intValue];
5477             if(MS.EGClight.endType1 == 3){
5478                 U = UTop;
5479                 while (U) {
5480                     if(U->x == Tx && U->y == Ty){
5481                         U->targType1L = true;
5482                         if(targType1cnt[0] < 0)
5483                             targType1cnt[0] = 0;
5484                         targType1cnt[0]++;
5485                         break;
5486                     }
5487                     U = U->next;
5488                 }U = UTop;
5489             }
5490             if(MS.EGClight.endType1 == 4){
5491                 U = UTop;
5492                 while (U) {
5493                     if(U->x == Tx && U->y == Ty){
5494                         U->targType2L = true;
5495                         if(targType2cnt[0] < 0)
5496                             targType2cnt[0] = 0;
5497                         targType2cnt[0]++;
5498                         break;
5499                     }
5500                     U = U->next;
5501                 }U = UTop;
5502             }
5503         }
5504         for (int i = 0;i < 64;i++) {
5505             if(!MS.EGClight.etValue2[i] || [MS.EGClight.etValue2[i] isEqualToString:@""]) break;
5506             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5507             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5508
5509             int Tx = [[array2 objectAtIndex:0] intValue];
5510             int Ty = [[array2 objectAtIndex:1] intValue];
5511
5512             if(MS.EGClight.endType2 == 3){
5513             U = UTop;
5514                 while (U) {
5515                     if(U->x == Tx && U->y == Ty){
5516                         U->targType1L = true;
5517                         if(targType1cnt[0] < 0)
5518                             targType1cnt[0] = 0;
5519                         targType1cnt[0]++;
5520                         break;
5521                     }
5522                     U = U->next;
5523                 }U = UTop;
5524             }
5525             if(MS.EGClight.endType2 == 4){
5526                 U = UTop;
5527                 while (U) {
5528                     if(U->x == Tx && U->y == Ty){
5529                         U->targType2L = true;
5530                         if(targType2cnt[0] < 0)
5531                             targType2cnt[0] = 0;
5532                         targType2cnt[0]++;
5533                         break;
5534                     }
5535                     U = U->next;
5536                 }U = UTop;
5537             }
5538         }
5539         for (int i = 0;i < 64;i++) {
5540             if(!MS.EGCdark.etValue1[i] || [MS.EGCdark.etValue1[i] isEqualToString:@""]) break;
5541             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5542             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5543
5544             int Tx = [[array2 objectAtIndex:0] intValue];
5545             int Ty = [[array2 objectAtIndex:1] intValue];
5546
5547             if(MS.EGCdark.endType1 == 3){
5548                     U = UTop;
5549                 while (U) {
5550                     if(U->x == Tx && U->y == Ty){
5551                         U->targType1D = true;
5552                         if(targType1cnt[1] < 0)
5553                             targType1cnt[1] = 0;
5554                         targType1cnt[1]++;
5555                         break;
5556                     }
5557                     U = U->next;
5558                 }U = UTop;
5559             }
5560             if(MS.EGCdark.endType1 == 4){
5561                 U = UTop;
5562                 while (U) {
5563                     if(U->x == Tx && U->y == Ty){
5564                         U->targType2D = true;
5565                         if(targType2cnt[1] < 0)
5566                             targType2cnt[1] = 0;
5567                         targType2cnt[1]++;
5568                         break;
5569                     }
5570                     U = U->next;
5571                 }U = UTop;
5572             }
5573         }
5574         for (int i = 0;i < 64;i++) {
5575             if(!MS.EGCdark.etValue2[i] || [MS.EGCdark.etValue2[i] isEqualToString:@""]) break;
5576             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5577             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5578
5579             int Tx = [[array2 objectAtIndex:0] intValue];
5580             int Ty = [[array2 objectAtIndex:1] intValue];
5581
5582             if(MS.EGCdark.endType2 == 3){
5583                 U = UTop;
5584                 while (U) {
5585                     if(U->x == Tx && U->y == Ty){
5586                         U->targType1D = true;
5587                         if(targType1cnt[1] < 0)
5588                             targType1cnt[1] = 0;
5589                         targType1cnt[1]++;
5590                         break;
5591                     }
5592                     U = U->next;
5593                 }U = UTop;
5594             }
5595             if(MS.EGCdark.endType2 == 4){
5596                 U = UTop;
5597                 while (U) {
5598                     if(U->x == Tx && U->y == Ty){
5599                         U->targType2D = true;
5600                         if(targType2cnt[1] < 0)
5601                             targType2cnt[1] = 0;
5602                         targType2cnt[1]++;
5603                         break;
5604                     }
5605                     U = U->next;
5606                 }U = UTop;
5607             }
5608         }
5609         break;
5610     }
5611
5612
5613
5614
5615 }
5616
5617 -(bool)setBuildList{
5618
5619     crCRL = 0;
5620
5621     [self willChangeValueForKey:@"CResearchListMA"];
5622     [CResearchListMA removeAllObjects];
5623     [self didChangeValueForKey:@"CResearchListMA"];
5624
5625     [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
5626     [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
5627     [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
5628     [researchACU setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
5629     [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
5630     [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
5631     [researchIMG setImage:NULL];
5632
5633     BUILDCHIP *B0;
5634
5635     B = BTop;
5636
5637     while (B && B->x != possionX && B->y != possionY) {
5638         B = B->next;
5639     }
5640     B0 = &BC[buildNum[possionX][possionY]];
5641
5642     RESEARCH *Rtop;
5643     UNITCHIP *BU;
5644
5645     Rtop = B0->R;
5646
5647
5648     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
5649
5650
5651         if(GCnum1 < 0)
5652         if(!B0->R){
5653
5654         return false;
5655
5656         }
5657     }
5658     else if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
5659
5660
5661         if(GCnum2 < 0)
5662         if(!B0->R){
5663
5664             return false;
5665
5666         }
5667     }
5668
5669     while(B0->R){
5670         BU = B0->R->U;
5671
5672         if(B->makeLv >= B0->R->Lv){
5673         NSMutableDictionary* dict = [NSMutableDictionary new];
5674         [dict setValue:[NSString stringWithFormat:@"%@", BU->nameClass] forKey:@"name"];
5675         [dict setValue:[NSString stringWithFormat:@"%g", BU->S_M.HP] forKey:@"HP"];
5676         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d", BU->S_M.cSupply, BU->S_M.cFood, BU->S_M.cMoney] forKey:@"cost"];
5677         [dict setValue:BU->img forKey:@"img"];
5678
5679
5680         [self willChangeValueForKey:@"CResearchListMA"];
5681         [CResearchListMA addObject:dict];
5682         [self didChangeValueForKey:@"CResearchListMA"];
5683         }
5684         B0->R = B0->R->next;
5685     }
5686     B0->R = Rtop;
5687
5688     B = BTop;
5689
5690     BUILDCHIP *B;
5691
5692     B = &BC[buildNum[possionX][possionY]];
5693
5694
5695     if(B0->R){
5696     Rtop = B->R;
5697
5698     BU = B->R->U;
5699     BRU = BU;
5700
5701     for(int i = 0;i <= crCRL && B->R;i++){
5702         BU = B->R->U;
5703         BRU = BU;
5704         [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", BU->S_M.ATK]];
5705         [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", BU->S_M.DEF]];
5706         [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", BU->S_M.CAP]];
5707         [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", BU->S_M.ACU]];
5708         [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", BU->S_M.EVA]];
5709         [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", BU->S_M.MOV]];
5710         [researchIMG setImage:BU->imgb];
5711         [researchIMG setImageScaling:NSScaleToFit];
5712
5713         B->R = B->R->next;
5714     }
5715     B->R = Rtop;
5716     }
5717
5718     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5719
5720     if(B->GuildFlag &&( buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1)){
5721
5722         int a = MS.guildListRegistNum12 - MS.guildListRegistNum11;
5723
5724         if(!guildRE1){
5725         Gnum1 = 0;
5726         if(a > 0)
5727             Gnum1 = MS.guildListRegistNum11 + arc4random()%(MS.guildListRegistNum12 - MS.guildListRegistNum11+1);
5728         else
5729             Gnum1 = MS.guildListRegistNum12;
5730
5731         if(Gnum1 > GCnum1+1)
5732             Gnum1 = GCnum1;
5733         }
5734         int n = 0;
5735         guildc = 0;
5736         saveGuildList = calloc((GCnum1+1), sizeof(int));
5737         if(!guildRE1) GuildDisp1 = calloc(Gnum1, sizeof(int));
5738         for(int i = 0;i < Gnum1;i++){
5739
5740             if(!guildRE1){
5741                 n = [self chooseGuildList:GuildChosen1 gcnum:GCnum1];
5742             if(n == -1)
5743                 break;
5744                 *(GuildDisp1 + i) = *(GuildChosen1 + n);
5745             }
5746
5747             if(*(GuildDisp1 + i) <= 0)
5748                 break;
5749
5750             NSMutableDictionary* dict = [NSMutableDictionary new];
5751             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp1 + i)-1].name] forKey:@"name"];
5752             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp1 + i)-1].S_M.HP] forKey:@"HP"];
5753             [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"];
5754             [dict setValue:UC[*(GuildDisp1 + i)-1].img forKey:@"img"];
5755
5756
5757             [self willChangeValueForKey:@"CResearchListMA"];
5758             [CResearchListMA addObject:dict];
5759             [self didChangeValueForKey:@"CResearchListMA"];
5760
5761         }
5762
5763
5764
5765         int k = 0;
5766         B->R = Rtop;
5767
5768         while (B->R) {
5769             B->R = B->R->next;
5770             k++;
5771         }
5772
5773         for(int i = k;i <= crCRL;i++){
5774             if(*(GuildDisp1 + i - k) <= 0)
5775                 continue;
5776
5777             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ATK]];
5778             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.DEF]];
5779             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.CAP]];
5780             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ACU]];
5781             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.EVA]];
5782             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp1 + i - k)-1].S_M.MOV]];
5783             [researchIMG setImage:UC[*(GuildDisp1 + i - k)-1].imgb];
5784             [researchIMG setImageScaling:NSScaleToFit];
5785
5786         }B->R = Rtop;
5787
5788         guildRE1 = true;
5789     }else if(B->GuildFlag && (buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3)){
5790
5791         int a = MS.guildListRegistNum22 - MS.guildListRegistNum21;
5792
5793         if(!guildRE2){
5794         Gnum2 = 0;
5795         if(a > 0)
5796             Gnum2 = MS.guildListRegistNum21 + arc4random()%(MS.guildListRegistNum22 - MS.guildListRegistNum21+1);
5797         else
5798             Gnum2 = MS.guildListRegistNum22;
5799
5800         if(Gnum2 > GCnum2+1)
5801             Gnum2 = GCnum2;
5802         }
5803         int n = 0;
5804
5805         guildc = 0;
5806         saveGuildList = calloc((GCnum2+1), sizeof(int));
5807         if(!guildRE2) GuildDisp2 = calloc(Gnum2, sizeof(int));
5808         for(int i = 0;i < Gnum2;i++){
5809             if(!guildRE2){
5810                 n = [self chooseGuildList:GuildChosen2 gcnum:GCnum2];
5811                 if(n == -1)
5812                     break;
5813                 *(GuildDisp2 + i) = *(GuildChosen2 + n);
5814             }
5815
5816             if(*(GuildDisp2 + i) <= 0)
5817                 break;
5818
5819             NSMutableDictionary* dict = [NSMutableDictionary new];
5820             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp2 + i)-1].name] forKey:@"name"];
5821             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp2 + i)-1].S_M.HP] forKey:@"HP"];
5822             [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"];
5823             [dict setValue:UC[*(GuildDisp2 + i)-1].img forKey:@"img"];
5824
5825
5826             [self willChangeValueForKey:@"CResearchListMA"];
5827             [CResearchListMA addObject:dict];
5828             [self didChangeValueForKey:@"CResearchListMA"];
5829         }
5830
5831         int k = 0;
5832         B->R = Rtop;
5833         while (B->R) {
5834             B->R = B->R->next;
5835             k++;
5836         }
5837
5838         for(int i = k;i <= crCRL;i++){
5839             if(*(GuildDisp2 + i - k) <= 0)
5840                 continue;
5841
5842
5843             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ATK]];
5844             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.DEF]];
5845             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.CAP]];
5846             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ACU]];
5847             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.EVA]];
5848             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp2 + i - k)-1].S_M.MOV]];
5849             [researchIMG setImage:UC[*(GuildDisp2 + i - k)-1].imgb];
5850             [researchIMG setImageScaling:NSScaleToFit];
5851
5852         }B->R = Rtop;
5853
5854
5855         guildRE2 = true;
5856     }
5857
5858
5859
5860
5861
5862
5863
5864
5865     return true;
5866 }
5867 -(int)chooseGuildList:(int*)value gcnum:(int)gcnum{
5868
5869     int a = 0;
5870     while(1){
5871         bool sameFlag = false;
5872         bool sameFlag2 = false;
5873
5874         if(guildc >= gcnum+1){
5875             a = -1;
5876             break;
5877         }
5878
5879         a = arc4random()%(gcnum+1);
5880
5881         for(int i = 0;i < guildc;i++){
5882             if(*(saveGuildList+i) == a){
5883                 sameFlag2 = true;
5884                 break;
5885             }
5886         }
5887
5888         if(sameFlag2)
5889             continue;
5890
5891         *(saveGuildList+guildc) = a;
5892
5893         guildc++;
5894
5895         U = UTop;
5896         while(U){
5897             if([UC[*(value + a)-1].nameID isEqualToString:U->C.nameID]){
5898                 sameFlag = true;
5899                 break;
5900             }
5901             U = U->next;
5902         }U = UTop;
5903
5904         if(!sameFlag)
5905             break;
5906     }
5907
5908
5909     return a;
5910 }
5911
5912 -(void)initGuildList{
5913
5914     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5915
5916     GuildChosen1 = calloc(UCN, sizeof(int));
5917     GuildChosen2 = calloc(UCN, sizeof(int));
5918
5919     GCnum1 = -1;
5920     for (int i = 0;i < UCN;i++) {
5921         if(MS.guildListRegist[i]){
5922             GCnum1++;
5923             *(GuildChosen1 + GCnum1) = i+1;
5924         }
5925     }
5926     GCnum2 = -1;
5927     for (int i = 0;i < UCN;i++) {
5928         if(MS.guildListRegist2[i]){
5929             GCnum2++;
5930             *(GuildChosen2 + GCnum2) = i+1;
5931         }
5932     }
5933
5934 }
5935
5936
5937 -(void)SetMenu{
5938
5939     [self setCommandPanel];
5940     [menuPanel makeKeyAndOrderFront:nil];
5941 }
5942
5943 -(IBAction)pushMove:(id)sender{menuDisplayFlag = false;
5944     [menuPanel close];
5945     moveFlag = true;
5946     attackFlag = false;
5947     createFlag = false;
5948     summonFlag = false;
5949 }
5950 -(IBAction)pushAttack:(id)sender{menuDisplayFlag = false;
5951     [menuPanel close];
5952     attackFlag = true;
5953     moveFlag = false;
5954     windowPoint.x = [mapWindow frame].origin.x;
5955     windowPoint.y = [mapWindow frame].origin.y;
5956     [atkPanel setFrameOrigin:windowPoint];
5957
5958     U = UTop;
5959     while (!(AUN[1] == U->number)) {
5960         U = U->next;
5961     }
5962
5963     if(U->chipNumberL >= 0){
5964         U = UTop;
5965         [self initCAttackList2];
5966         [self initCAttackSelect2];
5967     }
5968     else if(U->chipNumber >= 0) {
5969         U = UTop;
5970         [self initCAttackList];
5971         [self initCAttackSelect];
5972     }
5973     U = UTop;
5974     [atkPanel makeKeyAndOrderFront:nil];
5975 }
5976 -(IBAction)pushStandby:(id)sender{menuDisplayFlag = false;
5977
5978     U = UTop;
5979
5980     while (U->number != wtUnitNum) {
5981         U = U->next;
5982     }
5983
5984     if(!wtMovedFlag && !wtAttackedFlag){
5985         U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
5986     }else if(wtMovedFlag && wtAttackedFlag){
5987         U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
5988     }else if(wtMovedFlag){
5989         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
5990     }else if(wtAttackedFlag){
5991         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
5992     }
5993
5994     BTop = B;
5995     while (B) {
5996         if(B->x == possionX && B->y == possionY && B->C.capture){
5997             buildCaptureFlag = true;
5998             unitMoveEndFlag = true;
5999         }
6000         B = B->next;
6001     }B = BTop;
6002
6003     U = UTop;
6004
6005     wtRdy = false;
6006     wtRdy2 = false;
6007     wtRdy3 = false;
6008     pushStanbyFlag = true;
6009     pussyLoopFlag = false;
6010     [menuPanel close];
6011 }
6012 -(IBAction)pushCreate:(id)sender{menuDisplayFlag = false;
6013     [menuPanel close];
6014     createFlag = true;
6015     moveFlag = false;
6016
6017     windowPoint.x = [mapWindow frame].origin.x;
6018     windowPoint.y = [mapWindow frame].origin.y;
6019     [createPanel setFrameOrigin:windowPoint];
6020
6021     [self initBCreateList];
6022     [createPanel makeKeyAndOrderFront:nil];
6023 }
6024
6025 -(IBAction)pushSummon:(id)sender{menuDisplayFlag = false;
6026     [menuPanel close];
6027     summonFlag = true;
6028     moveFlag = false;
6029
6030     windowPoint.x = [mapWindow frame].origin.x;
6031     windowPoint.y = [mapWindow frame].origin.y;
6032     [summonPanel setFrameOrigin:windowPoint];
6033
6034     [self initCSummonList];
6035     [summonPanel makeKeyAndOrderFront:nil];
6036 }
6037
6038
6039
6040 -(void)initStatusWindow{
6041
6042     U = UTop;
6043
6044     [STIV setImage:Uselected->C.imgb];
6045     [STnameTF setStringValue:Uselected->C.name];
6046     [STclassTF setStringValue:Uselected->C.nameClass];
6047     [SThpTF setStringValue:[NSString stringWithFormat:@"HP　%g/%g", Uselected->C.S_C.HP, Uselected->C.S_M.HP]];
6048     [STmpTF setStringValue:[NSString stringWithFormat:@"MP　%g/%g", Uselected->C.S_C.MP, Uselected->C.S_M.MP]];
6049     [STatkTF setStringValue:[NSString stringWithFormat:@"ATK %g", Uselected->C.S_C.ATK]];
6050     [STdefTF setStringValue:[NSString stringWithFormat:@"DEF %g", Uselected->C.S_C.DEF]];
6051     [STcapTF setStringValue:[NSString stringWithFormat:@"CAP %g", Uselected->C.S_C.CAP]];
6052     [STacuTF setStringValue:[NSString stringWithFormat:@"ACU %g", Uselected->C.S_C.ACU]];
6053     [STevaTF setStringValue:[NSString stringWithFormat:@"EVA %g", Uselected->C.S_C.EVA]];
6054     [STstrTF setStringValue:[NSString stringWithFormat:@"STR %g", Uselected->C.S_C.STR]];
6055     [STvitTF setStringValue:[NSString stringWithFormat:@"VIT %g", Uselected->C.S_C.VIT]];
6056     [STagiTF setStringValue:[NSString stringWithFormat:@"AGI %g", Uselected->C.S_C.AGI]];
6057     [STdexTF setStringValue:[NSString stringWithFormat:@"DEX %g", Uselected->C.S_C.DEX]];
6058     [STmenTF setStringValue:[NSString stringWithFormat:@"MEN %g", Uselected->C.S_C.MEN]];
6059     [STintTF setStringValue:[NSString stringWithFormat:@"INT %g", Uselected->C.S_C.INT]];
6060     [STmelTF setStringValue:[NSString stringWithFormat:@"MEL %g", Uselected->C.S_C.MEL]];
6061     [STmisTF setStringValue:[NSString stringWithFormat:@"MIS %g", Uselected->C.S_C.MIS]];
6062     [SThitTF setStringValue:[NSString stringWithFormat:@"HIT %g", Uselected->C.S_C.HIT]];
6063     [STdodTF setStringValue:[NSString stringWithFormat:@"DOD %g", Uselected->C.S_C.DOD]];
6064     [STreaTF setStringValue:[NSString stringWithFormat:@"REA %g", Uselected->C.S_C.REA]];
6065     [STskiTF setStringValue:[NSString stringWithFormat:@"SKI %g", Uselected->C.S_C.SKI]];
6066     [STvigTF setStringValue:[NSString stringWithFormat:@"VIG %d", Uselected->C.S_C.vigor]];
6067
6068
6069
6070
6071
6072
6073
6074     U = UTop;
6075 }
6076
6077 -(IBAction)pushStatus:(id)sender{menuDisplayFlag = false;
6078
6079     [self initStatusWindow];
6080
6081     windowPoint.x = [mapWindow frame].origin.x;
6082     windowPoint.y = [mapWindow frame].origin.y;
6083     [STwindow setFrameOrigin:windowPoint];
6084     [STwindow makeKeyAndOrderFront:nil];
6085
6086
6087
6088     [menuPanel close];
6089 }
6090
6091 -(IBAction)STsubmit:(id)sender{
6092
6093     [STwindow close];
6094 }
6095
6096 -(IBAction)pushCancel:(id)sender{menuDisplayFlag = false;
6097     moveFlag = false;
6098     attackFlag = false;
6099     summonFlag = false;
6100     [menuPanel close];
6101 }
6102 -(IBAction)pushCancelCAL:(id)sender{
6103     attackFlag = false;
6104     [atkPanel close];
6105 }
6106
6107 -(IBAction)pushCancelBCL:(id)sender{
6108     createFlag = false;
6109     [createPanel close];
6110 }
6111
6112 -(IBAction)pushCancelCSL:(id)sender{
6113     summonFlag = false;
6114     [summonPanel close];
6115 }
6116
6117 -(void)addBuildStatus{
6118     //おまんちん
6119
6120     registerNumB++;
6121
6122     if(registerNumB == 1){
6123         B = calloc(1, sizeof(BUILD));
6124         BTop = B;
6125     }
6126
6127     int omgCnt = 0;
6128     B = BTop;
6129     if(B)
6130     while (B->next) {omgCnt++;
6131         B = B->next;
6132     }
6133     if(registerNumB != 1){
6134         B->next = calloc(1, sizeof(BUILD));
6135         if(registerNumB == 2)
6136             BTop = B;
6137         B = B->next;
6138     }
6139         B->next = NULL;
6140
6141     B->number = registerNumB;
6142
6143
6144     B->chipNumber = BC[buildNum[possionX][possionY]].chipNumb;
6145     B->x = possionX;
6146     B->y = possionY;
6147     B->C = BC[buildNum[possionX][possionY]];
6148     B->img = [BC[buildNum[possionX][possionY]].img retain];
6149     unitColorInitFlag = true;
6150
6151     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
6152         B->team = 0;
6153         if(unitTeam[possionX][possionY] == 0){
6154             U->joinArmyFromNext = true;
6155             U->persuasion = true;
6156         }
6157     }
6158     if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
6159         B->team = 2;
6160     }
6161     if(buildTeam[possionX][possionY] == 4 || buildTeam[possionX][possionY] == 5){
6162         B->team = 1;
6163     }
6164     if(buildTeam[possionX][possionY] == -1){
6165         B->team = -1;
6166
6167     }
6168
6169     B = BTop;
6170 }
6171
6172
6173 -(void)addUnitStatus{
6174     registerNum++;
6175     int omgCnt = 0;
6176     U = UTop;
6177     while (U->next) {omgCnt++;
6178         U = U->next;
6179     }
6180     U->next = calloc(1, sizeof(UNIT));
6181     U = U->next;
6182     U->next = NULL;
6183     if(omgCnt == 0) U = UTop;
6184     U->number = registerNum;
6185
6186     for(int i = 0;i < UCN;i++){
6187         if([U->C.nameID isEqualToString:UC[i].nameID])
6188             U->chipNumber = i;
6189     }
6190
6191     U->chipNumber = unitNum[possionX][possionY];
6192     U->chipNumberL = loadNum[possionX][possionY];
6193     U->C.chipNumb = unitNum[possionX][possionY];
6194     U->CL.chipNumb = loadNum[possionX][possionY];
6195     U->x = possionX;
6196     U->y = possionY;
6197     U->C = *BRU;
6198                 if(unitTeam[possionX][possionY] == 0 || unitTeam[possionX][possionY] == 1){
6199                     U->team = 0;
6200                     if(unitTeam[possionX][possionY] == 1){
6201                         U->joinArmyFromNext = true;
6202                         U->persuasion = true;
6203                     }
6204
6205                     if(MF[MFselectedRow+1].MS.playerSet1 == 2){
6206                         U->CPU = true;
6207                     }
6208                 }
6209                 if(unitTeam[possionX][possionY] == 2 || unitTeam[possionX][possionY] == 3){
6210                     U->team = 2;
6211                     if(unitTeam[possionX][possionY] == 3){
6212                         U->joinArmyFromNext = true;
6213                         U->persuasion = true;
6214                     }
6215
6216                     if(MF[MFselectedRow+1].MS.playerSet2 == 2){
6217                         U->CPU = true;
6218                     }
6219                 }
6220                 if(unitTeam[possionX][possionY] == 4 || unitTeam[possionX][possionY] == 5){
6221                     U->team = 1;
6222                     if(unitTeam[possionX][possionY] == 5){
6223                         U->joinArmyFromNext = true;
6224                         U->persuasion = true;
6225                     }
6226                     U->CPU = true;
6227                 }
6228                 if(unitTeam[possionX][possionY] == -1){
6229                     U->team = -1;
6230                     if(unitTeam[possionX][possionY] == 0){
6231                         U->joinArmyFromNext = false;
6232                         U->persuasion = true;
6233                     }
6234                     U->CPU = true;
6235                 }
6236
6237
6238                 [self SetUnitStatus:unitNum[possionX][possionY]];
6239     U = UTop;
6240 }
6241
6242 -(void)addSummonStatus{
6243     registerNum++;
6244     int omgCnt = 0;
6245     U = UTop;
6246     while (U->next) {omgCnt++;
6247         U = U->next;
6248     }
6249     U->next = calloc(1, sizeof(UNIT));
6250     U = U->next;
6251     U->next = NULL;
6252     if(omgCnt == 0) U = UTop;
6253
6254
6255     U->x = possionX;
6256     U->y = possionY;
6257
6258     U->C = CSLUC;
6259     if(unitTeam[CSLU->x][CSLU->y] == 0 || unitTeam[CSLU->x][CSLU->y] == 1){
6260         U->team = 0;
6261         if(unitTeam[CSLU->x][CSLU->y] == 1){
6262             U->joinArmyFromNext = true;
6263             U->persuasion = true;
6264         }
6265     }
6266     if(unitTeam[CSLU->x][CSLU->y] == 2 || unitTeam[CSLU->x][CSLU->y] == 3){
6267         U->team = 2;
6268         if(unitTeam[CSLU->x][CSLU->y] == 3){
6269             U->joinArmyFromNext = true;
6270             U->persuasion = true;
6271         }
6272     }
6273     if(unitTeam[CSLU->x][CSLU->y] == 4 || unitTeam[CSLU->x][CSLU->y] == 5){
6274         U->team = 1;
6275         if(unitTeam[CSLU->x][CSLU->y] == 5){
6276             U->joinArmyFromNext = true;
6277             U->persuasion = true;
6278         }
6279     }
6280     if(unitTeam[CSLU->x][CSLU->y] == -1){
6281         U->team = -1;
6282         if(unitTeam[CSLU->x][CSLU->y] == 0){
6283             U->joinArmyFromNext = false;
6284             U->persuasion = true;
6285         }
6286     }
6287
6288     [self SetUnitStatus:unitNum[possionX][possionY]];
6289
6290     for(int i = 0;i < UCN;i++){
6291         if([U->C.nameID isEqualToString:UC[i].nameID])
6292             U->chipNumber = i;
6293     }
6294     for(int i = 0;i < LCN;i++){
6295         if([U->CL.nameID isEqualToString:LC[i].nameID])
6296             U->chipNumberL = i;
6297     }
6298     for(int i = 0;i < UCN;i++){
6299         if([U->C.nameID isEqualToString:UC[i].nameID])
6300             U->C.chipNumb = i;
6301     }
6302     for(int i = 0;i < LCN;i++){
6303         if([U->CL.nameID isEqualToString:LC[i].nameID])
6304             U->CL.chipNumb = i;
6305     }
6306
6307     U = UTop;
6308
6309 }
6310
6311 -(void)initUnitStatusDat{
6312     U = NULL;
6313     UTop = NULL;
6314     for(int i = 0;i < sdd2[datRow].registerNum;i++){
6315         if(i == 0){
6316             U = calloc(1, sizeof(UNIT));
6317             UTop = U;
6318         }
6319         if(i > 0)
6320             U = U->next;
6321
6322         U->x = sdd2[datRow].dU[i].x;
6323         U->y = sdd2[datRow].dU[i].y;
6324         U->number = sdd2[datRow].dU[i].number;;
6325         U->chipNumber = sdd2[datRow].dU[i].chipNumber;
6326         U->chipNumberL = sdd2[datRow].dU[i].chipNumberL;
6327         U->C.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6328         U->CL.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6329         U->atkRange = 0;
6330         U->dead = sdd2[datRow].dU[i].dead;
6331
6332         U->team = sdd2[datRow].dU[i].team;
6333         U->CPU = sdd2[datRow].dU[i].CPU;
6334         U->joinArmyFromNext = sdd2[datRow].dU[i].joinArmyFromNext;
6335         U->persuasion = sdd2[datRow].dU[i].persuasion;
6336
6337         U->ix = sdd2[datRow].dU[i].ix;
6338         U->iy = sdd2[datRow].dU[i].iy;
6339         U->iz = sdd2[datRow].dU[i].iz;
6340
6341
6342
6343         if(U->chipNumber >= 0) [self SetUnitStatus:U->chipNumber];
6344         if(U->chipNumberL >= 0) [self SetUnitStatus2:U->chipNumberL];
6345
6346         U->C.S_C = sdd2[datRow].dU[i].C.S_C;
6347         U->C.R_C = sdd2[datRow].dU[i].C.R_C;
6348
6349         if(U->chipNumberL >= 0) U->img = [LC[U->chipNumberL].img retain];
6350             else U->img = [UC[U->chipNumber].img retain];
6351
6352
6353         unitTeam[U->x][U->y] = U->team;
6354         unitNum[U->x][U->y] = U->chipNumber;
6355         loadNum[U->x][U->y] = U->chipNumberL;
6356
6357
6358         U->next = calloc(1, sizeof(UNIT));
6359     }
6360
6361     if(U) U->next = NULL;
6362     U = UTop;
6363
6364 }
6365
6366
6367 -(void)initUnitStatus{
6368     registerNum = 0;
6369     U = NULL;
6370     UTop = NULL;
6371     for(int i=1;i <= chipHeight;i++){
6372         for(int j=1;j<= chipWidth;j++){
6373             if(unitNum[j][i] >= 0 || loadNum[j][i] >= 0){
6374                 registerNum++;
6375                 if(registerNum == 1){
6376                     U = calloc(1, sizeof(UNIT));
6377                     UTop = U;
6378                 }
6379                 if(registerNum > 1)
6380                     U = U->next;
6381                 U->x = j;
6382                 U->y = i;
6383                 U->number = registerNum;
6384                 U->chipNumber = unitNum[j][i];
6385                 U->chipNumberL = loadNum[j][i];
6386                 U->C.chipNumb = U->chipNumber;
6387                 U->CL.chipNumb = U->chipNumberL;
6388
6389                 if(unitTeam[j][i] == 0 || unitTeam[j][i] == 1){
6390                     U->team = 0;
6391                     if(unitTeam[j][i] == 1){
6392                         U->joinArmyFromNext = true;
6393                         U->persuasion = true;
6394                     }
6395                     if(MF[MFselectedRow+1].MS.playerSet1 == 2)
6396                         U->CPU = true;
6397                 }
6398                 if(unitTeam[j][i] == 2 || unitTeam[j][i] == 3){
6399                     U->team = 2;
6400                     if(unitTeam[i][j] == 2){
6401                         U->joinArmyFromNext = true;
6402                         U->persuasion = true;
6403                     }
6404                     if(MF[MFselectedRow+1].MS.playerSet2 == 2)
6405                         U->CPU = true;
6406                 }
6407                 if(unitTeam[j][i] == 4 || unitTeam[j][i] == 5){
6408                     U->team = 1;
6409                     if(unitTeam[j][i] == 5){
6410                         U->joinArmyFromNext = true;
6411                         U->persuasion = true;
6412                     }
6413                     U->CPU = true;
6414                 }
6415                 if(unitTeam[j][i] == -1){
6416                     U->team = -1;
6417                     if(unitTeam[j][i] == -1){
6418                         U->joinArmyFromNext = false;
6419                         U->persuasion = true;
6420                     }
6421                     U->CPU = true;
6422                 }
6423                 if(unitNum[j][i] >= 0) [self SetUnitStatus:unitNum[j][i]];
6424                 if(loadNum[j][i] >= 0) [self SetUnitStatus2:loadNum[j][i]];
6425
6426                 U->next = calloc(1, sizeof(UNIT));
6427                 U->atkRange = 0;
6428
6429                 U->ix = U->x;
6430                 U->iy = U->y;
6431                 U->iz = 0;
6432
6433                 UNIT *Ucrnt = U;
6434
6435                 U = UTop;
6436                 while(U){
6437                     if(Ucrnt->x == U->x && Ucrnt->y == U->y){
6438                         Ucrnt->iz++;
6439                     }
6440                     U = U->next;
6441                 }
6442
6443                 U = Ucrnt;
6444             }
6445
6446         }
6447     }
6448
6449     if(U) U->next = NULL;
6450
6451     U = UTop;
6452 }
6453
6454 -(void)initBuildStatusDat{
6455     B = NULL;
6456     BTop = NULL;
6457     for(int i = 0;i < sdd2[datRow].registerNumB;i++){
6458         if(i == 0){
6459             B = calloc(1, sizeof(BUILD));
6460             BTop = B;
6461         }
6462         if(i > 0)
6463             B = B->next;
6464
6465         B->x = sdd2[datRow].dB[i].x;
6466         B->y = sdd2[datRow].dB[i].y;
6467         B->team = sdd2[datRow].dB[i].team;
6468         B->number = sdd2[datRow].dB[i].number;
6469         B->chipNumber = sdd2[datRow].dB[i].chipNumber;
6470         B->makeLv = sdd2[datRow].dB[i].makeLv;
6471         B->dead = sdd2[datRow].dB[i].dead;
6472
6473         B->C = BC[B->chipNumber];
6474         B->C.S_C = sdd2[datRow].dB[i].C.S_C;
6475
6476         B->img = [BC[B->chipNumber].img retain];
6477
6478         buildTeam[B->x][B->y] = B->team;
6479         buildNum[B->x][B->y] = B->chipNumber;
6480
6481         B->next = calloc(1, sizeof(BUILD));
6482     }
6483     if(B) B->next = NULL;
6484     B = BTop;
6485
6486 }
6487
6488
6489 -(void)initBuildStatus{
6490     B = NULL;
6491     BTop = NULL;
6492     for(int i=1;i <= chipHeight;i++){
6493         for(int j=1;j<= chipWidth;j++){
6494             if(buildNum[j][i] >= 0){
6495                 registerNumB++;
6496                 if(registerNumB == 1){
6497                     B = calloc(1, sizeof(BUILD));
6498                     BTop = B;
6499                 }
6500                 if(registerNumB > 1)
6501                     B = B->next;
6502                 B->x = j;
6503                 B->y = i;
6504                 B->number = registerNumB;
6505                 B->chipNumber = buildNum[j][i];
6506                 B->makeLv = 1;
6507                 if(buildTeam[j][i] == 0 || buildTeam[j][i] == 1){
6508                     B->team = 0;
6509
6510                 }
6511                 if(buildTeam[j][i] == 2 || buildTeam[j][i] == 3){
6512                     B->team = 2;
6513
6514                 }
6515                 if(buildTeam[j][i] == 4 || buildTeam[j][i] == 5){
6516                     B->team = 1;
6517
6518                 }
6519                 if(buildTeam[j][i] == -1){
6520                     B->team = -1;
6521
6522                 }
6523                 //[self SetUnitStatus:unitNum[j][i]];
6524
6525                 B->C = BC[buildNum[j][i]];
6526
6527                 B->next = calloc(1, sizeof(BUILD));
6528
6529             }
6530
6531         }
6532     }
6533     if(B) B->next = NULL;
6534     B = BTop;
6535
6536 }
6537
6538 -(void)SetUnitStatus:(int)UN{
6539
6540     U->C = UC[UN];
6541     U->C.S_C.vigor = 100;
6542
6543     ATTACK *Atop;
6544     ATTACK *AtopE1;
6545     ATTACK *AtopE2;
6546     ATTACK *UAtop;
6547     Atop = UC[UN].A;
6548     AtopE1 = UC[UN].eHandL.A;
6549     AtopE2 = UC[UN].eHandR.A;
6550     U->C.A = calloc(1, sizeof(ATTACK));
6551     UAtop = U->C.A;
6552
6553     bool ow1 = false;
6554     bool ow2 = false;
6555
6556     while(UC[UN].eHandR.A != NULL){ow1 = true;
6557         *U->C.A = *UC[UN].eHandR.A;
6558         U->C.A->next = calloc(1, sizeof(ATTACK));
6559         U->C.A->next->next = NULL;
6560         if(UC[UN].eHandR.A->next != NULL) U->C.A = U->C.A->next;
6561         UC[UN].eHandR.A = UC[UN].eHandR.A->next;
6562         U->C.attackListNum++;
6563     }
6564     UC[UN].eHandR.A = AtopE2;
6565
6566
6567     if(ow1) {
6568         U->C.A = U->C.A->next;
6569         ow1 = false;
6570     }
6571     while(UC[UN].eHandL.A != NULL){ow2 = true;
6572         *U->C.A = *UC[UN].eHandL.A;
6573         U->C.A->next = calloc(1, sizeof(ATTACK));
6574         U->C.A->next->next = NULL;
6575         if(UC[UN].eHandL.A->next != NULL) U->C.A = U->C.A->next;
6576         UC[UN].eHandL.A = UC[UN].eHandL.A->next;
6577         U->C.attackListNum++;
6578     }
6579     UC[UN].eHandL.A = AtopE1;
6580
6581     if(ow2) {
6582         U->C.A = U->C.A->next;
6583         ow2 = false;
6584     }
6585     while(UC[UN].A != NULL){
6586         *U->C.A = *UC[UN].A;
6587         U->C.A->next = calloc(1, sizeof(ATTACK));
6588         U->C.A->next->next = NULL;
6589         if(UC[UN].A->next != NULL) U->C.A = U->C.A->next;
6590         UC[UN].A = UC[UN].A->next;
6591     }
6592     U->C.A->next = NULL;
6593     UC[UN].A = Atop;
6594     U->C.A = UAtop;
6595     if(U->C.A) if(!U->C.A->name)
6596         U->C.A = NULL;
6597
6598 }
6599
6600 -(void)SetUnitStatus2:(int)UN{
6601
6602     U->CL = LC[UN];
6603
6604     ATTACK *Atop;
6605     ATTACK *UAtop;
6606     Atop = LC[UN].A;
6607     U->CL.A = calloc(1, sizeof(ATTACK));
6608     UAtop = U->CL.A;
6609     while(LC[UN].A != NULL){
6610         *U->CL.A = *LC[UN].A;
6611         U->CL.A->next = calloc(1, sizeof(ATTACK));
6612         U->CL.A->next->next = NULL;
6613         if(LC[UN].A->next != NULL) U->CL.A = U->CL.A->next;
6614         LC[UN].A = LC[UN].A->next;
6615     }
6616     U->CL.A->next = NULL;
6617     LC[UN].A = Atop;
6618     U->CL.A = UAtop;
6619
6620 }
6621
6622
6623 -(void)initCAttackList2{
6624     crCAL = 0;
6625
6626     CAttackListMA = [NSMutableArray new];
6627
6628     [self willChangeValueForKey:@"CAttackListMA"];
6629     [CAttackListMA removeAllObjects];
6630     [self didChangeValueForKey:@"CAttackListMA"];
6631
6632     U = UTop;
6633     if(!battleSet2PushedFlag){
6634         ATTACK *Atop;
6635         while (!(AUN[1] == U->number)) {
6636             U = U->next;
6637         }
6638         Atop = U->CL.A;
6639         for(int i = 0;i < U->CL.attackListNum;i++){
6640             if(!U->CL.A) break;
6641             NSMutableDictionary* dict = [NSMutableDictionary new];
6642             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6643             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6644             if(U->CL.A->rangeA != U->CL.A->rangeB){
6645                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6646             }else{
6647                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6648             }
6649             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6650             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6651
6652             [self willChangeValueForKey:@"CAttackListMA"];
6653             [CAttackListMA addObject:dict];
6654             [self didChangeValueForKey:@"CAttackListMA"];
6655
6656             U->CL.A = U->CL.A->next;
6657         }
6658
6659         U->CL.A = Atop;
6660     }else{
6661         ATTACK *Atop;
6662         while (!(DUN[1] == U->number)) {
6663             U = U->next;
6664         }
6665         Atop = U->CL.A;
6666         for(int i = 0;i < U->CL.attackListNum;i++){
6667
6668             if(!U->CL.A){
6669                 U->CL.attackListNum = i;
6670                 break;
6671             }
6672             NSMutableDictionary* dict = [NSMutableDictionary new];
6673             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6674             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6675             if(U->CL.A->rangeA != U->CL.A->rangeB){
6676                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6677             }else{
6678                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6679             }
6680             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6681             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6682
6683             [self willChangeValueForKey:@"CAttackListMA"];
6684             [CAttackListMA addObject:dict];
6685             [self didChangeValueForKey:@"CAttackListMA"];
6686
6687             U->CL.A = U->CL.A->next;
6688         }
6689
6690         U->CL.A = Atop;
6691
6692     }
6693     U = UTop;
6694
6695     [CAttackListAC setSelectionIndex:crCAL];
6696
6697     [self initCAttackSelect2];
6698
6699
6700
6701
6702 }
6703
6704 -(void)initCAttackList{
6705     crCAL = 0;
6706     CAttackListMA = [NSMutableArray new];
6707
6708     [self willChangeValueForKey:@"CAttackListMA"];
6709     [CAttackListMA removeAllObjects];
6710     [self didChangeValueForKey:@"CAttackListMA"];
6711
6712     U = UTop;
6713     if(!battleSet2PushedFlag){
6714         ATTACK *Atop;
6715     while (!(AUN[1] == U->number)) {
6716         U = U->next;
6717     }
6718     Atop = U->C.A;
6719         for(int i = 0;i < U->C.attackListNum;i++){
6720             if(!U->C.A) {
6721                 U->C.attackListNum = i;
6722                 break;
6723             };
6724         NSMutableDictionary* dict = [NSMutableDictionary new];
6725         [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6726         [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6727         if(U->C.A->rangeA != U->C.A->rangeB){
6728             [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6729         }else{
6730             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6731         }
6732         [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6733         //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6734
6735         [self willChangeValueForKey:@"CAttackListMA"];
6736         [CAttackListMA addObject:dict];
6737         [self didChangeValueForKey:@"CAttackListMA"];
6738
6739         U->C.A = U->C.A->next;
6740     }
6741
6742     U->C.A = Atop;
6743     }else{
6744
6745         ATTACK *Atop;
6746         while (!(DUN[1] == U->number)) {
6747             U = U->next;
6748         }
6749         Atop = U->C.A;
6750         for(int i = 0;i < U->C.attackListNum;i++){
6751             NSMutableDictionary* dict = [NSMutableDictionary new];
6752             [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6753             [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6754             if(U->C.A->rangeA != U->C.A->rangeB){
6755                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6756             }else{
6757                 [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6758             }
6759             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6760             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6761
6762             [self willChangeValueForKey:@"CAttackListMA"];
6763             [CAttackListMA addObject:dict];
6764             [self didChangeValueForKey:@"CAttackListMA"];
6765
6766             U->C.A = U->C.A->next;
6767         }
6768
6769         U->C.A = Atop;
6770
6771     }
6772     U = UTop;
6773
6774     [CAttackListAC setSelectionIndex:crCAL];
6775
6776     [self initCAttackSelect];
6777 }
6778
6779 -(void)initBCreateList{
6780     BCreateListMA = [NSMutableArray new];
6781
6782     [self willChangeValueForKey:@"BCreateListMA"];
6783     [BCreateListMA removeAllObjects];
6784     [self didChangeValueForKey:@"BCreateListMA"];
6785     buildSkillFlag = false;
6786
6787     U = UTop;
6788     SKILL *Stop;
6789     while (!(AUN[1] == U->number)) {
6790         U = U->next;
6791     }
6792     Stop = U->C.S;
6793     if(!U->C.S) {
6794         U = UTop;
6795         return;
6796     }
6797     while (U->C.S->type != 1 && U->C.S->next) {
6798         U->C.S = U->C.S->next;
6799     }
6800     if(U->C.S->type != 1) {
6801         U->C.S = Stop;
6802         U = UTop;
6803         return;
6804     }
6805     for(int i = 0;U->C.S->list[i] > 0;i++){
6806         NSMutableDictionary* dict = [NSMutableDictionary new];
6807         [dict setValue:[NSString stringWithFormat:@"%@", BC[U->C.S->list[i]-1].name] forKey:@"name"];
6808         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d",
6809                         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"];
6810         [dict setValue:BC[U->C.S->list[i]-1].img forKey:@"img"];
6811
6812         [self willChangeValueForKey:@"BCreateListMA"];
6813         [BCreateListMA addObject:dict];
6814         [self didChangeValueForKey:@"BCreateListMA"];
6815
6816         buildSkillFlag = true;
6817     }
6818     U->C.S = Stop;
6819     U = UTop;
6820 }
6821
6822 -(void)initCSummonList{
6823     CSummonListMA = [NSMutableArray new];
6824
6825     [self willChangeValueForKey:@"CSummonListMA"];
6826     [CSummonListMA removeAllObjects];
6827     [self didChangeValueForKey:@"CSummonListMA"];
6828
6829     summonSkillFlag = false;
6830
6831     U = UTop;
6832     SKILL *Stop;
6833     while (!(AUN[1] == U->number)) {
6834         U = U->next;
6835     }
6836     Stop = U->C.S;
6837     if(!U->C.S) {
6838         U = UTop;
6839         return;
6840     }
6841     while (U->C.S->type != 2 && U->C.S->next) {
6842         U->C.S = U->C.S->next;
6843     }
6844     if(U->C.S->type != 2) {
6845         U->C.S = Stop;
6846         U = UTop;
6847         return;
6848     }
6849     for(int i = 0;U->C.S->list[i] > 0;i++){
6850         NSMutableDictionary* dict = [NSMutableDictionary new];
6851         [dict setValue:[NSString stringWithFormat:@"%@", UC[U->C.S->list[i]-1].nameClass] forKey:@"name"];
6852         [dict setValue:[NSString stringWithFormat:@"%g", UC[U->C.S->list[i]-1].S_M.HP] forKey:@"HP"];
6853         [dict setValue:[NSString stringWithFormat:@"%g", U->C.S->cost[i]] forKey:@"cost"];
6854         [dict setValue:UC[U->C.S->list[i]-1].img forKey:@"img"];
6855
6856         [self willChangeValueForKey:@"CSummonListMA"];
6857         [CSummonListMA addObject:dict];
6858         [self didChangeValueForKey:@"CSummonListMA"];
6859
6860         summonSkillFlag = true;
6861     }
6862     U->C.S = Stop;
6863     U = UTop;
6864
6865 }
6866
6867
6868 -(void)AttackDisplay{
6869
6870     if(battleRdy) return;
6871     if(!battleSetUp) return;
6872     if(!fuckingLoadBugFix) return;
6873
6874     U = UTop;
6875     while (!(AUN[1] == U->number)) {
6876         U = U->next;
6877     }
6878     [bplayer1 setImage:U->C.imgb];
6879     [bplayer1 setImageScaling:NSScaleToFit];
6880     [nplayer1 setStringValue:U->C.name];
6881     [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6882     [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6883     [iplayer1 setImage:MC[chipNum[U->x][U->y]].img];
6884     [mplayer1 setStringValue:MC[chipNum[U->x][U->y]].name];
6885     [rplayer1 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6886
6887     U = UTop;
6888
6889
6890     U = UTop;
6891     while (!(DUN[1] == U->number)) {
6892         U = U->next;
6893     }
6894     [bplayer2 setImage:U->C.imgb];
6895     [bplayer1 setImageScaling:NSScaleToFit];
6896     [nplayer2 setStringValue:U->C.name];
6897     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6898     [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6899     [iplayer2 setImage:MC[chipNum[U->x][U->y]].img];
6900     [mplayer2 setStringValue:MC[chipNum[U->x][U->y]].name];
6901     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6902     U = UTop;
6903
6904     [self AttackDisplay2];
6905
6906     messageProcess = 0;
6907     [battleDialog setStringValue:@"攻撃開始!!!!"];
6908
6909     battleRdy = true;
6910
6911 }
6912
6913 -(void)AttackDisplay2{
6914
6915     U = UTop;
6916
6917     while (!(DUN[1] == U->number)) {
6918         U = U->next;
6919     }
6920     U2 = U;
6921     U = UTop;
6922     while (!(AUN[1] == U->number)) {
6923         U = U->next;
6924     }
6925
6926
6927     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){U = UTop;
6928
6929         U = UTop;
6930         while (!(AUN[1] == U->number)) {
6931             U = U->next;
6932         }
6933         [bplayer1 setImage:U->CL.imgb];
6934         [bplayer1 setImageScaling:NSScaleToFit];
6935         [nplayer1 setStringValue:U->CL.name];
6936         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6937         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6938
6939         U = UTop;
6940
6941
6942         U = UTop;
6943         while (!(DUN[1] == U->number)) {
6944             U = U->next;
6945         }
6946         [bplayer2 setImage:U->CL.imgb];
6947         [bplayer1 setImageScaling:NSScaleToFit];
6948         [nplayer2 setStringValue:U->CL.name];
6949         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6950         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6951         U = UTop;
6952
6953
6954     }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){U = UTop;
6955         U = UTop;
6956         while (!(AUN[1] == U->number)) {
6957             U = U->next;
6958         }
6959         [bplayer1 setImage:U->CL.imgb];
6960         [bplayer1 setImageScaling:NSScaleToFit];
6961         [nplayer1 setStringValue:U->CL.name];
6962         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
6963         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
6964
6965         U = UTop;
6966
6967
6968         U = UTop;
6969         while (!(DUN[1] == U->number)) {
6970             U = U->next;
6971         }
6972         [bplayer2 setImage:U->C.imgb];
6973         [bplayer1 setImageScaling:NSScaleToFit];
6974         [nplayer2 setStringValue:U->C.name];
6975         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6976         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6977         U = UTop;
6978
6979
6980
6981
6982     }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){U = UTop;
6983         U = UTop;
6984         while (!(AUN[1] == U->number)) {
6985             U = U->next;
6986         }
6987         [bplayer1 setImage:U->C.imgb];
6988         [bplayer1 setImageScaling:NSScaleToFit];
6989         [nplayer1 setStringValue:U->C.name];
6990         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6991         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6992
6993         U = UTop;
6994
6995
6996         U = UTop;
6997         while (!(DUN[1] == U->number)) {
6998             U = U->next;
6999         }
7000         [bplayer2 setImage:U->CL.imgb];
7001         [bplayer1 setImageScaling:NSScaleToFit];
7002         [nplayer2 setStringValue:U->CL.name];
7003         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7004         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
7005         U = UTop;
7006     }
7007
7008
7009     U = UTop;
7010 }
7011
7012 -(bool)sortEcheck:(ATTACK*)AT opponent:(UNIT*)UT{
7013
7014     if(AT->riku == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_RIKU)
7015         return true;
7016     if(AT->umi == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_UMI)
7017         return true;
7018     if(AT->chu == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_CHU)
7019         return true;
7020     if(AT->sora == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_SORA)
7021         return true;
7022
7023
7024
7025     return false;
7026 }
7027
7028 -(void)setBattlePanel{
7029     //おまんちん
7030     U = UTop;
7031
7032     while (!(DUN[1] == U->number)) {
7033         U = U->next;
7034     }
7035     U2 = U;
7036     U = UTop;
7037     while (!(AUN[1] == U->number)) {
7038         U = U->next;
7039     }
7040
7041     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
7042         U = UTop;
7043         [self setBattlePanelT2];
7044         return;
7045     }else if(U->chipNumberL >= 0 && U2->chipNumberL <= 0){
7046         U = UTop;
7047         [self setBattlePanelT3];
7048         return;
7049     }else if(U->chipNumberL <= 0 && U2->chipNumberL >= 0){
7050         U = UTop;
7051         [self setBattlePanelT4];
7052         return;
7053     }
7054
7055     U = UTop;
7056     while (!(AUN[1] == U->number)) {
7057         U = U->next;
7058     }
7059
7060     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7061         cpuModeBATTLEflag = false;
7062     int mostDmg = 0;
7063     int mostDmg2 = 0;
7064     int mostHit = 0;
7065     int mostNum = 0;
7066     int num = 0;
7067     ATTACK *aTop2 = U->C.A;
7068     int mpCost = 0;
7069     if(U->C.A)
7070         if(!U->C.A->D){
7071             U->C.A = NULL;
7072             aTop2 = U->C.A;
7073         }
7074
7075
7076
7077     while(U->C.A){
7078
7079         double urSupposedToGet;
7080
7081         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7082
7083         double asItIs;
7084
7085         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7086
7087
7088         double oopsIsRight = 0;
7089
7090         if(U->C.A){
7091             if(U->C.A->melee){
7092                 oopsIsRight = U->C.S_C.MEL;
7093             }else
7094                 oopsIsRight = U->C.S_C.MIS;
7095         }
7096         oopsIsRight = oopsIsRight/100;
7097
7098         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7099
7100         if(!U2->C.aura && U->C.A->D){
7101             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
7102                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7103             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
7104                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7105             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
7106                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7107             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
7108                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7109             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
7110                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7111             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7112         }else if(U->C.A->D){
7113             double val = val = 1/log(3+U2->C.S_C.MP/64);
7114             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
7115                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7116             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
7117                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7118             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
7119                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7120             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
7121                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7122             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
7123                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7124             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7125         }
7126         double val2 = log(3+U2->C.S_C.MP/64);
7127         if(U->C.aura){
7128             mostDmg2 = mostDmg2*val2;
7129         }
7130         if(U->C.A->D){
7131             if(U->C.A->D->fix == 2){
7132                 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;
7133
7134                 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;
7135                 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;
7136                 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;
7137                 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;
7138                 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;
7139
7140
7141             }else if(U->C.A->D->fix == 1){
7142                 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;
7143
7144                 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;
7145                 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;
7146                 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;
7147                 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;
7148                 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;
7149
7150             }else if(U->C.A->D->fix == 0){
7151
7152             }
7153         }
7154
7155
7156         U2A = U->C.A;
7157         costVIG = U->C.A->vigor;
7158         UNIT *oops = U;
7159         U = U2;
7160         mostDmg2 = [self dmgResist:mostDmg2];
7161
7162         //NSLog(@"crCAL1 %d", crCAL1);
7163         if(mostDmg2 < 0) mostDmg2 = 1;
7164         U = oops;
7165         if(U->C.A->D)
7166         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]){
7167
7168             mostDmg = mostDmg2;
7169
7170             //mostDmg = U->C.A->totalD;
7171             mostNum = num;
7172         }
7173         if(U->C.A->D)
7174         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]){
7175             //mostDmg = U->C.A->totalD;
7176             mostHit = U->C.A->hitPercent;
7177             mostNum = num;
7178         }
7179         U->C.A = U->C.A->next;
7180         num++;
7181     }
7182     U->C.A = aTop2;
7183
7184         if(U->C.A->extent == 0 && mostNum >= 0 && !CPUmostDmgChoice){
7185
7186             U->C.A = aTop2;
7187             crCAL1 = 0;
7188             for(int i = 0;i < mostNum;i++){
7189                 U->C.A = U->C.A->next;
7190                 crCAL1++;
7191             }
7192         }
7193         else{
7194         U->C.A = aTop2;
7195             for(int i = 0;i < crCAL1;i++){
7196                 U->C.A = U->C.A->next;
7197             }
7198         }
7199
7200         CPUmostDmgChoice = false;
7201
7202    if(U->C.A){
7203         mostNumSub = mostNum;
7204
7205
7206         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7207        costVIG = U->C.A->vigor;
7208
7209         if(U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange
7210            && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
7211
7212         }else{
7213
7214         }
7215
7216     }U->C.A = aTop2;
7217     }
7218     U = UTop;
7219
7220     while (!(AUN[1] == U->number)) {
7221         U = U->next;
7222     }
7223     U2 = U;
7224
7225     ATTACK *aTop = U->C.A;
7226     ATTACK *u2A;
7227
7228     for(int i = 0;i < crCAL1;i++){
7229         U->C.A = U->C.A->next;
7230     }
7231
7232     //NSLog(@"%@", U->C.A->name);
7233
7234     if(battleSet1Flag){
7235         U->C.A = aTop;
7236         for (int i = 0;i < crCAL1;i++) {
7237             U->C.A = U->C.A->next;
7238         }
7239
7240     }
7241
7242     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7243     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7244     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7245     //NSLog(@"crCAL1 %d", crCAL1);
7246     if(U->C.A){
7247         [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7248
7249     }
7250     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7251     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7252     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
7253     [combatLHP1 setIntValue:(int)oops];
7254     oops = U->C.S_C.MP/U->C.S_M.MP*100;
7255     [combatLMP1 setIntValue:(int)oops];
7256
7257     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7258     //NSLog(@"mostNumSub %d crCAL1 %d", mostNumSub, crCAL1);
7259     hitFix = U->C.A->hitPercent;
7260
7261     u2A = U->C.A;
7262     U->C.A = aTop;
7263
7264     if(battleDef1Flag){
7265         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7266         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7267         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7268         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7269         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7270         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7271         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7272     }
7273     if(battleDod1Flag){
7274         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7275         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7276         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7277         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7278         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7279         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7280         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7281
7282     }
7283
7284
7285
7286
7287
7288
7289
7290     U = UTop;
7291     while (!(DUN[1] == U->number)) {
7292         U = U->next;
7293     }
7294
7295     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7296
7297     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7298     if(hi < 0) hi = 0;
7299
7300     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7301
7302     if(battleDod2Flag) hit = hit / 2;
7303     hit = floor(hit);
7304
7305     if(hit > 100) hit = 100;
7306     if(hit < 0) hit = 0;
7307
7308     if(u2A->D->sort == 1){
7309         hit = 100;
7310     }
7311
7312     if([self sortEcheck:u2A opponent:U])
7313         hit = 0;
7314     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7315     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7316
7317
7318
7319     int mostDmg = 0;
7320     int mostDmg2 = 0;
7321     int mostHit = 0;
7322     int mostNum = 0;
7323     int num = 0;
7324     ATTACK *aTop2 = U->C.A;
7325     int mpCost = 0;
7326
7327
7328     while(U->C.A){
7329
7330         double urSupposedToGet;
7331
7332         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7333
7334         double asItIs;
7335         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7336
7337         double oopsIsRight = 0;
7338
7339         if(U->C.A){
7340             if(U->C.A->melee){
7341                 oopsIsRight = U->C.S_C.MEL;
7342             }else
7343                 oopsIsRight = U->C.S_C.MIS;
7344         }
7345         oopsIsRight = oopsIsRight/100;
7346
7347         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7348
7349         if(!U2->C.aura && U->C.A->D){
7350             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
7351                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7352             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
7353                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7354             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
7355                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7356             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
7357                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7358             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
7359                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7360             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7361         }else if(U->C.A->D){
7362             double val = val = 1/log(3+U2->C.S_C.MP/64);
7363             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
7364                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7365             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
7366                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7367             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
7368                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7369             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
7370                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7371             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
7372                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7373             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7374         }
7375         double val2 = log(3+U2->C.S_C.MP/64);
7376         if(U->C.aura){
7377             mostDmg2 = mostDmg2*val2;
7378         }
7379         if(U->C.A->D){
7380             if(U->C.A->D->fix == 2){
7381                 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;
7382
7383                 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;
7384                 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;
7385                 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;
7386                 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;
7387                 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;
7388
7389
7390             }else if(U->C.A->D->fix == 1){
7391                 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;
7392
7393                 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;
7394                 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;
7395                 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;
7396                 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;
7397                 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;
7398
7399             }else if(U->C.A->D->fix == 0){
7400
7401             }
7402         }
7403
7404         U2A = U->C.A;
7405
7406         UNIT *oops = U;
7407         //U = U2;
7408         mostDmg2 = [self dmgResist:mostDmg2];
7409         U = oops;
7410
7411         costVIG = U->C.A->vigor;
7412
7413         if(U->C.A->D)
7414         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]){
7415
7416             mostDmg = mostDmg2;
7417
7418             //mostDmg = U->C.A->totalD;
7419             mostNum = num;
7420         }
7421         if(U->C.A->D)
7422         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]){
7423             //mostDmg = U->C.A->totalD;
7424             mostHit = U->C.A->hitPercent;
7425             mostNum = num;
7426         }
7427         U->C.A = U->C.A->next;
7428         num++;
7429     }
7430
7431
7432
7433     U->C.A = aTop2;
7434     if(U->C.A){
7435     mostNumSub = mostNum;
7436
7437     for(int i = 0;i < mostNum;i++){
7438         U->C.A = U->C.A->next;
7439     }
7440     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7441
7442
7443         costVIG = U->C.A->vigor;
7444
7445
7446     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){
7447
7448     }else while(U->C.A){
7449         U->C.A = U->C.A->next;
7450     }
7451
7452     }
7453
7454
7455
7456     if(battleSet2Flag){
7457             U->C.A = aTop2;
7458         //NSLog(@"%@", U->C.name);
7459         for (int i = 0;i < crCAL2;i++) {
7460             U->C.A = U->C.A->next;
7461         }
7462     }
7463
7464
7465     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7466     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7467     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7468     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7469     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7470     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
7471     [combatLHP2 setIntValue:(int)oops2];
7472     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
7473     [combatLMP2 setIntValue:(int)oops2];
7474
7475     bool counter;
7476     int mpCost2 = 0;
7477     if(U->C.A){
7478         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7479         costVIG = U->C.A->vigor;
7480
7481     }
7482     if(U->C.A && U->C.A->D){
7483     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]){
7484         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7485         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7486         hitFix = U->C.A->hitPercent;
7487         counter = true;
7488     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U]){
7489         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7490     }
7491     }else{
7492         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7493     }
7494     U2A = U->C.A;
7495     U->C.A = aTop2;
7496
7497     if(battleDef2Flag){
7498         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7499         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7500         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7501         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7502         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7503         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7504         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7505     }
7506
7507     if(battleDod2Flag){
7508         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7509         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7510         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7511         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7512         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7513         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7514         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7515
7516     }
7517     U = UTop;
7518     while (!(DUN[1] == U->number)) {
7519         U = U->next;
7520     }
7521     U2 = U;
7522
7523     U = UTop;
7524     while (!(AUN[1] == U->number)) {
7525         U = U->next;
7526     }
7527
7528     if(counter){
7529
7530         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7531
7532
7533         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7534         if(hi < 0) hi = 0;
7535
7536         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7537         if(battleDod1Flag) hit /= 2;
7538         hit = floor(hit);
7539
7540         if(hit > 100) hit = 100;
7541         if(hit < 0) hit = 0;
7542
7543         if([self sortEcheck:U2A opponent:U])
7544             hit = 0;
7545
7546         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7547         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7548
7549     }else{
7550         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7551     }
7552
7553     U = UTop;
7554
7555     if(CPUAttackSubmitFlag){
7556         if(unitCPUAttackFlag){
7557             [battleCancelBtn setEnabled:NO];
7558             [battleCancelBtn setTransparent:YES];
7559         }else{
7560             [battleCancelBtn setEnabled:YES];
7561             [battleCancelBtn setTransparent:NO];
7562         }
7563         if(displayBattleCheckPanelFlag == 0) displayBattleCheckPanelFlag = 1;
7564     }else{
7565         [battleCancelBtn setEnabled:YES];
7566         [battleCancelBtn setTransparent:NO];
7567     }
7568
7569     U = UTop;
7570     while (!(AUN[1] == U->number)) {
7571         U = U->next;
7572     }
7573
7574     if(U->CPU){
7575         [battleAttackBtn1 setEnabled:NO];
7576         [battleAttackBtn1 setTransparent:YES];
7577         [battleGuardBtn1 setEnabled:NO];
7578         [battleGuardBtn1 setTransparent:YES];
7579         [battleDodgeBtn1 setEnabled:NO];
7580         [battleDodgeBtn1 setTransparent:YES];
7581     }else{
7582         [battleAttackBtn1 setEnabled:YES];
7583         [battleAttackBtn1 setTransparent:NO];
7584         [battleGuardBtn1 setEnabled:YES];
7585         [battleGuardBtn1 setTransparent:NO];
7586         [battleDodgeBtn1 setEnabled:YES];
7587         [battleDodgeBtn1 setTransparent:NO];
7588     }U = UTop;
7589
7590     U = UTop;
7591     while (!(DUN[1] == U->number)) {
7592         U = U->next;
7593     }
7594     if(U->CPU){
7595         [battleAttackBtn2 setEnabled:NO];
7596         [battleAttackBtn2 setTransparent:YES];
7597         [battleGuardBtn2 setEnabled:NO];
7598         [battleGuardBtn2 setTransparent:YES];
7599         [battleDodgeBtn2 setEnabled:NO];
7600         [battleDodgeBtn2 setTransparent:YES];
7601     }else{
7602         [battleAttackBtn2 setEnabled:YES];
7603         [battleAttackBtn2 setTransparent:NO];
7604         [battleGuardBtn2 setEnabled:YES];
7605         [battleGuardBtn2 setTransparent:NO];
7606         [battleDodgeBtn2 setEnabled:YES];
7607         [battleDodgeBtn2 setTransparent:NO];
7608     }U = UTop;
7609
7610
7611
7612     U = UTop;
7613
7614     for (int i = 1; i < DUN[1]; i++) {
7615         U = U->next;
7616
7617     }
7618
7619
7620     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
7621        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
7622        ){
7623
7624  //おまんこかわいい
7625
7626
7627     }else{
7628         [battleStartBtn setEnabled:YES];
7629         [battleStartBtn setTransparent:NO];
7630     }
7631
7632     U = UTop;
7633
7634     avPlayerFlag1 = false;
7635     avPlayerFlag2 = false;
7636 }
7637
7638 -(void)setBattlePanelT2{
7639
7640     U = UTop;
7641     int mpCost = 0;
7642     ATTACK *aTop2 = U->CL.A;
7643     while (!(AUN[1] == U->number)) {
7644         U = U->next;
7645     }
7646
7647     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7648         cpuModeBATTLEflag = false;
7649     int mostDmg = 0;
7650     int mostHit = 0;
7651     int mostNum = -1;
7652     int num = 0;
7653     int mpCost = 0;
7654     while(U->CL.A){
7655         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7656         costVIG = U->C.A->vigor;
7657         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]){
7658             mostDmg = U->CL.A->totalD;
7659             mostNum = num;
7660         }
7661         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]){
7662             //mostDmg = U->C.A->totalD;
7663             mostHit = U->CL.A->hitPercent;
7664             mostNum = num;
7665         }
7666         U->CL.A = U->CL.A->next;
7667         num++;
7668     }
7669         U->CL.A = aTop2;
7670
7671         for(int i = 0;i < crCAL1;i++){
7672             U->CL.A = U->CL.A->next;
7673
7674         }
7675         ATTACK *ua = U->CL.A;
7676
7677         U->CL.A = aTop2;
7678
7679     mostNumSub = mostNum;
7680
7681         U->CL.A = aTop2;
7682
7683         for(int i = 0;i < mostNum;i++){
7684             U->C.A = U->CL.A->next;
7685         }
7686         if(U->CL.A->extent == 0){
7687
7688             U->CL.A = aTop2;
7689             crCAL1 = 0;
7690             for(int i = 0;i < mostNum;i++){
7691                 U->CL.A = U->CL.A->next;
7692                 crCAL1++;
7693             }
7694         }
7695         else{
7696             U->CL.A = aTop2;
7697             for(int i = 0;i < crCAL1;i++){
7698                 U->CL.A = U->CL.A->next;
7699             }
7700         }
7701     }else{
7702
7703         U->CL.A = NULL;
7704     }
7705     if(U->CL.A){
7706         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7707         costVIG = U->C.A->vigor;
7708     }
7709     if(U->CL.A){
7710         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){
7711
7712         }else while(U->CL.A){
7713             U->CL.A = U->CL.A->next;
7714             crCAL1++;
7715         }
7716     }U->CL.A = aTop2;
7717
7718
7719     U = UTop;
7720     while (!(AUN[1] == U->number)) {
7721         U = U->next;
7722     }
7723     U2 = U;
7724
7725     ATTACK *aTop = U->CL.A;
7726     ATTACK *u2A;
7727
7728     if(U->C.A)
7729         crCAL1 = crCAL;
7730
7731     for(int i = 0;i < crCAL1;i++){
7732         U->CL.A = U->CL.A->next;
7733     }
7734
7735
7736     if(battleSet1Flag){
7737
7738         U->CL.A = aTop;
7739         for (int i = 0;i < crCAL1;i++) {
7740             U->CL.A = U->CL.A->next;
7741         }
7742
7743     }
7744
7745     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7746     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7747     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7748     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7749     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7750     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7751     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
7752     [combatLHP1 setIntValue:(int)oops];
7753     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
7754     [combatLMP1 setIntValue:(int)oops];
7755
7756     hit = U->CL.S_C.MOB + U->C.S_C.HIT*U->C.S_C.HP/U->C.S_M.HP;
7757     hitFix = U->CL.A->hitPercent;
7758
7759     u2A = U->CL.A;
7760     U->CL.A = aTop;
7761
7762     if(battleDef1Flag){
7763         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7764         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7765         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7766         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7767         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7768         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7769         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7770     }
7771     if(battleDod1Flag){
7772         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7773         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7774         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7775         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7776         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7777         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7778         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7779
7780     }
7781
7782
7783
7784
7785
7786
7787
7788     U = UTop;
7789     while (!(DUN[1] == U->number)) {
7790         U = U->next;
7791     }
7792
7793     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;
7794     if(battleDod2Flag) hit = hit / 2;
7795     hit = floor(hit);
7796
7797     if(hit > 100) hit = 100;
7798     if(hit < 0) hit = 0;
7799
7800     if(u2A->D->sort == 1){
7801         hit = 100;
7802     }
7803
7804     if([self sortEcheck:u2A opponent:U])
7805         hit = 0;
7806     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7807     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7808
7809
7810
7811     int mostDmg = 0;
7812     int mostHit = 0;
7813     int mostNum = -1;
7814     int num = 0;
7815     costVIG = U->C.A->vigor;
7816     while(U->CL.A){
7817         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7818         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]){
7819             mostDmg = U->CL.A->totalD;
7820             mostNum = num;
7821         }
7822         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]){
7823             //mostDmg = U->C.A->totalD;
7824             mostHit = U->CL.A->hitPercent;
7825             mostNum = num;
7826         }
7827         U->CL.A = U->CL.A->next;
7828         num++;
7829     }
7830
7831     U->CL.A = aTop2;
7832
7833     mostNumSub = mostNum;
7834
7835     if(mostNum >= 0){
7836     for(int i = 0;i < mostNum;i++){
7837         U->CL.A = U->CL.A->next;
7838     }
7839     }else{
7840
7841         U->CL.A = NULL;
7842     }
7843     if(U->CL.A){
7844         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7845         costVIG = U->C.A->vigor;
7846     }
7847     if(U->CL.A){
7848     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){
7849
7850     }else while(U->CL.A){
7851         U->CL.A = U->CL.A->next;
7852     }
7853     }
7854
7855
7856
7857     if(battleSet2Flag){
7858
7859         U->CL.A = aTop2;
7860
7861         for (int i = 0;i < crCAL2;i++) {
7862             U->CL.A = U->CL.A->next;
7863         }
7864
7865     }
7866
7867
7868     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7869     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7870     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7871     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7872     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7873     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
7874     [combatLHP2 setIntValue:(int)oops2];
7875     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
7876     [combatLMP2 setIntValue:(int)oops2];
7877
7878     bool counter;
7879     int mpCost2 = 0;
7880     if(U->CL.A && U->CL.A->D){
7881     if(U->CL.A->name){
7882
7883     if(U->CL.A){
7884         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7885
7886     }
7887     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]){
7888         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7889         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
7890         hitFix = U->CL.A->hitPercent;
7891         counter = true;
7892     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
7893         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7894     }
7895
7896     }else{
7897         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7898     }
7899     }else{
7900         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7901     }
7902     U2A = U->CL.A;
7903     U->CL.A = aTop2;
7904
7905     if(battleDef2Flag){
7906         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7907         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7908         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7909         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7910         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7911         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7912         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7913     }
7914
7915     if(battleDod2Flag){
7916         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7917         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7918         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7919         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7920         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7921         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7922         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7923
7924     }
7925     U = UTop;
7926     while (!(AUN[1] == U->number)) {
7927         U = U->next;
7928     }
7929
7930     if(counter){
7931         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;
7932         if(battleDod1Flag) hit /= 2;
7933         hit = floor(hit);
7934
7935         if(hit > 100) hit = 100;
7936         if(hit < 0) hit = 0;
7937         if([self sortEcheck:U2A opponent:U])
7938             hit = 0;
7939         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7940         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7941
7942     }else{
7943         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7944     }
7945
7946     U = UTop;
7947     while (!(AUN[1] == U->number)) {
7948         U = U->next;
7949     }
7950
7951     if(U->CPU){
7952         [battleAttackBtn1 setEnabled:NO];
7953         [battleAttackBtn1 setTransparent:YES];
7954         [battleGuardBtn1 setEnabled:NO];
7955         [battleGuardBtn1 setTransparent:YES];
7956         [battleDodgeBtn1 setEnabled:NO];
7957         [battleDodgeBtn1 setTransparent:YES];
7958     }else{
7959         [battleAttackBtn1 setEnabled:YES];
7960         [battleAttackBtn1 setTransparent:NO];
7961         [battleGuardBtn1 setEnabled:YES];
7962         [battleGuardBtn1 setTransparent:NO];
7963         [battleDodgeBtn1 setEnabled:YES];
7964         [battleDodgeBtn1 setTransparent:NO];
7965     }U = UTop;
7966
7967     U = UTop;
7968     while (!(DUN[1] == U->number)) {
7969         U = U->next;
7970     }
7971     if(U->CPU){
7972         [battleAttackBtn2 setEnabled:NO];
7973         [battleAttackBtn2 setTransparent:YES];
7974         [battleGuardBtn2 setEnabled:NO];
7975         [battleGuardBtn2 setTransparent:YES];
7976         [battleDodgeBtn2 setEnabled:NO];
7977         [battleDodgeBtn2 setTransparent:YES];
7978     }else{
7979         [battleAttackBtn2 setEnabled:YES];
7980         [battleAttackBtn2 setTransparent:NO];
7981         [battleGuardBtn2 setEnabled:YES];
7982         [battleGuardBtn2 setTransparent:NO];
7983         [battleDodgeBtn2 setEnabled:YES];
7984         [battleDodgeBtn2 setTransparent:NO];
7985     }U = UTop;
7986
7987     U = UTop;
7988
7989     for (int i = 1; i < DUN[1]; i++) {
7990         U = U->next;
7991     }
7992
7993
7994     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
7995        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
7996        ){
7997         /*
7998         [battleStartBtn setEnabled:NO];
7999         [battleStartBtn setTransparent:YES];
8000          */
8001     }else{
8002         [battleStartBtn setEnabled:YES];
8003         [battleStartBtn setTransparent:NO];
8004     }
8005
8006     U = UTop;
8007
8008     avPlayerFlag1 = false;
8009     avPlayerFlag2 = false;
8010 }
8011
8012 -(void)setBattlePanelT3{
8013
8014
8015     U = UTop;
8016     while (!(AUN[1] == U->number)) {
8017         U = U->next;
8018     }
8019
8020     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 &&MF[MFselectedRow+1].MS.playerSet2 == 2)){
8021         cpuModeBATTLEflag = false;
8022     int mostDmg = 0;
8023     int mostHit = 0;
8024     int mostNum = 0;
8025     int num = 0;
8026     ATTACK *aTop2 = U->C.A;
8027     int mpCost = 0;
8028     while(U->C.A){
8029         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8030
8031         costVIG = U->C.A->vigor;
8032         if(U->C.A->D)
8033         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]){
8034             mostDmg = U->C.A->totalD;
8035             mostNum = num;
8036         }
8037         if(U->C.A->D)
8038         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]){
8039             //mostDmg = U->C.A->totalD;
8040             mostHit = U->C.A->hitPercent;
8041             mostNum = num;
8042         }
8043         U->C.A = U->C.A->next;
8044         num++;
8045     }
8046         U->C.A = aTop2;
8047
8048         for(int i = 0;i < crCAL1;i++){
8049             U->C.A = U->C.A->next;
8050
8051         }
8052         ATTACK *ua = U->C.A;
8053
8054         U->C.A = aTop2;
8055
8056     mostNumSub = mostNum;
8057         U->C.A = aTop2;
8058
8059         for(int i = 0;i < mostNum;i++){
8060             U->C.A = U->C.A->next;
8061         }
8062         if(U->C.A->extent == 0 && mostNum > 0){
8063
8064             U->C.A = aTop2;
8065             crCAL1 = 0;
8066             for(int i = 0;i < mostNum;i++){
8067                 U->C.A = U->C.A->next;
8068                 crCAL1++;
8069             }
8070         }
8071         else{
8072             U->C.A = aTop2;
8073             for(int i = 0;i < crCAL1;i++){
8074                 U->C.A = U->C.A->next;
8075             }
8076         }
8077     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8078         costVIG = U->C.A->vigor;
8079
8080
8081     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){
8082
8083     }else{
8084
8085     }
8086       U->C.A = aTop2;
8087     }
8088
8089     U = UTop;
8090     while (!(AUN[1] == U->number)) {
8091         U = U->next;
8092     }
8093     U2 = U;
8094
8095
8096     ATTACK *aTop = U->CL.A;
8097     ATTACK *u2A;
8098
8099     if(U->C.A)
8100         crCAL1 = crCAL;
8101
8102     for(int i = 0;i < crCAL1;i++){
8103         U->CL.A = U->CL.A->next;
8104     }
8105
8106     if(battleSet1Flag){
8107
8108         U->CL.A = aTop;
8109         for (int i = 0;i < crCAL1;i++) {
8110             U->CL.A = U->CL.A->next;
8111         }
8112
8113     }
8114
8115     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8116     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8117     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8118     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8119     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8120     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8121     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
8122     [combatLHP1 setIntValue:(int)oops];
8123     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
8124     [combatLMP1 setIntValue:(int)oops];
8125
8126     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8127     hitFix = U->CL.A->hitPercent;
8128
8129     u2A = U->CL.A;
8130     U->CL.A = aTop;
8131
8132     if(battleDef1Flag){
8133         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8134         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8135         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8136         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8137         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8138         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8139         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8140     }
8141     if(battleDod1Flag){
8142         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8143         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8144         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8145         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8146         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8147         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8148         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8149
8150     }
8151
8152
8153
8154
8155
8156     U = UTop;
8157     while (!(AUN[1] == U->number)) {
8158         U = U->next;
8159     }
8160     U2 = U;
8161
8162     U = UTop;
8163     while (!(DUN[1] == U->number)) {
8164         U = U->next;
8165     }
8166
8167     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8168
8169     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8170     if(hi < 0) hi = 0;
8171
8172     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8173     if(battleDod2Flag) hit = hit / 2;
8174     hit = floor(hit);
8175
8176     if(hit > 100) hit = 100;
8177     if(hit < 0) hit = 0;
8178
8179     if(u2A->D->sort == 1){
8180         hit = 100;
8181     }
8182     if([self sortEcheck:u2A opponent:U])
8183         hit = 0;
8184     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8185     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8186
8187
8188
8189     int mostDmg = 0;
8190     int mostHit = 0;
8191     int mostNum = 0;
8192     int num = 0;
8193     ATTACK *aTop2 = U->C.A;
8194     int mpCost = 0;
8195     while(U->C.A){
8196
8197         costVIG = U->C.A->vigor;
8198
8199         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8200         if(U->C.A->D)
8201         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]){
8202             mostDmg = U->C.A->totalD;
8203             mostNum = num;
8204         }
8205         if(U->C.A->D)
8206         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]){
8207             //mostDmg = U->C.A->totalD;
8208             mostHit = U->C.A->hitPercent;
8209             mostNum = num;
8210         }
8211         U->C.A = U->C.A->next;
8212         num++;
8213     }
8214
8215     U->C.A = aTop2;
8216
8217     mostNumSub = mostNum;
8218
8219     for(int i = 0;i < mostNum;i++){
8220         U->C.A = U->C.A->next;
8221     }
8222     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8223     costVIG = U->C.A->vigor;
8224
8225     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){
8226
8227     }else while(U->C.A){
8228         U->C.A = U->C.A->next;
8229     }
8230
8231
8232     if(battleSet2Flag){
8233
8234         U->C.A = aTop2;
8235
8236         for (int i = 0;i < crCAL2;i++) {
8237             U->C.A = U->C.A->next;
8238         }
8239
8240     }
8241
8242
8243     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8244     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8245     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8246     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8247     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8248     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
8249     [combatLHP2 setIntValue:(int)oops2];
8250     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
8251     [combatLMP2 setIntValue:(int)oops2];
8252
8253     bool counter;
8254     int mpCost2 = 0;
8255     if(U->C.A){
8256         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8257         costVIG = U->C.A->vigor;
8258
8259     }
8260     if(U->C.A &&U->C.A->D){
8261     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]){
8262         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8263         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8264         hitFix = U->C.A->hitPercent;
8265         counter = true;
8266     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U2]){
8267         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8268     }}else{
8269         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8270     }
8271     U2A = U->C.A;
8272     U->C.A = aTop2;
8273
8274     if(battleDef2Flag){
8275         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8276         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8277         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8278         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8279         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8280         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8281         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8282     }
8283
8284     if(battleDod2Flag){
8285         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8286         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8287         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8288         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8289         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8290         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8291         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8292
8293     }
8294     U = UTop;
8295     while (!(AUN[1] == U->number)) {
8296         U = U->next;
8297     }
8298
8299     if(counter){
8300         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;
8301         if(battleDod1Flag) hit /= 2;
8302         hit = floor(hit);
8303
8304         if(hit > 100) hit = 100;
8305         if(hit < 0) hit = 0;
8306         if([self sortEcheck:U2A opponent:U])
8307             hit = 0;
8308         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8309         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8310
8311     }else{
8312         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8313     }
8314
8315     U = UTop;
8316     while (!(AUN[1] == U->number)) {
8317         U = U->next;
8318     }
8319
8320     if(U->CPU){
8321         [battleAttackBtn1 setEnabled:NO];
8322         [battleAttackBtn1 setTransparent:YES];
8323         [battleGuardBtn1 setEnabled:NO];
8324         [battleGuardBtn1 setTransparent:YES];
8325         [battleDodgeBtn1 setEnabled:NO];
8326         [battleDodgeBtn1 setTransparent:YES];
8327     }else{
8328         [battleAttackBtn1 setEnabled:YES];
8329         [battleAttackBtn1 setTransparent:NO];
8330         [battleGuardBtn1 setEnabled:YES];
8331         [battleGuardBtn1 setTransparent:NO];
8332         [battleDodgeBtn1 setEnabled:YES];
8333         [battleDodgeBtn1 setTransparent:NO];
8334     }U = UTop;
8335
8336     U = UTop;
8337     while (!(DUN[1] == U->number)) {
8338         U = U->next;
8339     }
8340     if(U->CPU){
8341         [battleAttackBtn2 setEnabled:NO];
8342         [battleAttackBtn2 setTransparent:YES];
8343         [battleGuardBtn2 setEnabled:NO];
8344         [battleGuardBtn2 setTransparent:YES];
8345         [battleDodgeBtn2 setEnabled:NO];
8346         [battleDodgeBtn2 setTransparent:YES];
8347     }else{
8348         [battleAttackBtn2 setEnabled:YES];
8349         [battleAttackBtn2 setTransparent:NO];
8350         [battleGuardBtn2 setEnabled:YES];
8351         [battleGuardBtn2 setTransparent:NO];
8352         [battleDodgeBtn2 setEnabled:YES];
8353         [battleDodgeBtn2 setTransparent:NO];
8354     }U = UTop;
8355
8356
8357     U = UTop;
8358
8359     for (int i = 1; i < DUN[1]; i++) {
8360         U = U->next;
8361     }
8362
8363     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8364        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8365        ){
8366         /*
8367         [battleStartBtn setEnabled:NO];
8368         [battleStartBtn setTransparent:YES];
8369          */
8370     }else{
8371         [battleStartBtn setEnabled:YES];
8372         [battleStartBtn setTransparent:NO];
8373     }
8374
8375     U = UTop;
8376
8377     avPlayerFlag1 = false;
8378     avPlayerFlag2 = false;
8379 }
8380
8381 -(void)setBattlePanelT4{
8382
8383     U = UTop;
8384
8385     while (!(AUN[1] == U->number)) {
8386         U = U->next;
8387     }
8388
8389     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2)){
8390         cpuModeBATTLEflag = false;
8391     int mostDmg = 0;
8392     int mostHit = 0;
8393     int mostNum = 0;
8394     int num = 0;
8395     ATTACK *aTop2 = U->CL.A;
8396     int mpCost = 0;
8397     while(U->CL.A){
8398         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8399         costVIG = U->C.A->vigor;
8400         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]){
8401             mostDmg = U->CL.A->totalD;
8402             mostNum = num;
8403         }
8404         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]){
8405             //mostDmg = U->C.A->totalD;
8406             mostHit = U->CL.A->hitPercent;
8407             mostNum = num;
8408         }
8409         U->CL.A = U->CL.A->next;
8410         num++;
8411     }
8412
8413
8414     mostNumSub = mostNum;
8415         U->CL.A = aTop2;
8416
8417         for(int i = 0;i < mostNum;i++){
8418             U->CL.A = U->CL.A->next;
8419         }
8420         if(U->CL.A->extent == 0){
8421
8422             U->CL.A = aTop2;
8423             crCAL1 = 0;
8424             for(int i = 0;i < mostNum;i++){
8425                 U->CL.A = U->CL.A->next;
8426                 crCAL1++;
8427             }
8428         }
8429         else{
8430             U->CL.A = aTop2;
8431             for(int i = 0;i < crCAL1;i++){
8432                 U->CL.A = U->CL.A->next;
8433             }
8434         }
8435     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8436         costVIG = U->C.A->vigor;
8437     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){
8438
8439     }else while(U->CL.A){
8440         U->CL.A = U->CL.A->next;
8441         crCAL1++;
8442     }
8443       U->CL.A = aTop2;
8444     }
8445     U = UTop;
8446
8447     while (!(AUN[1] == U->number)) {
8448         U = U->next;
8449     }
8450     U2 = U;
8451
8452     ATTACK *aTop = U->C.A;
8453     ATTACK *u2A;
8454
8455     if(U->C.A)
8456         crCAL1 = crCAL;
8457
8458     for(int i = 0;i < crCAL1;i++){
8459         U->C.A = U->C.A->next;
8460     }
8461
8462     if(battleSet1Flag){
8463
8464         U->C.A = aTop;
8465         for (int i = 0;i < crCAL1;i++) {
8466             U->C.A = U->C.A->next;
8467         }
8468
8469     }
8470
8471     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8472     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8473     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8474     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8475     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8476     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8477     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
8478     [combatLHP1 setIntValue:(int)oops];
8479     oops = U->C.S_C.MP/U->C.S_M.MP*100;
8480     [combatLMP1 setIntValue:(int)oops];
8481
8482     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8483     hitFix = U->C.A->hitPercent;
8484
8485     u2A = U->C.A;
8486     U->C.A = aTop;
8487
8488     if(battleDef1Flag){
8489         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8490         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8491         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8492         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8493         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8494         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8495         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8496     }
8497     if(battleDod1Flag){
8498         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8499         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8500         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8501         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8502         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8503         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8504         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8505
8506     }
8507
8508
8509
8510
8511
8512
8513
8514     U = UTop;
8515     while (!(DUN[1] == U->number)) {
8516         U = U->next;
8517     }
8518
8519     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;
8520     if(battleDod2Flag) hit = hit / 2;
8521     hit = floor(hit);
8522
8523     if(hit > 100) hit = 100;
8524     if(hit < 0) hit = 0;
8525
8526     if(u2A->D->sort == 1){
8527         hit = 100;
8528     }
8529     if([self sortEcheck:u2A opponent:U])
8530         hit = 0;
8531     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8532     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8533
8534
8535
8536     int mostDmg = 0;
8537     int mostHit = 0;
8538     int mostNum = 0;
8539     int num = 0;
8540     ATTACK *aTop2 = U->CL.A;
8541     int mpCost = 0;
8542     while(U->CL.A){
8543         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8544         costVIG = U->C.A->vigor;
8545         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]){
8546             mostDmg = U->CL.A->totalD;
8547             mostNum = num;
8548         }
8549         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]){
8550             //mostDmg = U->C.A->totalD;
8551             mostHit = U->CL.A->hitPercent;
8552             mostNum = num;
8553         }
8554         U->CL.A = U->CL.A->next;
8555         num++;
8556     }
8557
8558     mostNumSub = mostNum;
8559
8560     U->CL.A = aTop2;
8561
8562     for(int i = 0;i < mostNum;i++){
8563         U->CL.A = U->CL.A->next;
8564     }
8565     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8566     costVIG = U->C.A->vigor;
8567     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){
8568
8569     }else while(U->CL.A){
8570         U->CL.A = U->CL.A->next;
8571     }
8572
8573
8574     if(battleSet2Flag){
8575
8576         U->CL.A = aTop2;
8577
8578         for (int i = 0;i < crCAL2;i++) {
8579             U->CL.A = U->CL.A->next;
8580         }
8581
8582     }
8583
8584
8585     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8586     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8587     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8588     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8589     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8590     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
8591     [combatLHP2 setIntValue:(int)oops2];
8592     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
8593     [combatLMP2 setIntValue:(int)oops2];
8594
8595     bool counter;
8596     int mpCost2 = 0;
8597     if(U->CL.A){
8598         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8599
8600     }
8601     if(U->CL.A && U->CL.A->D){
8602     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]){
8603         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8604         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8605         hitFix = U->CL.A->hitPercent;
8606         counter = true;
8607     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
8608         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8609     }}else{
8610         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8611     }
8612     U2A = U->CL.A;
8613     U->CL.A = aTop2;
8614
8615     if(battleDef2Flag){
8616         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8617         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8618         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8619         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8620         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8621         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8622         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8623     }
8624
8625     if(battleDod2Flag){
8626         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8627         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8628         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8629         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8630         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8631         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8632         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8633
8634     }
8635
8636     U = UTop;
8637     while (!(DUN[1] == U->number)) {
8638         U = U->next;
8639     }
8640     U2 = U;
8641
8642     U = UTop;
8643     while (!(AUN[1] == U->number)) {
8644         U = U->next;
8645     }
8646
8647     if(counter){
8648
8649         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8650
8651         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8652         if(hi < 0) hi = 0;
8653
8654         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8655         if(battleDod1Flag) hit /= 2;
8656         hit = floor(hit);
8657
8658         if(hit > 100) hit = 100;
8659         if(hit < 0) hit = 0;
8660         if([self sortEcheck:U2A opponent:U])
8661             hit = 0;
8662         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8663         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8664
8665     }else{
8666         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8667     }
8668
8669     U = UTop;
8670     while (!(AUN[1] == U->number)) {
8671         U = U->next;
8672     }
8673
8674     if(U->CPU){
8675         [battleAttackBtn1 setEnabled:NO];
8676         [battleAttackBtn1 setTransparent:YES];
8677         [battleGuardBtn1 setEnabled:NO];
8678         [battleGuardBtn1 setTransparent:YES];
8679         [battleDodgeBtn1 setEnabled:NO];
8680         [battleDodgeBtn1 setTransparent:YES];
8681     }else{
8682         [battleAttackBtn1 setEnabled:YES];
8683         [battleAttackBtn1 setTransparent:NO];
8684         [battleGuardBtn1 setEnabled:YES];
8685         [battleGuardBtn1 setTransparent:NO];
8686         [battleDodgeBtn1 setEnabled:YES];
8687         [battleDodgeBtn1 setTransparent:NO];
8688     }U = UTop;
8689
8690     U = UTop;
8691     while (!(DUN[1] == U->number)) {
8692         U = U->next;
8693     }
8694     if(U->CPU){
8695         [battleAttackBtn2 setEnabled:NO];
8696         [battleAttackBtn2 setTransparent:YES];
8697         [battleGuardBtn2 setEnabled:NO];
8698         [battleGuardBtn2 setTransparent:YES];
8699         [battleDodgeBtn2 setEnabled:NO];
8700         [battleDodgeBtn2 setTransparent:YES];
8701     }else{
8702         [battleAttackBtn2 setEnabled:YES];
8703         [battleAttackBtn2 setTransparent:NO];
8704         [battleGuardBtn2 setEnabled:YES];
8705         [battleGuardBtn2 setTransparent:NO];
8706         [battleDodgeBtn2 setEnabled:YES];
8707         [battleDodgeBtn2 setTransparent:NO];
8708     }U = UTop;
8709
8710
8711     U = UTop;
8712
8713     for (int i = 1; i < DUN[1]; i++) {
8714         U = U->next;
8715     }
8716
8717     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8718        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8719        ){
8720         /*
8721         [battleStartBtn setEnabled:NO];
8722         [battleStartBtn setTransparent:YES];
8723          */
8724     }else{
8725         [battleStartBtn setEnabled:YES];
8726         [battleStartBtn setTransparent:NO];
8727     }
8728
8729     U = UTop;
8730
8731     avPlayerFlag1 = false;
8732     avPlayerFlag2 = false;
8733 }
8734
8735 -(void)DisplayMessage{
8736
8737     battleFlag = true;
8738     attackExtentFlag = false;
8739     attackingWait = false;
8740
8741     if(!battleSetUp) return;
8742     if(!fuckingLoadBugFix) return;
8743
8744     if(!battleVeryBegunFlag){
8745     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8746     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8747     [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8748     [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8749     }
8750     battleVeryBegunFlag = true;
8751     pussyLoopFlag = true;
8752     if(AVpreview){
8753     if(AVpreview.rate > 0){
8754         //[battleWindow setIgnoresMouseEvents:YES];
8755         [battleWindow makeKeyAndOrderFront:nil];
8756         //NSLog(@"%g", AVpreview.rate);
8757         return;
8758     }else{
8759         //[battleWindow setIgnoresMouseEvents:NO];
8760         //NSLog(@"%g", AVpreview.rate);
8761         AVpreview = NULL;
8762         if(avPlayerFlag1){
8763
8764             [AVPV setHidden:YES];
8765         }
8766         else if(avPlayerFlag2){
8767             [AVPV setHidden:YES];
8768         }
8769     }
8770     }
8771     if(animationFlag3){
8772         if(animationFlag1){
8773             animationFlag1 = false;
8774             U = effCun;
8775             U->C.A = attackTop;
8776         }
8777         if(animationFlag2){
8778             animationFlag2 = false;
8779             U = effCun;
8780             U->C.A = attackTop2;
8781         }
8782         U = UTop;
8783     }else{
8784         if(animationFlag1 || animationFlag2){
8785             return;
8786         }
8787     }
8788
8789     double def2 = (double)31/32;
8790     NSString *message = @"";
8791
8792     enum{
8793         RIKU,
8794         UMI,
8795         CHU,
8796         SORA
8797     };
8798
8799     enum{
8800         A,
8801         B,
8802         C,
8803         D,
8804         E,
8805         S,
8806         SS
8807     };
8808     static bool extentbool = false;
8809     static bool extentbool2 = false;
8810
8811
8812     if(cpuAtkExtendFlag){
8813         extentBattleFlag2 = true;
8814     }
8815
8816     if(!extentbool && extentBattleFlag2){
8817         extentbool = true;
8818         extentMPcostFlag = false;
8819         DUNnum = 1;
8820     }
8821
8822     assholeLoadBugFix = true;
8823
8824     switch (messageProcess) {
8825         case 0:
8826             if(bLoopFlag) break;
8827
8828             DUNnum = 1;
8829
8830             U = UTop;
8831             while (!(DUN[DUNnum] == U->number)) {
8832                 U = U->next;
8833
8834             }
8835             U2 = U;
8836             U = UTop;
8837             while (!(AUN[1] == U->number)) {
8838                 U = U->next;
8839             }
8840
8841             if(U->number == U2->number){
8842                 btSelfAction = true;
8843             }else{
8844                 btSelfAction = false;
8845             }
8846
8847             U = UTop;
8848             U2 = UTop;
8849
8850             [battleDialog setStringValue:@"攻撃開始！"];
8851             if(!baseDistanceCompFlag)
8852                 break;
8853             bLoopFlag = true;
8854             messageProcess++;
8855             DUNnum = 1;
8856             battleIsProcFlag = true;
8857
8858             break;
8859         case 1:
8860
8861             if(bLoopFlag) break;
8862
8863
8864             if(DUNnum > 1){
8865
8866
8867                 btHitExtendFlag1 = true;
8868
8869                 if(btHitExtendProc1 >= 3){
8870                     btHitExtendProc1 = 0;
8871                 }
8872             }
8873
8874                 BTunitAttackFlag1 = true;
8875             if(battleDef1Flag || battleDod1Flag)
8876                 BTunitAttackFlag1 = false;
8877
8878             U = UTop;
8879             while (!(DUN[DUNnum] == U->number)) {
8880                 U = U->next;
8881
8882             }
8883             U2 = U;
8884             U = UTop;
8885             while (!(AUN[1] == U->number)) {
8886                 U = U->next;
8887             }
8888
8889
8890             if(U->number == U2->number){
8891                 btSelfAction = true;
8892             }else{
8893                 btSelfAction = false;
8894             }
8895
8896             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
8897                 U = UTop;
8898                 [self DisplayMessageMod1A];
8899                 return;
8900             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
8901                 U = UTop;
8902                 [self DisplayMessageMod2A];
8903                 return;
8904             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
8905                 U = UTop;
8906                 [self DisplayMessageMod3A];
8907                 return;
8908             }
8909
8910
8911             U = UTop;
8912             if(bLoopFlag) break;
8913
8914             U = UTop;
8915             while (!(AUN[1] == U->number)) {
8916                 U = U->next;
8917             }
8918             ATTACK *aTop = U->C.A;
8919             attackTop = aTop;
8920             for(int i = 0;i < crCAL1;i++){
8921                 U->C.A = U->C.A->next;
8922             }
8923             effCun = U;
8924             attackCR = U->C.A;
8925
8926             if(attackCR->magic){
8927                 btAttackType1 = BT_TYPE_MAGIC;
8928             }else{
8929                 btAttackType1 = BT_TYPE_NORMAL;
8930             }
8931
8932             if(BTunitAttackFlag1)
8933             if((btAttackType1 == BT_TYPE_NORMAL && btAttackMoveValue1 < 2)
8934                || (btAttackType1 == BT_TYPE_MAGIC && btAttackMoveValue1 < 5)
8935                || (btAttackType1 == BT_TYPE_ABILITY && btAttackMoveValue1 < 2)){
8936
8937                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
8938
8939                 [battleDialog setStringValue:message];
8940                 U->C.A = aTop;
8941                 U = UTop;
8942
8943                 return;
8944             }
8945
8946             if(btHitExtendFlag1 && btHitExtendProc1 < 2){
8947
8948
8949
8950
8951                 U->C.A = aTop;
8952                 U = UTop;
8953
8954                 return;
8955             }
8956
8957             if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
8958
8959
8960             [bplayer2 setImage:U2->C.imgb];
8961             [bplayer2 setImageScaling:NSScaleToFit];
8962             [nplayer2 setStringValue:U2->C.name];
8963             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->C.S_C.HP, U2->C.S_M.HP]];
8964             [lplayer2 setIntValue:U2->C.S_C.HP/U2->C.S_M.HP*100];
8965             [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
8966             [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
8967             [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
8968
8969             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){
8970                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
8971
8972                 NSString *path = @"data/AttackList/ALdata";
8973
8974                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
8975
8976                 path = [path stringByAppendingFormat:@"/"];
8977
8978                 path = [path stringByAppendingString:U->C.A->AN.movName];
8979
8980                 NSData *AVData = [NSData dataWithContentsOfFile:path];
8981
8982                 if(AVData)
8983                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
8984
8985
8986                 if(!AVpreview){
8987
8988                     NSString *path = @"data/AttackList3/IALdata";
8989
8990                     path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
8991
8992                     path = [path stringByAppendingFormat:@"/"];
8993
8994                     path = [path stringByAppendingString:U->C.A->AN.movName];
8995
8996
8997                     NSData *AVData = [NSData dataWithContentsOfFile:path];
8998
8999                     if(AVData)
9000                     AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9001
9002
9003                 }
9004
9005                 if(AVpreview) {
9006                     AVPV.player = [AVpreview retain];
9007                 }else{
9008                     goto avAWESOME;
9009                 }
9010
9011
9012                 [AVPV setHidden:NO];
9013                 [AVpreview play];
9014                 [battleDialog setStringValue:message];
9015
9016                 avPlayerFlag1 = true;
9017
9018
9019                 U->C.A = aTop;
9020                 U = UTop;
9021                 return;
9022             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUNnum == 1){
9023
9024                 [battleDialog setStringValue:message];
9025                 animationFlag1 = true;
9026                 aniFrameCnt = 0;
9027                 return;
9028             }
9029
9030         avAWESOME:{}
9031
9032             double urSupposedToGet;
9033
9034             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9035
9036             double asItIs;
9037             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9038
9039             double oopsIsRight;
9040
9041             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9042             else oopsIsRight = U->C.S_C.MIS;
9043
9044             oopsIsRight = oopsIsRight/100;
9045             double val;
9046             if(!U2->C.aura && U->C.A->D){
9047             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
9048                                             - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9049             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
9050                                             - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9051             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
9052                                             - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9053             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
9054                                             - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9055             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
9056                                             - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9057             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9058             }else if(U->C.A->D){
9059                 val = 1/log(3+U2->C.S_C.MP/64);
9060                 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
9061                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9062                 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
9063                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9064                 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
9065                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9066                 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
9067                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9068                 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
9069                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9070                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9071             }
9072             double val2 = log(3+U2->C.S_C.MP/64);
9073             if(U->C.aura){
9074                 dmg = dmg*val2;
9075             }
9076
9077             if(U->C.A->D){
9078             if(U->C.A->D->fix == 2){
9079                 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;
9080
9081                 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;
9082                 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;
9083                 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;
9084                 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;
9085                 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;
9086
9087
9088             }else if(U->C.A->D->fix == 1){
9089                 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;
9090
9091                 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;
9092                 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;
9093                 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;
9094                 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;
9095                 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;
9096
9097             }else if(U->C.A->D->fix == 0){
9098
9099             }
9100             }
9101             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9102
9103             if(extentMPcostFlag && extentBattleFlag2){
9104
9105             }else{
9106                 U->C.S_C.MP -= costMP;
9107                 extentMPcostFlag = true;
9108             }
9109
9110             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9111             hitFix = U->C.A->hitPercent;
9112
9113             U2A = U->C.A;
9114             U->C.A = aTop;
9115
9116             U = UTop;
9117             while (!(AUN[1] == U->number)) {
9118                 U = U->next;
9119             }
9120             U2 = U;
9121
9122             U = UTop;
9123             while (!(DUN[DUNnum] == U->number)) {
9124                 U = U->next;
9125             }
9126
9127             double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9128
9129             double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9130             if(hi < 0) hi = 0;
9131
9132             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9133             if(hit > 100) hit = 100;
9134             if(hit < 0) hit = 0;
9135             if(U2A->D->sort == 1){
9136                 hit = 100;
9137             }
9138             if([self sortEcheck:U2A opponent:U])
9139                 hit = 0;
9140
9141             healFlag = false;
9142
9143             int wtf = 100;
9144             if(battleDod2Flag) wtf = 50;
9145             if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
9146
9147                 if(U2A->D->sort == 0){
9148                     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);
9149                     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);
9150                     NSLog(@"修正前のダメージ:%g", dmg);
9151                     dmg = [self dmgResist:dmg];
9152                     NSLog(@"属性後のダメージ:%g", dmg);
9153                     def2 = pow(def2, U->C.S_C.DEF);
9154                     int omfg = rand()%100;
9155                     NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9156                     dmg = (dmg*omfg/100/10 + dmg);
9157                     NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9158                     if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9159                     else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9160
9161                     if(U->C.S_C.typeMOVE == RIKU){
9162                         if(U2A->riku == A) dmg = dmg*1.2;
9163                         if(U2A->riku == B) dmg = dmg*1.0;
9164                         if(U2A->riku == C) dmg = dmg*0.6;
9165                         if(U2A->riku == D) dmg = dmg*0.2;
9166                         if(U2A->riku == E) dmg = 0;
9167                         if(U2A->riku == S) dmg = dmg*1.5;
9168                         if(U2A->riku == SS) dmg = dmg*2.0;
9169                     } if(U->C.S_C.typeMOVE == UMI &&
9170                        (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9171                         if(U2A->umi == A) dmg = dmg*1.2;
9172                         if(U2A->umi == B) dmg = dmg*1.0;
9173                         if(U2A->umi == C) dmg = dmg*0.6;
9174                         if(U2A->umi == D) dmg = dmg*0.2;
9175                         if(U2A->umi == E) dmg = 0;
9176                         if(U2A->umi == S) dmg = dmg*1.5;
9177                         if(U2A->umi == SS) dmg = dmg*2.0;
9178                     }else if(U->C.S_C.typeMOVE == UMI){
9179                         if(U2A->riku == A) dmg = dmg*1.2;
9180                         if(U2A->riku == B) dmg = dmg*1.0;
9181                         if(U2A->riku == C) dmg = dmg*0.6;
9182                         if(U2A->riku == D) dmg = dmg*0.2;
9183                         if(U2A->riku == E) dmg = 0;
9184                         if(U2A->riku == S) dmg = dmg*1.5;
9185                         if(U2A->riku == SS) dmg = dmg*2.0;
9186
9187                     } if(U->C.S_C.typeMOVE == CHU){
9188                         if(U2A->chu == A) dmg = dmg*1.2;
9189                         if(U2A->chu == B) dmg = dmg*1.0;
9190                         if(U2A->chu == C) dmg = dmg*0.6;
9191                         if(U2A->chu == D) dmg = dmg*0.2;
9192                         if(U2A->chu == E) dmg = 0;
9193                         if(U2A->chu == S) dmg = dmg*1.5;
9194                         if(U2A->chu == SS) dmg = dmg*2.0;
9195                     } if(U->C.S_C.typeMOVE == SORA){
9196                         if(U2A->sora == A) dmg = dmg*1.2;
9197                         if(U2A->sora == B) dmg = dmg*1.0;
9198                         if(U2A->sora == C) dmg = dmg*0.6;
9199                         if(U2A->sora == D) dmg = dmg*0.2;
9200                         if(U2A->sora == E) dmg = 0;
9201                         if(U2A->sora == S) dmg = dmg*1.5;
9202                         if(U2A->sora == SS) dmg = dmg*2.0;
9203                     }
9204
9205                     NSLog(@"ユニットの地形適用後:%g", dmg);
9206                     if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
9207                     graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9208
9209                     grazeFlag = false;
9210                     omfg = rand()%100;
9211                     if(graze > omfg && !healFlag) {dmg = dmg/5;
9212                         grazeFlag = true;
9213                     }
9214                     if(battleDef2Flag) dmg -= dmg*0.5;
9215                     battleDef2Flag = false;
9216                     dmg = floor(dmg);
9217                     if(dmg < 0) dmg = 0;
9218                     U->C.S_C.HP -= dmg;
9219                     U->C.S_C.vigor++;
9220
9221                     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9222                     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9223
9224
9225
9226                 }else if(U2A->D->sort == 1){
9227                     dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
9228                     dmg = floor(dmg);
9229
9230                     U->C.S_C.HP += dmg;
9231                     if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
9232                     healFlag = true;
9233                 }
9234
9235                 while(1){
9236                     if(U->C.S_C.HP <= 0) {
9237                         U->C.S_C.HP = 0;
9238                         U2->C.S_C.vigor += 5;
9239
9240                         messageProcess = 2;
9241                         if(U->dead) break;
9242                         U->dead = true;
9243
9244
9245                         if(U->targType1L)
9246                             targType1cnt[0]--;
9247                         if(U->targType2L) {
9248                             targType2cnt[0]--;
9249                             targType2Lflag = true;
9250                         }
9251
9252                         if(U->targType1D)
9253                             targType1cnt[1]--;
9254                         if(U->targType2D) {
9255                             targType2cnt[1]--;
9256                             targType2Dflag = true;
9257                         }
9258
9259                         break;
9260                     }
9261                     break;
9262                 }
9263
9264             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9265             [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9266
9267                 if(![U2A->msg isEqualToString:@""]){
9268
9269                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9270                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9271
9272                 }
9273
9274             if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9275             if(!healFlag) {
9276                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9277                 btHitFlag1 = true;
9278                 }
9279             else {
9280                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
9281                 btHitFlag1 = false;
9282             }
9283             }else if(battleDef1Flag){
9284
9285
9286                 U = UTop;
9287                 while (!(AUN[1] == U->number)) {
9288                     U = U->next;
9289                 }
9290
9291
9292                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9293
9294                 btHitFlag1 = false;
9295
9296             }else if(battleDod1Flag){
9297
9298                 U = UTop;
9299                 while (!(AUN[1] == U->number)) {
9300                     U = U->next;
9301                 }
9302
9303                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9304
9305                 btHitFlag1 = false;
9306             }else{
9307
9308                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9309                 btHitFlag1 = false;
9310
9311             }
9312                 [battleDialog setStringValue:message];
9313
9314             [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9315
9316             U = UTop;
9317
9318             bLoopFlag = true;
9319
9320             if(!extentBattleFlag2){
9321             if(healFlag) {
9322                 messageProcess++;
9323                  };
9324             messageProcess++;
9325             }else if(extentBattleFlag2){
9326                 if(btHitExtendProc1 == 2)
9327                     btHitExtendProc1 = 3;
9328                 if(btHitExtendProc1 >= 2)
9329                     btHitExtendFix1 = 1;
9330
9331                 btHitFlagCnt1 = 0;
9332                 DUNnum++;
9333                 messageProcess = 1;
9334                 if(DUN[DUNnum] <= 0){
9335                     messageProcess++;
9336                     messageProcess++;
9337                     extentBattleFlag2 = false;
9338                     extentbool = false;
9339                     extentMPcostFlag = false;
9340                 }
9341             }
9342             message = @"";
9343             avPlayerFlag1 = false;
9344             animationFlag3 = false;
9345             btAtattckMoveEnd = false;
9346             oopsCnt = 30;
9347             break;
9348
9349         case 2:
9350
9351             if(bLoopFlag) break;
9352             BTunitAttackFlag1 = false;
9353             BTunitAttackFlag2 = true;
9354             if(battleDef2Flag || battleDod2Flag)
9355                 BTunitAttackFlag2 = false;
9356             btHitFlag1 = false;
9357
9358
9359             U = UTop;
9360             while (!(DUN[1] == U->number)) {
9361                 U = U->next;
9362             }
9363             U2 = U;
9364             U = UTop;
9365             while (!(AUN[1] == U->number)) {
9366                 U = U->next;
9367             }
9368
9369
9370             if(U->number == U2->number){
9371                 btSelfAction = true;
9372             }else{
9373                 btSelfAction = false;
9374             }
9375
9376             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
9377                 U = UTop;
9378                 [self DisplayMessageMod1B];
9379                 return;
9380             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
9381                 U = UTop;
9382                 [self DisplayMessageMod2B];
9383                 return;
9384             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
9385                 U = UTop;
9386                 [self DisplayMessageMod3B];
9387                 return;
9388             }
9389             U = UTop;
9390
9391             if(bLoopFlag) break;
9392
9393             U = UTop;
9394             while (!(AUN[1] == U->number)) {
9395                 U = U->next;
9396             }
9397             U2 = U;
9398             U = UTop;
9399
9400             U = UTop;
9401             while (!(DUN[1] == U->number)) {
9402                 U = U->next;
9403             }
9404
9405             ATTACK *aTop2 = U->C.A;
9406             attackTop2 = aTop2;
9407             int mostDmg = 0;
9408             int mostDmg2 = 0;
9409             int mostNum = 0;
9410             int num = 0;
9411             int mpCost =0;
9412
9413             if(!U->C.A) goto SKIP3;
9414
9415
9416
9417             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9418
9419             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9420
9421
9422             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9423             else oopsIsRight = U->C.S_C.MIS;
9424
9425             oopsIsRight = oopsIsRight/100;
9426
9427             if(U->C.A) {
9428                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9429             }
9430             while(U->C.A){
9431                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9432                 if(!U2->C.aura && U->C.A->D){
9433                     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
9434                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9435                     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
9436                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9437                     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
9438                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9439                     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
9440                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9441                     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
9442                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9443                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
9444                 }else if(U->C.A->D){
9445                     val = 1/log(3+U2->C.S_C.MP/64);
9446                     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
9447                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9448                     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
9449                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9450                     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
9451                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9452                     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
9453                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor)*asItIs*val;
9454                     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
9455                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9456                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
9457                 }
9458                 double val2 = log(3+U2->C.S_C.MP/64);
9459                 if(U->C.aura){
9460                     mostDmg2 = mostDmg2*val2;
9461                 }
9462                 if(U->C.A->D){
9463                     if(U->C.A->D->fix == 2){
9464                         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;
9465
9466                         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;
9467                         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;
9468                         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;
9469                         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;
9470                         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;
9471
9472
9473                     }else if(U->C.A->D->fix == 1){
9474                         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;
9475
9476                         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;
9477                         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;
9478                         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;
9479                         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;
9480                         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;
9481
9482                     }else if(U->C.A->D->fix == 0){
9483
9484                     }
9485                 }
9486
9487                 U2A = U->C.A;
9488                 UNIT *oops = U;
9489                 U = U2;
9490                 mostDmg2 = [self dmgResist:mostDmg2];
9491                 U = oops;
9492
9493                 costVIG = U->C.A->vigor;
9494                 if(U->C.A->D)
9495                 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]){
9496
9497
9498                     mostDmg = mostDmg2;
9499
9500
9501                     //mostDmg = U->C.A->totalD;
9502                     mostNum = num;
9503                 }
9504                 U->C.A = U->C.A->next;
9505                 num++;
9506             }
9507
9508             U->C.A = aTop2;
9509
9510             if(!battleSet2PushedFlag){
9511                 for(int i = 0;i < mostNumSub;i++){
9512                 U->C.A = U->C.A->next;
9513             }
9514
9515             }else{
9516             for(int i = 0;i < crCAL2;i++){
9517                 U->C.A = U->C.A->next;
9518             }
9519
9520
9521             }
9522             if(U->C.A->D){
9523             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]){
9524
9525             }else while(U->C.A){
9526                 U->C.A = U->C.A->next;
9527             }}
9528
9529             if(!U->C.A){
9530                 U->C.A = aTop2;
9531                 U = UTop;
9532                 BTunitAttackFlag2 = false;
9533                 message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
9534                 goto SKIP1;
9535             }
9536             effCun = U;
9537             attackCR2 = U->C.A;
9538
9539             if(attackCR2->magic){
9540                 btAttackType2 = BT_TYPE_MAGIC;
9541             }else{
9542                 btAttackType2 = BT_TYPE_NORMAL;
9543             }
9544
9545             if(BTunitAttackFlag2)
9546                 if((btAttackType2 == BT_TYPE_NORMAL && btAttackMoveValue2 < 2)
9547                    || (btAttackType2 == BT_TYPE_MAGIC && btAttackMoveValue2 < 5)
9548                    || (btAttackType2 == BT_TYPE_ABILITY && btAttackMoveValue2 < 2)){
9549
9550
9551                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9552
9553                 [battleDialog setStringValue:message];
9554                 U->C.A = aTop2;
9555                 U = UTop;
9556
9557                 return;
9558             }
9559
9560             if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9561
9562             if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
9563                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
9564
9565                 NSString *path = @"data/AttackList/ALdata";
9566
9567                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
9568
9569                 path = [path stringByAppendingFormat:@"/"];
9570
9571                 path = [path stringByAppendingString:U->C.A->AN.movName];
9572
9573
9574                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9575
9576                 if(AVpreview) {
9577                     AVPV.player = [AVpreview retain];
9578                 }else{
9579                     goto avAWESOME2;
9580                 }
9581
9582                 [AVPV setControlsStyle:0];
9583                 [AVPV setHidden:NO];
9584                 [AVpreview play];
9585                 [battleDialog setStringValue:message];
9586
9587                 avPlayerFlag2 = true;
9588
9589                 U->C.A = aTop2;
9590                 U = UTop;
9591                 return;
9592             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
9593
9594
9595                 animationFlag2 = true;
9596                 aniFrameCnt = 0;
9597                 return;
9598             }
9599
9600
9601         avAWESOME2:{}
9602             U2A = U->C.A;
9603
9604             /*
9605             if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
9606             if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
9607             if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
9608             if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
9609             if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
9610             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9611             */
9612
9613             U->C.A = aTop2;
9614             U = UTop;
9615             while (!(AUN[1] == U->number)) {
9616                 U = U->next;
9617             }
9618             U2 = U;
9619             U = UTop;
9620             while (!(DUN[1] == U->number)) {
9621                 U = U->next;
9622             }
9623             NSString *string = [U2A->name retain];
9624             while (![U->C.A->name isEqualToString:string] && U->C.A) {
9625                 U->C.A = U->C.A->next;
9626             }
9627
9628             if(!U->C.A) U->C.A = aTop2;
9629
9630             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9631
9632             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9633
9634
9635             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9636             else oopsIsRight = U->C.S_C.MIS;
9637
9638             oopsIsRight = oopsIsRight/100;
9639
9640
9641             if(!U2->C.aura && U->C.A->D){
9642                 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
9643                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9644                 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
9645                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9646                 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
9647                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9648                 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
9649                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9650                 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
9651                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9652                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9653             }else if(U->C.A->D){
9654                 double val = val = 1/log(3+U2->C.S_C.MP/64);
9655                 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
9656                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9657                 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
9658                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9659                 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
9660                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9661                 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
9662                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9663                 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
9664                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9665                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9666             }
9667             val2 = log(3+U2->C.S_C.MP/64);
9668             if(U->C.aura){
9669                 dmg = dmg*val2;
9670             }
9671             if(U->C.A->D){
9672                 if(U->C.A->D->fix == 2){
9673                     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;
9674
9675                     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;
9676                     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;
9677                     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;
9678                     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;
9679                     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;
9680
9681
9682                 }else if(U->C.A->D->fix == 1){
9683                     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;
9684
9685                     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;
9686                     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;
9687                     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;
9688                     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;
9689                     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;
9690
9691                 }else if(U->C.A->D->fix == 0){
9692
9693                 }
9694             }
9695             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9696             U->C.S_C.MP -= costMP;
9697
9698             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9699             hitFix = U->C.A->hitPercent;
9700
9701             U2A = U->C.A;
9702
9703             U->C.A = aTop2;
9704
9705             U = UTop;
9706             while (!(DUN[1] == U->number)) {
9707                 U = U->next;
9708             }
9709             U2 = U;
9710
9711             U = UTop;
9712             while (!(AUN[1] == U->number)) {
9713                 U = U->next;
9714             }
9715
9716             hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9717
9718             hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9719             if(hi < 0) hi = 0;
9720
9721             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9722             if(hit > 100) hit = 100;
9723             if(hit < 0) hit = 0;
9724             if([self sortEcheck:U2A opponent:U])
9725                 hit = 0;
9726
9727             battleDod1Flag = false;
9728
9729             U = UTop;
9730             while (!(DUN[1] == U->number)) {
9731                 U = U->next;
9732             }
9733             U2 = U;
9734
9735             U = UTop;
9736             while (!(AUN[1] == U->number)) {
9737                 U = U->next;
9738             }
9739
9740             int omg = 100;
9741             if(battleDod1Flag) omg = 50;
9742
9743             if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
9744                 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);
9745                 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);
9746                 NSLog(@"修正前のダメージ:%g", dmg);
9747                 dmg = [self dmgResist:dmg];
9748                 NSLog(@"属性後のダメージ:%g", dmg);
9749             def2 = pow(def2, U->C.S_C.DEF);
9750             int omfg = rand()%100;
9751                 NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9752                 dmg = (dmg*omfg/100/10 + dmg);
9753                 NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9754                 if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9755                 else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9756
9757                 if(U->C.S_C.typeMOVE == RIKU){
9758                     if(U2A->riku == A) dmg = dmg*1.2;
9759                     if(U2A->riku == B) dmg = dmg*1.0;
9760                     if(U2A->riku == C) dmg = dmg*0.6;
9761                     if(U2A->riku == D) dmg = dmg*0.2;
9762                     if(U2A->riku == E) dmg = 0;
9763                     if(U2A->riku == S) dmg = dmg*1.5;
9764                     if(U2A->riku == SS) dmg = dmg*2.0;
9765                 } if(U->C.S_C.typeMOVE == UMI &&
9766                      (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9767                     if(U2A->umi == A) dmg = dmg*1.2;
9768                     if(U2A->umi == B) dmg = dmg*1.0;
9769                     if(U2A->umi == C) dmg = dmg*0.6;
9770                     if(U2A->umi == D) dmg = dmg*0.2;
9771                     if(U2A->umi == E) dmg = 0;
9772                     if(U2A->umi == S) dmg = dmg*1.5;
9773                     if(U2A->umi == SS) dmg = dmg*2.0;
9774                 }else if(U->C.S_C.typeMOVE == UMI){
9775                     if(U2A->riku == A) dmg = dmg*1.2;
9776                     if(U2A->riku == B) dmg = dmg*1.0;
9777                     if(U2A->riku == C) dmg = dmg*0.6;
9778                     if(U2A->riku == D) dmg = dmg*0.2;
9779                     if(U2A->riku == E) dmg = 0;
9780                     if(U2A->riku == S) dmg = dmg*1.5;
9781                     if(U2A->riku == SS) dmg = dmg*2.0;
9782
9783                 } if(U->C.S_C.typeMOVE == CHU){
9784                     if(U2A->chu == A) dmg = dmg*1.2;
9785                     if(U2A->chu == B) dmg = dmg*1.0;
9786                     if(U2A->chu == C) dmg = dmg*0.6;
9787                     if(U2A->chu == D) dmg = dmg*0.2;
9788                     if(U2A->chu == E) dmg = 0;
9789                     if(U2A->chu == S) dmg = dmg*1.5;
9790                     if(U2A->chu == SS) dmg = dmg*2.0;
9791                 } if(U->C.S_C.typeMOVE == SORA){
9792                     if(U2A->sora == A) dmg = dmg*1.2;
9793                     if(U2A->sora == B) dmg = dmg*1.0;
9794                     if(U2A->sora == C) dmg = dmg*0.6;
9795                     if(U2A->sora == D) dmg = dmg*0.2;
9796                     if(U2A->sora == E) dmg = 0;
9797                     if(U2A->sora == S) dmg = dmg*1.5;
9798                     if(U2A->sora == SS) dmg = dmg*2.0;
9799                 }
9800
9801                 NSLog(@"ユニットの地形適用後:%g", dmg);
9802
9803
9804                 graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9805
9806                 grazeFlag = false;
9807                 omfg = rand()&100;
9808                 if(graze > omfg && !healFlag) {dmg = dmg/5;
9809                     grazeFlag = true;
9810                 }
9811
9812             if(battleDef1Flag) dmg -= dmg*0.5;
9813             battleDef1Flag = false;
9814                 dmg = floor(dmg);
9815                 if(dmg < 0) dmg = 0;
9816                 U->C.S_C.HP -= dmg;
9817                 U->C.S_C.vigor++;
9818
9819                 [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9820                 [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9821
9822                 while(1){
9823                 if(U->C.S_C.HP <= 0) {
9824                     U->C.S_C.HP = 0;
9825                     U2->C.S_C.vigor += 5;
9826
9827                     messageProcess = 2;
9828                     if(U->dead) break;
9829                     U->dead = true;
9830
9831
9832                     if(U->targType1L)
9833                         targType1cnt[0]--;
9834                     if(U->targType2L) {
9835                         targType2cnt[0]--;
9836                         targType2Lflag = true;
9837                     }
9838
9839                     if(U->targType1D)
9840                         targType1cnt[1]--;
9841                     if(U->targType2D) {
9842                         targType2cnt[1]--;
9843                         targType2Dflag = true;
9844                     }
9845
9846                     break;
9847                 }
9848                     break;
9849                 }
9850
9851
9852
9853                 [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9854
9855                 [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9856
9857                 if(![U2A->msg isEqualToString:@""]){
9858                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9859                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9860                 }
9861
9862
9863
9864                 if(grazeFlag)
9865                     message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9866
9867                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9868                 btHitFlag2 = true;
9869
9870             }else if(battleDef2Flag){
9871
9872
9873                 U = UTop;
9874                 while (!(DUN[1] == U->number)) {
9875                     U = U->next;
9876                 }
9877
9878
9879                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9880                 btHitFlag2 = false;
9881
9882             }else if(battleDod2Flag){
9883
9884                 U = UTop;
9885                 while (!(DUN[1] == U->number)) {
9886                     U = U->next;
9887                 }
9888
9889                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9890
9891                 btHitFlag2 = false;
9892             }else{
9893
9894                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9895                 btHitFlag2 = false;
9896             }
9897         SKIP1:
9898             [battleDialog setStringValue:message];
9899         SKIP3:
9900             U = UTop;
9901             [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9902             bLoopFlag = true;
9903             messageProcess++;
9904             message = @"";
9905             avPlayerFlag2 = false;
9906             animationFlag3 = false;
9907             btAtattckMoveEnd = false;
9908             oopsCnt = 30;
9909             break;
9910         case 3:
9911             //おまんこ
9912             if(bLoopFlag) break;
9913             if(cpuAImodeflag && !cpuTurnEndFlag) {
9914                 wtRdy = false;
9915             wtRdy2 = false;
9916             }
9917
9918             fuckingLoadBugFix = false;
9919
9920             battleSetUp = false;
9921             battleSetFlag = false;
9922             battleFlag = false;
9923             battleRdy = false;
9924             battleSet2PushedFlag = false;
9925             cpuModeBATTLEendFlag = true;
9926             crCAL1 = 0;
9927             crCAL2 = 0;
9928             [battleWindow close];
9929             pussyLoopFlag = false;
9930             cpuAtkExtendFlag3 = false;
9931             cpuOMFGmoveATKfixFlag = false;
9932             unitNoMoveFlag = false;
9933             UA = NULL;
9934             Utarget = NULL;
9935             CPUmostDmgChoice = false;
9936             //おまんちん
9937             cpuIsAttackingFlag = false;
9938             for(int g = 0;g < chipWidth;g++){
9939                 for(int k = 0;k < chipHeight;k++){
9940                     g_attackRangeExtent[g][k] = 0;
9941                 }
9942             }
9943
9944             btDistanceX1 = 0;
9945             btDistanceX2 = 0;
9946             BTunitAttackFlag1 = false;
9947             BTunitAttackFlag2 = false;
9948             BTunitAttackFlag1 = false;
9949             btAttackMoveValue1 = 0;
9950             btAttackMoveValue2 = 0;
9951             btHitFlag1 = false;
9952             btHitFlag2 = false;
9953             btHitFlagCnt1 = 0;
9954             btHitFlagCnt2 = 0;
9955             btHitExtendFlag1 = false;
9956             btHitExtendProc1 = 0;
9957             btHitExtendMove1 = 0;
9958             btHitExtendFlag2 = false;
9959             btHitExtendProc2 = 0;
9960             btHitExtendMove2 = 0;
9961             baseDistanceCompFlag = false;
9962             battleVeryBegunFlag = false;
9963             CPUAttackSubmitFlag = false;
9964             battleSetUp = false;
9965             displayBattleCheckPanelFlag = 0;
9966             battleEndFlag = true;
9967             assholeLoadBugFix = false;
9968
9969             battleIsProcFlag = false;
9970             break;
9971
9972         default:
9973             break;
9974     }
9975
9976
9977     UCselected = UC[-1];
9978
9979
9980 }
9981
9982 -(void)DisplayMessageMod1A{//両方モビール
9983
9984     double def2 = (double)31/32;
9985     NSString *message = @"";
9986
9987     enum{
9988         RIKU,
9989         UMI,
9990         CHU,
9991         SORA,
9992     };
9993
9994     enum{
9995         A,
9996         B,
9997         C,
9998         D,
9999         E,
10000         S,
10001         SS
10002     };
10003
10004
10005
10006     if(bLoopFlag) return;
10007     U = UTop;
10008     while (!(AUN[1] == U->number)) {
10009         U = U->next;
10010     }
10011     U2 = U;
10012     ATTACK *aTop = U->CL.A;
10013     for(int i = 0;i < crCAL1;i++){
10014         U->CL.A = U->CL.A->next;
10015     }
10016
10017
10018     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10019
10020     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10021         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10022
10023         NSString *path = @"data/AttackList/ALdata";
10024
10025         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10026
10027         path = [path stringByAppendingFormat:@"/"];
10028
10029         path = [path stringByAppendingString:U->CL.A->AN.movName];
10030
10031         NSData *AVData = [NSData dataWithContentsOfFile:path];
10032
10033         if(AVData)
10034             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10035
10036
10037         if(!AVpreview){
10038
10039             NSString *path = @"data/AttackList3/IALdata";
10040
10041             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10042
10043             path = [path stringByAppendingFormat:@"/"];
10044
10045             path = [path stringByAppendingString:U->CL.A->AN.movName];
10046
10047
10048             NSData *AVData = [NSData dataWithContentsOfFile:path];
10049
10050             if(AVData)
10051                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10052
10053
10054         }
10055
10056         if(AVpreview) {
10057             AVPV.player = [AVpreview retain];
10058         }else{
10059             goto avAWESOME1A;
10060         }
10061
10062
10063         [AVPV setHidden:NO];
10064         [AVpreview play];
10065         [battleDialog setStringValue:message];
10066
10067         avPlayerFlag1 = true;
10068
10069         U->CL.A = aTop;
10070
10071         U = UTop;
10072         return;
10073     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10074
10075         [battleDialog setStringValue:message];
10076         animationFlag1 = true;
10077         aniFrameCnt = 0;
10078         return;
10079     }
10080
10081 avAWESOME1A:{}
10082
10083     dmg = U->CL.A->totalD;
10084
10085     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10086     U->CL.S_C.EN -= costMP;
10087
10088     hit = U->CL.S_C.MOB+U->C.S_C.HIT;
10089     hitFix = U->CL.A->hitPercent;
10090
10091     U2A = U->CL.A;
10092     U->CL.A = aTop;
10093
10094     U = UTop;
10095     while (!(DUN[1] == U->number)) {
10096         U = U->next;
10097     }
10098     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;
10099     if(hit > 100) hit = 100;
10100     if(U2A->D->sort == 1){
10101         hit = 100;
10102     }
10103     if([self sortEcheck:U2A opponent:U])
10104         hit = 0;
10105
10106     healFlag = false;
10107
10108     int wtf = 100;
10109     if(battleDod2Flag) wtf = 50;
10110     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10111
10112         if(U2A->D->sort == 0){
10113             NSLog(@"修正前のダメージ:%g", dmg);
10114             dmg = [self dmgResist:dmg];
10115             NSLog(@"属性後のダメージ:%g", dmg);
10116             def2 = pow(def2, U->CL.S_C.ARM);
10117             int omfg = rand()%100;
10118             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10119
10120             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10121             dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10122             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10123             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10124             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10125
10126             if(U->CL.S_C.typeMOVE == RIKU){
10127                 if(U2A->riku == A) dmg = dmg*1.2;
10128                 if(U2A->riku == B) dmg = dmg*1.0;
10129                 if(U2A->riku == C) dmg = dmg*0.6;
10130                 if(U2A->riku == D) dmg = dmg*0.2;
10131                 if(U2A->riku == E) dmg = 0;
10132                 if(U2A->riku == S) dmg = dmg*1.5;
10133                 if(U2A->riku == SS) dmg = dmg*2.0;
10134             } if(U->CL.S_C.typeMOVE == UMI &&
10135                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10136                 if(U2A->umi == A) dmg = dmg*1.2;
10137                 if(U2A->umi == B) dmg = dmg*1.0;
10138                 if(U2A->umi == C) dmg = dmg*0.6;
10139                 if(U2A->umi == D) dmg = dmg*0.2;
10140                 if(U2A->umi == E) dmg = 0;
10141                 if(U2A->umi == S) dmg = dmg*1.5;
10142                 if(U2A->umi == SS) dmg = dmg*2.0;
10143             }else if(U->CL.S_C.typeMOVE == UMI){
10144                 if(U2A->riku == A) dmg = dmg*1.2;
10145                 if(U2A->riku == B) dmg = dmg*1.0;
10146                 if(U2A->riku == C) dmg = dmg*0.6;
10147                 if(U2A->riku == D) dmg = dmg*0.2;
10148                 if(U2A->riku == E) dmg = 0;
10149                 if(U2A->riku == S) dmg = dmg*1.5;
10150                 if(U2A->riku == SS) dmg = dmg*2.0;
10151
10152             } if(U->CL.S_C.typeMOVE == CHU){
10153                 if(U2A->chu == A) dmg = dmg*1.2;
10154                 if(U2A->chu == B) dmg = dmg*1.0;
10155                 if(U2A->chu == C) dmg = dmg*0.6;
10156                 if(U2A->chu == D) dmg = dmg*0.2;
10157                 if(U2A->chu == E) dmg = 0;
10158                 if(U2A->chu == S) dmg = dmg*1.5;
10159                 if(U2A->chu == SS) dmg = dmg*2.0;
10160             } if(U->CL.S_C.typeMOVE == SORA){
10161                 if(U2A->sora == A) dmg = dmg*1.2;
10162                 if(U2A->sora == B) dmg = dmg*1.0;
10163                 if(U2A->sora == C) dmg = dmg*0.6;
10164                 if(U2A->sora == D) dmg = dmg*0.2;
10165                 if(U2A->sora == E) dmg = 0;
10166                 if(U2A->sora == S) dmg = dmg*1.5;
10167                 if(U2A->sora == SS) dmg = dmg*2.0;
10168             }
10169
10170             NSLog(@"ユニットの地形適用後:%g", dmg);
10171             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10172             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10173
10174             grazeFlag = false;
10175             omfg = rand()%100;
10176             if(graze > omfg && !healFlag) {dmg = dmg/5;
10177                 grazeFlag = true;
10178             }
10179             if(battleDef2Flag) dmg -= dmg*0.5;
10180             battleDef2Flag = false;
10181             dmg = floor(dmg);
10182             if(dmg < 0) dmg = 0;
10183             U->CL.S_C.HP -= dmg;
10184             U->C.S_C.vigor++;
10185
10186         }else if(U2A->D->sort == 1){
10187             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10188             dmg = floor(dmg);
10189
10190             U->CL.S_C.HP += dmg;
10191
10192             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10193             healFlag = true;
10194         }
10195
10196         while(1){
10197             if(U->CL.S_C.HP <= 0) {
10198                 U->CL.S_C.HP = 0;
10199                 U2->C.S_C.vigor += 5;
10200
10201                 messageProcess = 2;
10202                 if(U->dead) break;
10203                 U->dead = true;
10204
10205
10206                 if(U->targType1L)
10207                     targType1cnt[0]--;
10208                 if(U->targType2L) {
10209                     targType2cnt[0]--;
10210                     targType2Lflag = true;
10211                 }
10212
10213                 if(U->targType1D)
10214                     targType1cnt[1]--;
10215                 if(U->targType2D) {
10216                     targType2cnt[1]--;
10217                     targType2Dflag = true;
10218                 }
10219
10220                 break;
10221             }
10222             break;
10223         }
10224
10225         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10226         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10227
10228         if(![U2A->msg isEqualToString:@""]){
10229
10230             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10231                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10232
10233         }
10234
10235         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10236         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10237         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
10238     }else if(battleDef1Flag){
10239
10240
10241         U = UTop;
10242         while (!(AUN[1] == U->number)) {
10243             U = U->next;
10244         }
10245
10246
10247         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10248
10249
10250     }else if(battleDod1Flag){
10251
10252         U = UTop;
10253         while (!(AUN[1] == U->number)) {
10254             U = U->next;
10255         }
10256
10257         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10258
10259
10260     }else{
10261
10262         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10263
10264     }
10265     [battleDialog setStringValue:message];
10266
10267
10268     U = UTop;
10269
10270     bLoopFlag = true;
10271
10272     if(healFlag) {
10273         messageProcess++;
10274     };
10275     messageProcess++;
10276
10277     return;
10278
10279 }
10280
10281 -(void)DisplayMessageMod1B{
10282
10283     double def2 = (double)31/32;
10284     NSString *message = @"";
10285
10286     enum{
10287         RIKU,
10288         UMI,
10289         CHU,
10290         SORA,
10291     };
10292
10293     enum{
10294         A,
10295         B,
10296         C,
10297         D,
10298         E,
10299         S,
10300         SS
10301     };
10302
10303
10304     if(bLoopFlag) return;
10305
10306     U = UTop;
10307     while (!(AUN[1] == U->number)) {
10308         U = U->next;
10309     }
10310     U2 = U;
10311     U = UTop;
10312
10313     U = UTop;
10314     while (!(DUN[1] == U->number)) {
10315         U = U->next;
10316     }
10317
10318     ATTACK *aTop2 = U->CL.A;
10319     int mostDmg = 0;
10320     int mostNum = 0;
10321     int num = 0;
10322     int mpCost =0;
10323     if(U->CL.A) {
10324         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10325         costVIG = U->C.A->vigor;
10326     }
10327     while(U->CL.A){
10328         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10329         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]){
10330             mostDmg = U->CL.A->totalD;
10331             mostNum = num;
10332         }
10333         U->CL.A = U->CL.A->next;
10334         num++;
10335     }
10336
10337     U->CL.A = aTop2;
10338
10339     if(!battleSet2PushedFlag){
10340         for(int i = 0;i < mostNumSub;i++){
10341             U->CL.A = U->CL.A->next;
10342         }
10343
10344     }else{
10345         for(int i = 0;i < crCAL2;i++){
10346             U->CL.A = U->CL.A->next;
10347         }
10348     }
10349
10350     if(!U->CL.A->name){
10351
10352         U->CL.A = NULL;
10353     }
10354     if(U->CL.A){
10355     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]){
10356     }else while(U->CL.A){
10357         U->CL.A = U->CL.A->next;
10358     }
10359     }
10360
10361     if(!U->CL.A){
10362         U->CL.A = aTop2;
10363         U = UTop;
10364         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10365         goto SKIP1;
10366     }
10367
10368     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10369
10370
10371     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10372         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10373
10374         NSString *path = @"data/AttackList/ALdata";
10375
10376         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10377
10378         path = [path stringByAppendingFormat:@"/"];
10379
10380         path = [path stringByAppendingString:U->CL.A->AN.movName];
10381
10382
10383         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10384
10385         if(AVpreview) {
10386             AVPV.player = [AVpreview retain];
10387         }else{
10388             goto avAWESOME1B;
10389         }
10390
10391         [AVPV setControlsStyle:0];
10392         [AVPV setHidden:NO];
10393         [AVpreview play];
10394         [battleDialog setStringValue:message];
10395
10396         avPlayerFlag2 = true;
10397
10398         U->CL.A = aTop2;
10399         U = UTop;
10400         return;
10401     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
10402
10403
10404         animationFlag2 = true;
10405         aniFrameCnt = 0;
10406         return;
10407     }
10408
10409
10410 avAWESOME1B:{}
10411
10412     dmg = U->CL.A->totalD;
10413
10414     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10415     U->CL.S_C.EN -= costMP;
10416
10417     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10418     hitFix = U->CL.A->hitPercent;
10419
10420     U2A = U->CL.A;
10421     U->CL.A = aTop2;
10422
10423
10424     U = UTop;
10425     while (!(AUN[1] == U->number)) {
10426         U = U->next;
10427     }
10428
10429
10430     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;
10431     if(hit > 100) hit = 100;
10432
10433     if([self sortEcheck:U2A opponent:U])
10434         hit = 0;
10435
10436     battleDod1Flag = false;
10437
10438     int omg = 100;
10439     if(battleDod1Flag) omg = 50;
10440
10441     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
10442         NSLog(@"修正前のダメージ:%g", dmg);
10443         dmg = [self dmgResist:dmg];
10444         NSLog(@"属性後のダメージ:%g", dmg);
10445         def2 = pow(def2, U->CL.S_C.ARM);
10446         int omfg = rand()%100;
10447         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10448         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10449         dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10450
10451
10452         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10453         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10454         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10455
10456         if(U->CL.S_C.typeMOVE == RIKU){
10457             if(U2A->riku == A) dmg = dmg*1.2;
10458             if(U2A->riku == B) dmg = dmg*1.0;
10459             if(U2A->riku == C) dmg = dmg*0.6;
10460             if(U2A->riku == D) dmg = dmg*0.2;
10461             if(U2A->riku == E) dmg = 0;
10462             if(U2A->riku == S) dmg = dmg*1.5;
10463             if(U2A->riku == SS) dmg = dmg*2.0;
10464         } if(U->CL.S_C.typeMOVE == UMI &&
10465              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10466             if(U2A->umi == A) dmg = dmg*1.2;
10467             if(U2A->umi == B) dmg = dmg*1.0;
10468             if(U2A->umi == C) dmg = dmg*0.6;
10469             if(U2A->umi == D) dmg = dmg*0.2;
10470             if(U2A->umi == E) dmg = 0;
10471             if(U2A->umi == S) dmg = dmg*1.5;
10472             if(U2A->umi == SS) dmg = dmg*2.0;
10473         }else if(U->CL.S_C.typeMOVE == UMI){
10474             if(U2A->riku == A) dmg = dmg*1.2;
10475             if(U2A->riku == B) dmg = dmg*1.0;
10476             if(U2A->riku == C) dmg = dmg*0.6;
10477             if(U2A->riku == D) dmg = dmg*0.2;
10478             if(U2A->riku == E) dmg = 0;
10479             if(U2A->riku == S) dmg = dmg*1.5;
10480             if(U2A->riku == SS) dmg = dmg*2.0;
10481
10482         } if(U->CL.S_C.typeMOVE == CHU){
10483             if(U2A->chu == A) dmg = dmg*1.2;
10484             if(U2A->chu == B) dmg = dmg*1.0;
10485             if(U2A->chu == C) dmg = dmg*0.6;
10486             if(U2A->chu == D) dmg = dmg*0.2;
10487             if(U2A->chu == E) dmg = 0;
10488             if(U2A->chu == S) dmg = dmg*1.5;
10489             if(U2A->chu == SS) dmg = dmg*2.0;
10490         } if(U->CL.S_C.typeMOVE == SORA){
10491             if(U2A->sora == A) dmg = dmg*1.2;
10492             if(U2A->sora == B) dmg = dmg*1.0;
10493             if(U2A->sora == C) dmg = dmg*0.6;
10494             if(U2A->sora == D) dmg = dmg*0.2;
10495             if(U2A->sora == E) dmg = 0;
10496             if(U2A->sora == S) dmg = dmg*1.5;
10497             if(U2A->sora == SS) dmg = dmg*2.0;
10498         }
10499
10500         NSLog(@"ユニットの地形適用後:%g", dmg);
10501
10502         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10503
10504         grazeFlag = false;
10505         omfg = rand()&100;
10506         if(graze > omfg && !healFlag) {dmg = dmg/5;
10507             grazeFlag = true;
10508         }
10509
10510         if(battleDef1Flag) dmg -= dmg*0.5;
10511         battleDef1Flag = false;
10512         dmg = floor(dmg);
10513         if(dmg < 0) dmg = 0;
10514         U->CL.S_C.HP -= dmg;
10515         U->C.S_C.vigor++;
10516
10517         while(1){
10518             if(U->CL.S_C.HP <= 0) {
10519                 U->CL.S_C.HP = 0;
10520                 U2->C.S_C.vigor += 5;
10521
10522                 messageProcess = 2;
10523                 if(U->dead) break;
10524                 U->dead = true;
10525
10526
10527                 if(U->targType1L)
10528                     targType1cnt[0]--;
10529                 if(U->targType2L) {
10530                     targType2cnt[0]--;
10531                     targType2Lflag = true;
10532                 }
10533
10534                 if(U->targType1D)
10535                     targType1cnt[1]--;
10536                 if(U->targType2D) {
10537                     targType2cnt[1]--;
10538                     targType2Dflag = true;
10539                 }
10540
10541                 break;
10542             }
10543             break;
10544         }
10545
10546
10547
10548         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10549
10550         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10551
10552         if(![U2A->msg isEqualToString:@""]){
10553             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10554                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10555         }
10556
10557
10558
10559         if(grazeFlag)
10560             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10561
10562         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10563
10564     }else if(battleDef2Flag){
10565
10566
10567         U = UTop;
10568         while (!(DUN[1] == U->number)) {
10569             U = U->next;
10570         }
10571
10572
10573         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10574
10575
10576     }else if(battleDod2Flag){
10577
10578         U = UTop;
10579         while (!(DUN[1] == U->number)) {
10580             U = U->next;
10581         }
10582
10583         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10584
10585
10586     }else{
10587
10588         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10589     }
10590 SKIP1:
10591     [battleDialog setStringValue:message];
10592
10593     U = UTop;
10594     bLoopFlag = true;
10595     messageProcess++;
10596     return;
10597
10598 }
10599
10600 -(void)DisplayMessageMod2A{//攻撃側モビール
10601
10602     double def2 = (double)31/32;
10603     NSString *message = @"";
10604
10605     enum{
10606         RIKU,
10607         UMI,
10608         CHU,
10609         SORA,
10610     };
10611
10612     enum{
10613         A,
10614         B,
10615         C,
10616         D,
10617         E,
10618         S,
10619         SS
10620     };
10621
10622
10623     if(bLoopFlag) return;
10624     U = UTop;
10625
10626     while (!(DUN[1] == U->number)) {
10627         U = U->next;
10628     }
10629     U2 = U;
10630
10631     U = UTop;
10632     while (!(AUN[1] == U->number)) {
10633         U = U->next;
10634     }
10635
10636     ATTACK *aTop = U->CL.A;
10637     for(int i = 0;i < crCAL1;i++){
10638         U->CL.A = U->CL.A->next;
10639     }
10640
10641
10642     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10643
10644     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10645         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10646
10647         NSString *path = @"data/AttackList/ALdata";
10648
10649         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10650
10651         path = [path stringByAppendingFormat:@"/"];
10652
10653         path = [path stringByAppendingString:U->CL.A->AN.movName];
10654
10655         NSData *AVData = [NSData dataWithContentsOfFile:path];
10656
10657         if(AVData)
10658             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10659
10660
10661         if(!AVpreview){
10662
10663             NSString *path = @"data/AttackList3/IALdata";
10664
10665             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10666
10667             path = [path stringByAppendingFormat:@"/"];
10668
10669             path = [path stringByAppendingString:U->CL.A->AN.movName];
10670
10671
10672             NSData *AVData = [NSData dataWithContentsOfFile:path];
10673
10674             if(AVData)
10675                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10676
10677
10678         }
10679
10680         if(AVpreview) {
10681             AVPV.player = [AVpreview retain];
10682         }else{
10683             goto avAWESOME2A;
10684         }
10685
10686
10687         [AVPV setHidden:NO];
10688         [AVpreview play];
10689         [battleDialog setStringValue:message];
10690
10691         avPlayerFlag1 = true;
10692
10693         U->CL.A = aTop;
10694
10695         U = UTop;
10696         return;
10697     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10698
10699         [battleDialog setStringValue:message];
10700         animationFlag1 = true;
10701         aniFrameCnt = 0;
10702         return;
10703     }
10704
10705 avAWESOME2A:{}
10706
10707     dmg = U->CL.A->totalD;
10708     double val = 1/log(3+U2->C.S_C.MP/64);
10709     if(U2->C.aura){
10710         dmg = dmg*val;
10711     }
10712
10713     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10714     U->CL.S_C.EN -= costMP;
10715
10716     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10717     hitFix = U->CL.A->hitPercent;
10718
10719     U2A = U->CL.A;
10720     U->CL.A = aTop;
10721
10722     U = UTop;
10723     while (!(DUN[1] == U->number)) {
10724         U = U->next;
10725     }
10726
10727     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
10728
10729     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
10730     if(hi < 0) hi = 0;
10731
10732     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
10733     if(hit > 100) hit = 100;
10734     if(U2A->D->sort == 1){
10735         hit = 100;
10736     }
10737     if([self sortEcheck:U2A opponent:U])
10738         hit = 0;
10739
10740     healFlag = false;
10741
10742     int wtf = 100;
10743     if(battleDod2Flag) wtf = 50;
10744     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10745
10746         if(U2A->D->sort == 0){
10747             NSLog(@"修正前のダメージ:%g", dmg);
10748             dmg = [self dmgResist:dmg];
10749             NSLog(@"属性後のダメージ:%g", dmg);
10750             def2 = pow(def2, U->C.S_C.DEF);
10751             int omfg = rand()%100;
10752             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
10753             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
10754             dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
10755             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10756             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10757             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10758
10759             if(U->C.S_C.typeMOVE == RIKU){
10760                 if(U2A->riku == A) dmg = dmg*1.2;
10761                 if(U2A->riku == B) dmg = dmg*1.0;
10762                 if(U2A->riku == C) dmg = dmg*0.6;
10763                 if(U2A->riku == D) dmg = dmg*0.2;
10764                 if(U2A->riku == E) dmg = 0;
10765                 if(U2A->riku == S) dmg = dmg*1.5;
10766                 if(U2A->riku == SS) dmg = dmg*2.0;
10767             } if(U->C.S_C.typeMOVE == UMI &&
10768                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10769                 if(U2A->umi == A) dmg = dmg*1.2;
10770                 if(U2A->umi == B) dmg = dmg*1.0;
10771                 if(U2A->umi == C) dmg = dmg*0.6;
10772                 if(U2A->umi == D) dmg = dmg*0.2;
10773                 if(U2A->umi == E) dmg = 0;
10774                 if(U2A->umi == S) dmg = dmg*1.5;
10775                 if(U2A->umi == SS) dmg = dmg*2.0;
10776             }else if(U->C.S_C.typeMOVE == UMI){
10777                 if(U2A->riku == A) dmg = dmg*1.2;
10778                 if(U2A->riku == B) dmg = dmg*1.0;
10779                 if(U2A->riku == C) dmg = dmg*0.6;
10780                 if(U2A->riku == D) dmg = dmg*0.2;
10781                 if(U2A->riku == E) dmg = 0;
10782                 if(U2A->riku == S) dmg = dmg*1.5;
10783                 if(U2A->riku == SS) dmg = dmg*2.0;
10784
10785             } if(U->C.S_C.typeMOVE == CHU){
10786                 if(U2A->chu == A) dmg = dmg*1.2;
10787                 if(U2A->chu == B) dmg = dmg*1.0;
10788                 if(U2A->chu == C) dmg = dmg*0.6;
10789                 if(U2A->chu == D) dmg = dmg*0.2;
10790                 if(U2A->chu == E) dmg = 0;
10791                 if(U2A->chu == S) dmg = dmg*1.5;
10792                 if(U2A->chu == SS) dmg = dmg*2.0;
10793             } if(U->C.S_C.typeMOVE == SORA){
10794                 if(U2A->sora == A) dmg = dmg*1.2;
10795                 if(U2A->sora == B) dmg = dmg*1.0;
10796                 if(U2A->sora == C) dmg = dmg*0.6;
10797                 if(U2A->sora == D) dmg = dmg*0.2;
10798                 if(U2A->sora == E) dmg = 0;
10799                 if(U2A->sora == S) dmg = dmg*1.5;
10800                 if(U2A->sora == SS) dmg = dmg*2.0;
10801             }
10802
10803             NSLog(@"ユニットの地形適用後:%g", dmg);
10804             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10805             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10806
10807             grazeFlag = false;
10808             omfg = rand()%100;
10809             if(graze > omfg && !healFlag) {dmg = dmg/5;
10810                 grazeFlag = true;
10811             }
10812             if(battleDef2Flag) dmg -= dmg*0.5;
10813             battleDef2Flag = false;
10814             dmg = floor(dmg);
10815             if(dmg < 0) dmg = 0;
10816             U->C.S_C.HP -= dmg;
10817             U->C.S_C.vigor++;
10818
10819         }else if(U2A->D->sort == 1){
10820             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10821             dmg = floor(dmg);
10822
10823             U->CL.S_C.HP += dmg;
10824
10825             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10826             healFlag = true;
10827         }
10828
10829         while(1){
10830             if(U->C.S_C.HP <= 0) {
10831                 U->C.S_C.HP = 0;
10832                 U2->C.S_C.vigor += 5;
10833
10834                 messageProcess = 2;
10835                 if(U->dead) break;
10836                 U->dead = true;
10837
10838
10839                 if(U->targType1L)
10840                     targType1cnt[0]--;
10841                 if(U->targType2L) {
10842                     targType2cnt[0]--;
10843                     targType2Lflag = true;
10844                 }
10845
10846                 if(U->targType1D)
10847                     targType1cnt[1]--;
10848                 if(U->targType2D) {
10849                     targType2cnt[1]--;
10850                     targType2Dflag = true;
10851                 }
10852
10853                 break;
10854             }
10855             break;
10856         }
10857
10858         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
10859         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
10860
10861         if(![U2A->msg isEqualToString:@""]){
10862
10863             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10864                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
10865
10866         }
10867
10868         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10869         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
10870         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
10871     }else if(battleDef1Flag){
10872
10873
10874         U = UTop;
10875         while (!(AUN[1] == U->number)) {
10876             U = U->next;
10877         }
10878
10879
10880         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10881
10882
10883     }else if(battleDod1Flag){
10884
10885         U = UTop;
10886         while (!(AUN[1] == U->number)) {
10887             U = U->next;
10888         }
10889
10890         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10891
10892
10893     }else{
10894
10895         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
10896
10897     }
10898     [battleDialog setStringValue:message];
10899
10900
10901     U = UTop;
10902
10903     bLoopFlag = true;
10904
10905     if(healFlag) {
10906         messageProcess++;
10907     };
10908     messageProcess++;
10909
10910     return;
10911
10912
10913 }
10914
10915 -(void)DisplayMessageMod2B{
10916
10917     double def2 = (double)31/32;
10918     NSString *message = @"";
10919
10920     enum{
10921         RIKU,
10922         UMI,
10923         CHU,
10924         SORA,
10925     };
10926
10927     enum{
10928         A,
10929         B,
10930         C,
10931         D,
10932         E,
10933         S,
10934         SS
10935     };
10936
10937
10938     if(bLoopFlag) return;
10939
10940     U = UTop;
10941     while (!(AUN[1] == U->number)) {
10942         U = U->next;
10943     }
10944     U2 = U;
10945     U = UTop;
10946
10947     U = UTop;
10948     while (!(DUN[1] == U->number)) {
10949         U = U->next;
10950     }
10951
10952     ATTACK *aTop2 = U->C.A;
10953     int mostDmg = 0;
10954     int mostNum = -1;
10955     int num = 0;
10956     int mpCost =0;
10957     if(U->C.A) {
10958         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
10959         costVIG = U->C.A->vigor;
10960         }
10961     while(U->C.A){
10962         costVIG = U->C.A->vigor;
10963
10964         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
10965         if(U->C.A->D)
10966         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]){
10967             mostDmg = U->C.A->totalD;
10968             mostNum = num;
10969         }
10970         U->C.A = U->C.A->next;
10971         num++;
10972     }
10973
10974     U->C.A = aTop2;
10975
10976     if(!battleSet2PushedFlag){
10977         for(int i = 0;i < mostNumSub;i++){
10978             U->C.A = U->C.A->next;
10979         }
10980
10981         if(mostNum < 0) U->C.A = NULL;
10982     }else{
10983         for(int i = 0;i < crCAL2;i++){
10984             U->C.A = U->C.A->next;
10985         }
10986     }
10987     if(U->C.A){
10988         if(U->C.A->D){
10989     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]){
10990     }else while(U->CL.A){
10991         U->C.A = U->C.A->next;
10992     }}
10993     }
10994     if(!U->C.A){
10995         U->C.A = aTop2;
10996         U = UTop;
10997         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10998         goto SKIP1;
10999     }
11000     if(!U->C.A->name){
11001         U->C.A = aTop2;
11002         U = UTop;
11003         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11004         goto SKIP1;
11005     }
11006
11007     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
11008
11009
11010     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
11011         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11012
11013         NSString *path = @"data/AttackList/ALdata";
11014
11015         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11016
11017         path = [path stringByAppendingFormat:@"/"];
11018
11019         path = [path stringByAppendingString:U->C.A->AN.movName];
11020
11021
11022         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11023
11024         if(AVpreview) {
11025             AVPV.player = [AVpreview retain];
11026         }else{
11027             goto avAWESOME2B;
11028         }
11029
11030         [AVPV setControlsStyle:0];
11031         [AVPV setHidden:NO];
11032         [AVpreview play];
11033         [battleDialog setStringValue:message];
11034
11035         avPlayerFlag2 = true;
11036
11037         U->C.A = aTop2;
11038         U = UTop;
11039         return;
11040     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
11041
11042
11043         animationFlag2 = true;
11044         aniFrameCnt = 0;
11045         return;
11046     }
11047
11048
11049 avAWESOME2B:{}
11050
11051
11052     /*
11053     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11054     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11055     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11056     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11057     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11058     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11059     */
11060
11061     double urSupposedToGet;
11062
11063     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11064
11065     double oopsIsRight;
11066     bool lolFlag = false;
11067     if(U->C.A) {
11068     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11069     else oopsIsRight = U->C.S_C.MIS;
11070
11071         if(U->C.A->D){
11072     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;
11073     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;
11074     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;
11075     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;
11076     if(U->C.A->D->type == 4) {
11077         lolFlag = true;
11078         dmg = (U->C.S_C.CAP + urSupposedToGet)*oopsIsRight/100;
11079     }
11080     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11081         }}
11082         costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11083     U->C.S_C.MP -= costMP;
11084
11085     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11086     hitFix = U->C.A->hitPercent;
11087
11088     U2A = U->C.A;
11089     U->C.A = aTop2;
11090
11091     U = UTop;
11092     while (!(AUN[1] == U->number)) {
11093         U = U->next;
11094     }
11095
11096     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;
11097     if(hit > 100) hit = 100;
11098
11099     if([self sortEcheck:U2A opponent:U])
11100         hit = 0;
11101
11102     battleDod1Flag = false;
11103
11104     int omg = 100;
11105     if(battleDod1Flag) omg = 50;
11106
11107     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11108         NSLog(@"修正前のダメージ:%g, %g", dmg, U2A->D->seed);
11109
11110         dmg = [self dmgResist:dmg];
11111         NSLog(@"属性後のダメージ:%g", dmg);
11112         def2 = pow(def2, U->CL.S_C.ARM);
11113         int omfg = rand()%100;
11114         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
11115         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11116         if(lolFlag) dmg = (dmg*omfg/100/10 + dmg);
11117         else dmg = (dmg*omfg/100/10+ dmg - U->CL.S_C.ARM);
11118
11119
11120         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11121         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11122         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11123
11124         if(U->CL.S_C.typeMOVE == RIKU){
11125             if(U2A->riku == A) dmg = dmg*1.2;
11126             if(U2A->riku == B) dmg = dmg*1.0;
11127             if(U2A->riku == C) dmg = dmg*0.6;
11128             if(U2A->riku == D) dmg = dmg*0.2;
11129             if(U2A->riku == E) dmg = 0;
11130             if(U2A->riku == S) dmg = dmg*1.5;
11131             if(U2A->riku == SS) dmg = dmg*2.0;
11132         } if(U->CL.S_C.typeMOVE == UMI &&
11133              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11134             if(U2A->umi == A) dmg = dmg*1.2;
11135             if(U2A->umi == B) dmg = dmg*1.0;
11136             if(U2A->umi == C) dmg = dmg*0.6;
11137             if(U2A->umi == D) dmg = dmg*0.2;
11138             if(U2A->umi == E) dmg = 0;
11139             if(U2A->umi == S) dmg = dmg*1.5;
11140             if(U2A->umi == SS) dmg = dmg*2.0;
11141         }else if(U->CL.S_C.typeMOVE == UMI){
11142             if(U2A->riku == A) dmg = dmg*1.2;
11143             if(U2A->riku == B) dmg = dmg*1.0;
11144             if(U2A->riku == C) dmg = dmg*0.6;
11145             if(U2A->riku == D) dmg = dmg*0.2;
11146             if(U2A->riku == E) dmg = 0;
11147             if(U2A->riku == S) dmg = dmg*1.5;
11148             if(U2A->riku == SS) dmg = dmg*2.0;
11149
11150         } if(U->CL.S_C.typeMOVE == CHU){
11151             if(U2A->chu == A) dmg = dmg*1.2;
11152             if(U2A->chu == B) dmg = dmg*1.0;
11153             if(U2A->chu == C) dmg = dmg*0.6;
11154             if(U2A->chu == D) dmg = dmg*0.2;
11155             if(U2A->chu == E) dmg = 0;
11156             if(U2A->chu == S) dmg = dmg*1.5;
11157             if(U2A->chu == SS) dmg = dmg*2.0;
11158         } if(U->CL.S_C.typeMOVE == SORA){
11159             if(U2A->sora == A) dmg = dmg*1.2;
11160             if(U2A->sora == B) dmg = dmg*1.0;
11161             if(U2A->sora == C) dmg = dmg*0.6;
11162             if(U2A->sora == D) dmg = dmg*0.2;
11163             if(U2A->sora == E) dmg = 0;
11164             if(U2A->sora == S) dmg = dmg*1.5;
11165             if(U2A->sora == SS) dmg = dmg*2.0;
11166         }
11167
11168         NSLog(@"ユニットの地形適用後:%g", dmg);
11169
11170         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11171
11172         grazeFlag = false;
11173         omfg = rand()&100;
11174         if(graze > omfg && !healFlag) {dmg = dmg/5;
11175             grazeFlag = true;
11176         }
11177
11178         if(battleDef1Flag) dmg -= dmg*0.5;
11179         battleDef1Flag = false;
11180         dmg = floor(dmg);
11181         if(dmg < 0) dmg = 0;
11182         U->CL.S_C.HP -= dmg;
11183         U->C.S_C.vigor++;
11184
11185         while(1){
11186             if(U->CL.S_C.HP <= 0) {
11187                 U->CL.S_C.HP = 0;
11188                 U2->C.S_C.vigor += 5;
11189
11190                 messageProcess = 2;
11191                 if(U->dead) break;
11192                 U->dead = true;
11193
11194
11195                 if(U->targType1L)
11196                     targType1cnt[0]--;
11197                 if(U->targType2L) {
11198                     targType2cnt[0]--;
11199                     targType2Lflag = true;
11200                 }
11201
11202                 if(U->targType1D)
11203                     targType1cnt[1]--;
11204                 if(U->targType2D) {
11205                     targType2cnt[1]--;
11206                     targType2Dflag = true;
11207                 }
11208
11209                 break;
11210             }
11211             break;
11212         }
11213
11214
11215
11216         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11217
11218         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11219
11220         if(![U2A->msg isEqualToString:@""]){
11221             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11222                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11223         }
11224
11225
11226
11227         if(grazeFlag)
11228             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11229
11230         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11231
11232     }else if(battleDef2Flag){
11233
11234
11235         U = UTop;
11236         while (!(DUN[1] == U->number)) {
11237             U = U->next;
11238         }
11239
11240
11241         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11242
11243
11244     }else if(battleDod2Flag){
11245
11246         U = UTop;
11247         while (!(DUN[1] == U->number)) {
11248             U = U->next;
11249         }
11250
11251         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11252
11253
11254     }else{
11255
11256         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11257     }
11258 SKIP1:
11259     [battleDialog setStringValue:message];
11260
11261     U = UTop;
11262     bLoopFlag = true;
11263     messageProcess++;
11264     return;
11265
11266
11267 }
11268
11269 -(void)DisplayMessageMod3A{//防御側モビール
11270
11271     double def2 = (double)31/32;
11272     NSString *message = @"";
11273
11274     enum{
11275         RIKU,
11276         UMI,
11277         CHU,
11278         SORA,
11279     };
11280
11281     enum{
11282         A,
11283         B,
11284         C,
11285         D,
11286         E,
11287         S,
11288         SS
11289     };
11290
11291     static bool extentbool3 = false;
11292     static bool extentbool4 = false;
11293     if(!extentbool3 && extentBattleFlag2){
11294         extentbool3 = true;
11295         extentMPcostFlag = false;
11296         DUNnum = 1;
11297     }
11298     if(!extentBattleFlag2){
11299         DUNnum = 1;
11300     }
11301
11302     if(bLoopFlag) return;
11303     U = UTop;
11304     U = UTop;
11305     while (!(DUN[DUNnum] == U->number)) {
11306         U = U->next;
11307     }
11308     U2 = U;
11309
11310     U = UTop;
11311     while (!(AUN[1] == U->number)) {
11312         U = U->next;
11313     }
11314
11315     ATTACK *aTop = U->C.A;
11316     for(int i = 0;i < crCAL1;i++){
11317         U->C.A = U->C.A->next;
11318     }
11319
11320
11321     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
11322
11323
11324     [bplayer2 setImage:U2->CL.imgb];
11325     //[bplayer2 setImageScaling:NSScaleToFit];
11326     [nplayer2 setStringValue:U2->CL.name];
11327     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->CL.S_C.HP, U2->CL.S_M.HP]];
11328     [lplayer2 setIntValue:U2->CL.S_C.HP/U2->CL.S_M.HP*100];
11329     [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
11330     [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
11331     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
11332
11333     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){
11334         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11335
11336         NSString *path = @"data/AttackList/ALdata";
11337
11338         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11339
11340         path = [path stringByAppendingFormat:@"/"];
11341
11342         path = [path stringByAppendingString:U->C.A->AN.movName];
11343
11344         NSData *AVData = [NSData dataWithContentsOfFile:path];
11345
11346         if(AVData)
11347             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11348
11349
11350         if(!AVpreview){
11351
11352             NSString *path = @"data/AttackList3/IALdata";
11353
11354             path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
11355
11356             path = [path stringByAppendingFormat:@"/"];
11357
11358             path = [path stringByAppendingString:U->C.A->AN.movName];
11359
11360
11361             NSData *AVData = [NSData dataWithContentsOfFile:path];
11362
11363             if(AVData)
11364                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11365
11366
11367         }
11368
11369         if(AVpreview) {
11370             AVPV.player = [AVpreview retain];
11371         }else{
11372             goto avAWESOME3A;
11373         }
11374
11375
11376         [AVPV setHidden:NO];
11377         [AVpreview play];
11378         [battleDialog setStringValue:message];
11379
11380         avPlayerFlag1 = true;
11381
11382
11383         U->C.A = aTop;
11384         U = UTop;
11385         return;
11386     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUN[DUNnum] == 1){
11387
11388         [battleDialog setStringValue:message];
11389         animationFlag1 = true;
11390         aniFrameCnt = 0;
11391         return;
11392     }
11393
11394 avAWESOME3A:{}
11395
11396     /*
11397     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11398     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11399     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11400     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11401     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11402     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11403     */
11404
11405     double urSupposedToGet;
11406
11407     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11408
11409     double oopsIsRight;
11410
11411     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11412     else oopsIsRight = U->C.S_C.MIS;
11413     bool lolflag = false;
11414     if(U->C.A->D){
11415     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;
11416     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;
11417     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;
11418     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;
11419
11420     if(U->C.A->D->type == 4){
11421         lolflag = true;
11422         dmg = (U->C.S_C.CAP + U->C.A->totalD)*oopsIsRight/100;
11423
11424     }
11425     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11426     double val2 = log(3+U2->C.S_C.MP/64);
11427         if(U->C.aura){
11428             dmg = dmg*val2;
11429         }
11430     }
11431     costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11432
11433     if(extentMPcostFlag && extentBattleFlag2){
11434
11435     }else{
11436         U->C.S_C.MP -= costMP;
11437         extentMPcostFlag = true;
11438     }
11439
11440     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11441     hitFix = U->C.A->hitPercent;
11442
11443     U2A = U->C.A;
11444     U->C.A = aTop;
11445
11446     U = UTop;
11447     while (!(DUN[DUNnum] == U->number)) {
11448         U = U->next;
11449     }
11450     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;
11451     if(hit > 100) hit = 100;
11452     if(U2A->D->sort == 1){
11453         hit = 100;
11454     }
11455     if([self sortEcheck:U2A opponent:U])
11456         hit = 0;
11457
11458     healFlag = false;
11459
11460     int wtf = 100;
11461     if(battleDod2Flag) wtf = 50;
11462     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
11463
11464         if(U2A->D->sort == 0){
11465             NSLog(@"修正前のダメージ:%g", dmg);
11466             dmg = [self dmgResist:dmg];
11467             NSLog(@"属性後のダメージ:%g", dmg);
11468             def2 = pow(def2, U->CL.S_C.ARM);
11469             int omfg = rand()%100;
11470             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, (U->CL.S_C.ARM));
11471             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11472             if(lolflag) dmg = (dmg*omfg/100/10 + dmg);
11473             else dmg = (dmg*omfg/100/10 + dmg - U->CL.S_C.ARM);
11474             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11475             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11476             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11477
11478             if(U->CL.S_C.typeMOVE == RIKU){
11479                 if(U2A->riku == A) dmg = dmg*1.2;
11480                 if(U2A->riku == B) dmg = dmg*1.0;
11481                 if(U2A->riku == C) dmg = dmg*0.6;
11482                 if(U2A->riku == D) dmg = dmg*0.2;
11483                 if(U2A->riku == E) dmg = 0;
11484                 if(U2A->riku == S) dmg = dmg*1.5;
11485                 if(U2A->riku == SS) dmg = dmg*2.0;
11486             } if(U->CL.S_C.typeMOVE == UMI &&
11487                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11488                 if(U2A->umi == A) dmg = dmg*1.2;
11489                 if(U2A->umi == B) dmg = dmg*1.0;
11490                 if(U2A->umi == C) dmg = dmg*0.6;
11491                 if(U2A->umi == D) dmg = dmg*0.2;
11492                 if(U2A->umi == E) dmg = 0;
11493                 if(U2A->umi == S) dmg = dmg*1.5;
11494                 if(U2A->umi == SS) dmg = dmg*2.0;
11495             }else if(U->CL.S_C.typeMOVE == UMI){
11496                 if(U2A->riku == A) dmg = dmg*1.2;
11497                 if(U2A->riku == B) dmg = dmg*1.0;
11498                 if(U2A->riku == C) dmg = dmg*0.6;
11499                 if(U2A->riku == D) dmg = dmg*0.2;
11500                 if(U2A->riku == E) dmg = 0;
11501                 if(U2A->riku == S) dmg = dmg*1.5;
11502                 if(U2A->riku == SS) dmg = dmg*2.0;
11503
11504             } if(U->CL.S_C.typeMOVE == CHU){
11505                 if(U2A->chu == A) dmg = dmg*1.2;
11506                 if(U2A->chu == B) dmg = dmg*1.0;
11507                 if(U2A->chu == C) dmg = dmg*0.6;
11508                 if(U2A->chu == D) dmg = dmg*0.2;
11509                 if(U2A->chu == E) dmg = 0;
11510                 if(U2A->chu == S) dmg = dmg*1.5;
11511                 if(U2A->chu == SS) dmg = dmg*2.0;
11512             } if(U->CL.S_C.typeMOVE == SORA){
11513                 if(U2A->sora == A) dmg = dmg*1.2;
11514                 if(U2A->sora == B) dmg = dmg*1.0;
11515                 if(U2A->sora == C) dmg = dmg*0.6;
11516                 if(U2A->sora == D) dmg = dmg*0.2;
11517                 if(U2A->sora == E) dmg = 0;
11518                 if(U2A->sora == S) dmg = dmg*1.5;
11519                 if(U2A->sora == SS) dmg = dmg*2.0;
11520             }
11521
11522             NSLog(@"ユニットの地形適用後:%g", dmg);
11523             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
11524             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11525
11526             grazeFlag = false;
11527             omfg = rand()%100;
11528             if(graze > omfg && !healFlag) {dmg = dmg/5;
11529                 grazeFlag = true;
11530             }
11531             if(battleDef2Flag) dmg -= dmg*0.5;
11532             battleDef2Flag = false;
11533             dmg = floor(dmg);
11534             if(dmg < 0) dmg = 0;
11535             U->CL.S_C.HP -= dmg;
11536             U->C.S_C.vigor++;
11537
11538         }else if(U2A->D->sort == 1){
11539             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
11540             dmg = floor(dmg);
11541
11542             U->C.S_C.HP += dmg;
11543             if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
11544             healFlag = true;
11545         }
11546
11547         while(1){
11548             if(U->CL.S_C.HP <= 0) {
11549                 U->CL.S_C.HP = 0;
11550                 U2->C.S_C.vigor += 5;
11551
11552                 messageProcess = 2;
11553                 if(U->dead) break;
11554                 U->dead = true;
11555
11556
11557                 if(U->targType1L)
11558                     targType1cnt[0]--;
11559                 if(U->targType2L) {
11560                     targType2cnt[0]--;
11561                     targType2Lflag = true;
11562                 }
11563
11564                 if(U->targType1D)
11565                     targType1cnt[1]--;
11566                 if(U->targType2D) {
11567                     targType2cnt[1]--;
11568                     targType2Dflag = true;
11569                 }
11570
11571                 break;
11572             }
11573             break;
11574         }
11575
11576         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11577         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11578
11579         if(![U2A->msg isEqualToString:@""]){
11580
11581             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11582                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11583
11584         }
11585
11586         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11587         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11588         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
11589     }else if(battleDef1Flag){
11590
11591
11592         U = UTop;
11593         while (!(AUN[1] == U->number)) {
11594             U = U->next;
11595         }
11596
11597
11598         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11599
11600
11601     }else if(battleDod1Flag){
11602
11603         U = UTop;
11604         while (!(AUN[1] == U->number)) {
11605             U = U->next;
11606         }
11607
11608         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11609
11610
11611     }else{
11612
11613         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11614
11615     }
11616     [battleDialog setStringValue:message];
11617
11618
11619     U = UTop;
11620
11621     bLoopFlag = true;
11622
11623     if(!extentBattleFlag2){
11624         if(healFlag) {
11625             messageProcess++;
11626         };
11627         messageProcess++;
11628     }else if(extentBattleFlag2){
11629         DUNnum++;
11630         messageProcess = 1;
11631         if(DUN[DUNnum] <= 0){
11632             DUNnum = 1;
11633             messageProcess++;
11634             messageProcess++;
11635             extentBattleFlag2 = false;
11636             extentbool3 = false;
11637             extentMPcostFlag = false;
11638         }
11639     }
11640     return;
11641
11642 }
11643
11644 -(void)DisplayMessageMod3B{
11645
11646
11647     double def2 = (double)31/32;
11648     NSString *message = @"";
11649
11650     enum{
11651         RIKU,
11652         UMI,
11653         CHU,
11654         SORA,
11655     };
11656
11657     enum{
11658         A,
11659         B,
11660         C,
11661         D,
11662         E,
11663         S,
11664         SS
11665     };
11666
11667
11668     if(bLoopFlag) return;
11669     U = UTop;
11670
11671     U = UTop;
11672     while (!(AUN[1] == U->number)) {
11673         U = U->next;
11674     }
11675     U2 = U;
11676
11677     U = UTop;
11678     while (!(DUN[1] == U->number)) {
11679         U = U->next;
11680     }
11681     ATTACK *aTop2 = U->CL.A;
11682     int mostDmg = 0;
11683     int mostNum = -1;
11684     int num = 0;
11685     int mpCost =0;
11686     if(U->CL.A) {
11687         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11688         costVIG = U->C.A->vigor;
11689     }
11690     while(U->CL.A){
11691         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11692         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]){
11693             mostDmg = U->CL.A->totalD;
11694             mostNum = num;
11695         }
11696         U->CL.A = U->CL.A->next;
11697         num++;
11698     }
11699
11700     if(mostNum < 0) U->C.A = NULL;
11701
11702     U->CL.A = aTop2;
11703
11704     if(!battleSet2PushedFlag){
11705         for(int i = 0;i < mostNumSub;i++){
11706             U->CL.A = U->CL.A->next;
11707         }
11708
11709
11710     }else{
11711         for(int i = 0;i < crCAL2;i++){
11712             U->CL.A = U->C.A->next;
11713         }
11714     }
11715
11716     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]){
11717     }else while(U->CL.A){
11718         U->CL.A = U->CL.A->next;
11719     }
11720
11721     if(!U->CL.A){
11722         U->CL.A = aTop2;
11723         U = UTop;
11724
11725         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11726         goto SKIP1;
11727     }
11728
11729     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
11730
11731     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
11732         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11733
11734         NSString *path = @"data/AttackList/ALdata";
11735
11736         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11737
11738         path = [path stringByAppendingFormat:@"/"];
11739
11740         path = [path stringByAppendingString:U->CL.A->AN.movName];
11741
11742
11743         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11744
11745         if(AVpreview) {
11746             AVPV.player = [AVpreview retain];
11747         }else{
11748             goto avAWESOME3B;
11749         }
11750
11751         [AVPV setControlsStyle:0];
11752         [AVPV setHidden:NO];
11753         [AVpreview play];
11754         [battleDialog setStringValue:message];
11755
11756         avPlayerFlag2 = true;
11757
11758         U->CL.A = aTop2;
11759         U = UTop;
11760         return;
11761     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
11762
11763
11764         animationFlag2 = true;
11765         aniFrameCnt = 0;
11766         return;
11767     }
11768
11769
11770 avAWESOME3B:{}
11771
11772
11773
11774     dmg = U->CL.A->totalD;
11775
11776     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11777     U->CL.S_C.EN -= costMP;
11778
11779     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
11780     hitFix = U->CL.A->hitPercent;
11781
11782     U2A = U->CL.A;
11783     U->CL.A = aTop2;
11784
11785     U = UTop;
11786     while (!(AUN[1] == U->number)) {
11787         U = U->next;
11788     }
11789
11790     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
11791
11792     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
11793     if(hi < 0) hi = 0;
11794
11795     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
11796     if(hit > 100) hit = 100;
11797
11798     if([self sortEcheck:U2A opponent:U])
11799         hit = 0;
11800
11801     battleDod1Flag = false;
11802
11803     int omg = 100;
11804     if(battleDod1Flag) omg = 50;
11805
11806     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11807         NSLog(@"修正前のダメージ:%g", dmg);
11808         dmg = [self dmgResist:dmg];
11809         NSLog(@"属性後のダメージ:%g", dmg);
11810         def2 = pow(def2, U->C.S_C.DEF);
11811         int omfg = rand()%100;
11812         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
11813         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
11814         dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
11815
11816
11817         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11818         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11819         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11820
11821         if(U->C.S_C.typeMOVE == RIKU){
11822             if(U2A->riku == A) dmg = dmg*1.2;
11823             if(U2A->riku == B) dmg = dmg*1.0;
11824             if(U2A->riku == C) dmg = dmg*0.6;
11825             if(U2A->riku == D) dmg = dmg*0.2;
11826             if(U2A->riku == E) dmg = 0;
11827             if(U2A->riku == S) dmg = dmg*1.5;
11828             if(U2A->riku == SS) dmg = dmg*2.0;
11829         } if(U->C.S_C.typeMOVE == UMI &&
11830              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11831             if(U2A->umi == A) dmg = dmg*1.2;
11832             if(U2A->umi == B) dmg = dmg*1.0;
11833             if(U2A->umi == C) dmg = dmg*0.6;
11834             if(U2A->umi == D) dmg = dmg*0.2;
11835             if(U2A->umi == E) dmg = 0;
11836             if(U2A->umi == S) dmg = dmg*1.5;
11837             if(U2A->umi == SS) dmg = dmg*2.0;
11838         }else if(U->C.S_C.typeMOVE == UMI){
11839             if(U2A->riku == A) dmg = dmg*1.2;
11840             if(U2A->riku == B) dmg = dmg*1.0;
11841             if(U2A->riku == C) dmg = dmg*0.6;
11842             if(U2A->riku == D) dmg = dmg*0.2;
11843             if(U2A->riku == E) dmg = 0;
11844             if(U2A->riku == S) dmg = dmg*1.5;
11845             if(U2A->riku == SS) dmg = dmg*2.0;
11846
11847         } if(U->C.S_C.typeMOVE == CHU){
11848             if(U2A->chu == A) dmg = dmg*1.2;
11849             if(U2A->chu == B) dmg = dmg*1.0;
11850             if(U2A->chu == C) dmg = dmg*0.6;
11851             if(U2A->chu == D) dmg = dmg*0.2;
11852             if(U2A->chu == E) dmg = 0;
11853             if(U2A->chu == S) dmg = dmg*1.5;
11854             if(U2A->chu == SS) dmg = dmg*2.0;
11855         } if(U->C.S_C.typeMOVE == SORA){
11856             if(U2A->sora == A) dmg = dmg*1.2;
11857             if(U2A->sora == B) dmg = dmg*1.0;
11858             if(U2A->sora == C) dmg = dmg*0.6;
11859             if(U2A->sora == D) dmg = dmg*0.2;
11860             if(U2A->sora == E) dmg = 0;
11861             if(U2A->sora == S) dmg = dmg*1.5;
11862             if(U2A->sora == SS) dmg = dmg*2.0;
11863         }
11864
11865         NSLog(@"ユニットの地形適用後:%g", dmg);
11866
11867         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11868
11869         grazeFlag = false;
11870         omfg = rand()&100;
11871         if(graze > omfg && !healFlag) {dmg = dmg/5;
11872             grazeFlag = true;
11873         }
11874
11875         if(battleDef1Flag) dmg -= dmg*0.5;
11876         battleDef1Flag = false;
11877         dmg = floor(dmg);
11878         if(dmg < 0) dmg = 0;
11879         U->C.S_C.HP -= dmg;
11880         U->C.S_C.vigor++;
11881
11882         while(1){
11883             if(U->C.S_C.HP <= 0) {
11884                 U->C.S_C.HP = 0;
11885                 U2->C.S_C.vigor += 5;
11886
11887                 messageProcess = 2;
11888                 if(U->dead) break;
11889                 U->dead = true;
11890
11891
11892                 if(U->targType1L)
11893                     targType1cnt[0]--;
11894                 if(U->targType2L) {
11895                     targType2cnt[0]--;
11896                     targType2Lflag = true;
11897                 }
11898
11899                 if(U->targType1D)
11900                     targType1cnt[1]--;
11901                 if(U->targType2D) {
11902                     targType2cnt[1]--;
11903                     targType2Dflag = true;
11904                 }
11905
11906                 break;
11907             }
11908             break;
11909         }
11910
11911
11912
11913         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
11914
11915         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
11916
11917         if(![U2A->msg isEqualToString:@""]){
11918             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11919                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
11920         }
11921
11922
11923
11924         if(grazeFlag)
11925             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11926
11927         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
11928
11929     }else if(battleDef2Flag){
11930
11931
11932         U = UTop;
11933         while (!(DUN[1] == U->number)) {
11934             U = U->next;
11935         }
11936
11937
11938         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
11939
11940
11941     }else if(battleDod2Flag){
11942
11943         U = UTop;
11944         while (!(DUN[1] == U->number)) {
11945             U = U->next;
11946         }
11947
11948         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
11949
11950
11951     }else{
11952
11953         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
11954     }
11955 SKIP1:
11956     [battleDialog setStringValue:message];
11957
11958     U = UTop;
11959     bLoopFlag = true;
11960     messageProcess++;
11961     return;
11962
11963 }
11964
11965 -(NSString*)originalMessage:(NSString*)str subj:(NSString*)subj obje:(NSString*)obje{
11966
11967     NSString *string;
11968     NSArray *array;
11969     NSString *result = @"";
11970
11971     string = [str copy];
11972
11973     array = [string componentsSeparatedByString:@"$subj"];
11974
11975     for(int i = 0;i < [array count];i++){
11976         if(i != 0)
11977             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", subj]] retain];
11978
11979         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
11980     }
11981
11982     string = [result copy];
11983
11984     array = [string componentsSeparatedByString:@"$obje"];
11985
11986     result = @"";
11987
11988     for(int i = 0;i < [array count];i++){
11989         if(i != 0)
11990             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", obje]] retain];
11991
11992         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
11993     }
11994
11995     //NSLog(@"%@", result);
11996
11997     return result;
11998 }
11999
12000
12001
12002 -(double)dmgResist:(double)DMG{
12003
12004     int sd[22];
12005
12006     sd[0] = U->C.R_C.blow + U->C.R_F.blow;
12007     sd[1] = U->C.R_C.slash + U->C.R_F.slash;
12008     sd[2] = U->C.R_C.stub + U->C.R_F.stub;
12009     sd[3] = U->C.R_C.arrow + U->C.R_F.arrow;
12010     sd[4] = U->C.R_C.gun + U->C.R_F.gun;
12011     sd[5] = U->C.R_C.shell + U->C.R_F.shell;
12012
12013     sd[6] = U->C.R_C.flame + U->C.R_F.flame;
12014     sd[7] = U->C.R_C.cold + U->C.R_F.cold;
12015     sd[8] = U->C.R_C.electoric + U->C.R_F.electoric;
12016     sd[9] = U->C.R_C.air + U->C.R_F.air;
12017     sd[10] = U->C.R_C.water + U->C.R_F.water;
12018     sd[11] = U->C.R_C.gas + U->C.R_F.gas;
12019     sd[12] = U->C.R_C.holy + U->C.R_F.holy;
12020     sd[13] = U->C.R_C.dark + U->C.R_F.dark;
12021     sd[14] = U->C.R_C.explosion + U->C.R_F.explosion;
12022     sd[15] = U->C.R_C.blood + U->C.R_F.blood;
12023
12024     sd[16] = U->C.R_C.paralysis + U->C.R_F.paralysis;
12025     sd[17] = U->C.R_C.confusion + U->C.R_F.confusion;
12026     sd[18] = U->C.R_C.poison + U->C.R_F.poison;
12027     sd[19] = U->C.R_C.sleep + U->C.R_F.sleep;
12028     sd[20] = U->C.R_C.charm + U->C.R_F.charm;
12029     sd[21] = U->C.R_C.silent + U->C.R_F.silent;
12030
12031
12032
12033     for(int i = 0;i <= 21;i++)
12034         sd[i] &= ~(sd[i] >> 31);
12035
12036     if(U2A->D){
12037
12038     if(U2A->D->seed == 0) DMG = DMG * sd[0]/100;
12039     if(U2A->D->seed == 1) DMG = DMG * sd[1]/100;
12040     if(U2A->D->seed == 2) DMG = DMG * sd[2]/100;
12041     if(U2A->D->seed == 3) DMG = DMG * sd[3]/100;
12042     if(U2A->D->seed == 4) DMG = DMG * sd[4]/100;
12043     if(U2A->D->seed == 5) DMG = DMG * sd[5]/100;
12044
12045     if(U2A->D->seed == 6) DMG = DMG * sd[6]/100;
12046     if(U2A->D->seed == 7) DMG = DMG * sd[7]/100;
12047     if(U2A->D->seed == 8) DMG = DMG * sd[8]/100;
12048     if(U2A->D->seed == 9) DMG = DMG * sd[9]/100;
12049     if(U2A->D->seed == 10) DMG = DMG * sd[10]/100;
12050     if(U2A->D->seed == 11) DMG = DMG * sd[11]/100;
12051     if(U2A->D->seed == 12) DMG = DMG * sd[12]/100;
12052     if(U2A->D->seed == 13) DMG = DMG * sd[13]/100;
12053     if(U2A->D->seed == 14) DMG = DMG * sd[14]/100;
12054     if(U2A->D->seed == 15) DMG = DMG * sd[15]/100;
12055
12056     if(U2A->D->seed == 16) DMG = DMG * sd[16]/100;
12057     if(U2A->D->seed == 17) DMG = DMG * sd[17]/100;
12058     if(U2A->D->seed == 18) DMG = DMG * sd[18]/100;
12059     if(U2A->D->seed == 19) DMG = DMG * sd[19]/100;
12060     if(U2A->D->seed == 20) DMG = DMG * sd[20]/100;
12061     if(U2A->D->seed == 21) DMG = DMG * sd[21]/100;
12062     }
12063     return DMG;
12064 }
12065
12066 -(IBAction)battleStart:(id)sender{
12067     battleSetUp = true;
12068     battleSet1Flag = false;
12069     battleSet2Flag = false;
12070     battleSettingFlag = false;
12071
12072     attackingWait = false;
12073     crapBugFixFlag = true;
12074
12075     [battlePanel close];
12076 }
12077
12078
12079 -(void)battleStartCPU{
12080     battleSetUp = true;
12081     battleSet1Flag = false;
12082     battleSet2Flag = false;
12083     battleSettingFlag = false;
12084
12085     crapBugFixFlag = true;
12086
12087     [battlePanel close];
12088 }
12089
12090 -(IBAction)battleSet1:(id)sender{
12091     battleSetFlag = false;
12092     battleSet1Flag = true;
12093     battleDef1Flag = false;
12094     battleDod1Flag = false;
12095     battleSettingFlag = true;
12096     battleSet2PushedFlag = false;
12097
12098     U = UTop;
12099     while (!(AUN[1] == U->number)) {
12100         U = U->next;
12101     }
12102     if(U->chipNumberL >= 0)
12103     {
12104         U = UTop;
12105         [self initCAttackList2];
12106         [self initCAttackSelect2];
12107     }
12108     else if(U->chipNumber >= 0) {
12109         U = UTop;
12110         [self initCAttackList];
12111         [self initCAttackSelect];
12112     }
12113     U = UTop;
12114
12115     [atkPanel makeKeyAndOrderFront:nil];
12116 }
12117 -(IBAction)battleDef1:(id)sender{
12118     battleDef1Flag = true;
12119     battleSet1Flag = false;
12120     battleDod1Flag = false;
12121 }
12122 -(IBAction)battleDod1:(id)sender{
12123     battleDod1Flag = true;
12124     battleDef1Flag = false;
12125     battleSet1Flag = false;
12126 }
12127 -(IBAction)battleSet2:(id)sender{
12128     battleSetFlag = true;
12129     battleSet2Flag = true;
12130     battleDef2Flag = false;
12131     battleDod2Flag = false;
12132     battleSettingFlag = true;
12133     battleSet2PushedFlag = true;
12134
12135     U = UTop;
12136     while (!(DUN[1] == U->number)) {
12137         U = U->next;
12138     }
12139
12140     if(U->chipNumberL >= 0){
12141         U = UTop;
12142         [self initCAttackList2];
12143         [self initCAttackSelect2];
12144     }
12145     else if(U->chipNumber >= 0) {
12146         U = UTop;
12147         [self initCAttackList];
12148         [self initCAttackSelect];
12149     }
12150     U = UTop;
12151     [atkPanel makeKeyAndOrderFront:nil];
12152 }
12153 -(IBAction)battleDef2:(id)sender{
12154     battleDef2Flag = true;
12155     battleSet2Flag = false;
12156     battleDod2Flag = false;
12157 }
12158 -(IBAction)battleDod2:(id)sender{
12159     battleDod2Flag = true;
12160     battleDef2Flag = false;
12161     battleSet2Flag = false;
12162 }
12163
12164 -(IBAction)battleCancel:(id)sender{
12165     battleFlag = false;
12166     battleSettingFlag = false;
12167
12168     battleSet2PushedFlag = false;
12169     attackingWait = false;
12170
12171     [battlePanel close];
12172 }
12173
12174 -(IBAction)researchCancel:(id)sender{
12175     [researchPanel close];
12176 }
12177
12178 -(void)setCommandPanel{
12179
12180     menuPoint.x = [mapWindow frame].origin.x + possionLocalX*32;
12181     menuPoint.y = [mapWindow frame].origin.y + possionLocalY*32 - 180;
12182
12183
12184     if(buildSkillFlag) {
12185         cIncludeCreateFlag = true;
12186         menuPoint.y -= 20;
12187     }else cIncludeCreateFlag = false;
12188     if(summonSkillFlag) {
12189         cIncludeSummonFlag = true;
12190         menuPoint.y -= 20;
12191     }else cIncludeSummonFlag = false;
12192     int plusBtnValue = 0;
12193
12194     if(cIncludeCreateFlag && cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12195
12196         plusBtnValue = 200;
12197         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12198
12199
12200         plusBtnValue -= moveBtn.frame.size.height + 12;
12201         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12202         [[commandPanel contentView] addSubview:moveBtn];
12203
12204         plusBtnValue -= attackBtn.frame.size.height + 2;
12205         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12206         [[commandPanel contentView] addSubview:attackBtn];
12207
12208         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12209         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12210         [[commandPanel contentView] addSubview:stanbyBtn];
12211
12212         [createBtn setTransparent: NO];
12213         [createBtn setEnabled: YES];
12214         plusBtnValue -= createBtn.frame.size.height + 2;
12215         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12216         [[commandPanel contentView] addSubview:createBtn];
12217
12218         [summonBtn setTransparent: NO];
12219         [summonBtn setEnabled: YES];
12220         plusBtnValue -= summonBtn.frame.size.height + 2;
12221         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12222         [[commandPanel contentView] addSubview:summonBtn];
12223
12224         plusBtnValue -= statusBtn.frame.size.height + 2;
12225         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12226         [[commandPanel contentView] addSubview:statusBtn];
12227
12228         plusBtnValue -= cancelBtn.frame.size.height + 2;
12229         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12230         [[commandPanel contentView] addSubview:cancelBtn];
12231
12232     }
12233     else if(cIncludeCreateFlag && !cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag){
12234         plusBtnValue = 180;
12235         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12236
12237         plusBtnValue -= moveBtn.frame.size.height + 12;
12238         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12239         [[commandPanel contentView] addSubview:moveBtn];
12240
12241         plusBtnValue -= attackBtn.frame.size.height + 2;
12242         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12243         [[commandPanel contentView] addSubview:attackBtn];
12244
12245         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12246         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12247         [[commandPanel contentView] addSubview:stanbyBtn];
12248
12249         [createBtn setTransparent: NO];
12250         [createBtn setEnabled: YES];
12251         plusBtnValue -= createBtn.frame.size.height + 2;
12252         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12253         [[commandPanel contentView] addSubview:createBtn];
12254
12255         [summonBtn setTransparent: YES];
12256         [summonBtn setEnabled: NO];
12257
12258         plusBtnValue -= statusBtn.frame.size.height + 2;
12259         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12260         [[commandPanel contentView] addSubview:statusBtn];
12261
12262         plusBtnValue -= cancelBtn.frame.size.height + 2;
12263         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12264         [[commandPanel contentView] addSubview:cancelBtn];
12265
12266
12267     }else if(cIncludeSummonFlag && !cIncludeCreateFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12268
12269         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, 210) display:YES];
12270
12271         plusBtnValue = 180;
12272         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12273
12274
12275         plusBtnValue -= moveBtn.frame.size.height + 12;
12276         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12277         [[commandPanel contentView] addSubview:moveBtn];
12278
12279         plusBtnValue -= attackBtn.frame.size.height + 2;
12280         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12281         [[commandPanel contentView] addSubview:attackBtn];
12282
12283         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12284         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12285         [[commandPanel contentView] addSubview:stanbyBtn];
12286
12287         [createBtn setTransparent: YES];
12288         [createBtn setEnabled: NO];
12289
12290         [summonBtn setTransparent: NO];
12291         [summonBtn setEnabled: YES];
12292         plusBtnValue -= summonBtn.frame.size.height + 2;
12293         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12294         [[commandPanel contentView] addSubview:summonBtn];
12295
12296         plusBtnValue -= statusBtn.frame.size.height + 2;
12297         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12298         [[commandPanel contentView] addSubview:statusBtn];
12299
12300         plusBtnValue -= cancelBtn.frame.size.height + 2;
12301         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12302         [[commandPanel contentView] addSubview:cancelBtn];
12303     }else{
12304
12305         plusBtnValue = 160;
12306         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12307
12308         plusBtnValue -= moveBtn.frame.size.height + 12;
12309         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12310         [[commandPanel contentView] addSubview:moveBtn];
12311
12312         plusBtnValue -= attackBtn.frame.size.height + 2;
12313         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12314         [[commandPanel contentView] addSubview:attackBtn];
12315
12316         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12317         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12318         [[commandPanel contentView] addSubview:stanbyBtn];
12319
12320         [createBtn setTransparent: YES];
12321         [createBtn setEnabled: NO];
12322
12323         [summonBtn setTransparent: YES];
12324         [summonBtn setEnabled: NO];
12325
12326         plusBtnValue -= statusBtn.frame.size.height + 2;
12327         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12328         [[commandPanel contentView] addSubview:statusBtn];
12329
12330         plusBtnValue -= cancelBtn.frame.size.height + 2;
12331         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12332         [[commandPanel contentView] addSubview:cancelBtn];
12333     }
12334
12335
12336 }
12337
12338 -(void)openMessage{
12339     [IVimage setHidden:NO];
12340     [TFname setHidden:NO];
12341     [TFmessage setHidden:NO];
12342     [BXname setHidden:NO];
12343     [BXmessage setHidden:NO];
12344     [IVimage setEnabled:YES];
12345     [TFname setEnabled:YES];
12346     [TFmessage setEnabled:YES];
12347 }
12348
12349 -(void)closeMessage{
12350     [IVimage setHidden:YES];
12351     [TFname setHidden:YES];
12352     [TFmessage setHidden:YES];
12353     [BXname setHidden:YES];
12354     [BXmessage setHidden:YES];
12355     [IVimage setEnabled:NO];
12356     [TFname setEnabled:NO];
12357     [TFmessage setEnabled:NO];
12358 }
12359
12360 -(MAPSCRIPT0*)setMessage:(MAPSCRIPT0*)MS0{
12361
12362
12363     if(!messageDialog){
12364         [self closeMessage];
12365         damnitFixFlag = true;
12366     }else if(MS0->S1.str){
12367         [self openMessage];
12368         damnitFixFlag = false;
12369     NSString *string = @"";
12370
12371         string = [MS0->S1.str retain];
12372         if(!string){
12373             MS0->endFlag = true;
12374             textInstantBugFixFlag = false;
12375             messageEndFlag = false;
12376             messageDialog = false;
12377             return MS0;
12378         }
12379
12380         if(!initStringNum){
12381             msgLvl = 0;
12382             msgCnt = 0;
12383             initStringNum = true;
12384             textInstantBugFixFlag = true;
12385         }
12386
12387         msgMax = (int)[string length];
12388
12389
12390         if(!initImgFlag)
12391         {
12392             [self loadImg];
12393             initImgFlag = true;
12394         }
12395
12396         [IVimage setImage:MS0->S1.img];
12397         if(MS0->S1.name) [TFname setStringValue:MS0->S1.name];
12398         else [TFname setStringValue:@""];
12399
12400         if(msgCnt <= msgMax){
12401             if(string) {
12402                 [TFmessage setStringValue:[string substringToIndex:msgCnt]];
12403                 msgCnt++;
12404             }
12405             else [TFmessage setStringValue:@""];
12406         }
12407         wtRdy3 = true;
12408
12409
12410         if(messageEndFlag){
12411             MS0->endFlag = true;
12412             messageEndFlag = false;
12413             initStringNum = false;
12414             messageDialog = false;
12415             MS0->succeessfulFlag = true;
12416             wtRdy3 = false;
12417             textInstantBugFixFlag = false;
12418             [self setMessage:NULL];
12419         }
12420
12421         return MS0;
12422     }else{
12423         MS0->endFlag = true;
12424         messageEndFlag = false;
12425         messageDialog = false;
12426         initStringNum = false;
12427     }
12428
12429
12430     return MS0;
12431 }
12432
12433 -(void) loadImg{
12434
12435     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
12436     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
12437
12438     NSString *path = @"Map/";
12439     NSString *fileData = nil;
12440     NSArray *fileDataArray;
12441
12442     path = [path stringByAppendingFormat:@"%@"  ,MF[MFselectedRow+1].fileName];
12443
12444     fileData = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:nil];
12445
12446     fileDataArray = [fileData componentsSeparatedByString:@"\n"];
12447
12448     MAPSCRIPT0 *MS00 = MF[MFselectedRow+1].MS.D->P;
12449     MAPSCRIPT0 *m00Top = MS00;
12450     for (int i = 0; i < [fileDataArray count]; i++) {
12451         if(!MS00) break;
12452         NSRange range = [[fileDataArray objectAtIndex:i] rangeOfString:@"◆"];
12453         if(range.location != NSNotFound){
12454
12455             NSArray *array2 = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
12456             if(MS00->type == 1)
12457             {
12458                 MS00->S1.iName = [[array2 objectAtIndex:2] retain];
12459
12460             for(int k = 0; k < UCN;k++){
12461
12462                 if([MS00->S1.iName isEqualToString:UC[k].nameClass]){
12463                     MS00->S1.img = [UC[k].imgb retain];
12464                     MS00 = MS00->next;
12465                     break;
12466                 }
12467
12468             }
12469             }
12470
12471         }
12472     }
12473
12474     MS00 = m00Top;
12475
12476 }
12477
12478
12479 -(MAPSCRIPT0*)setSwitch:(MAPSCRIPT0*)MS0{
12480
12481     if(MS0->switch1)
12482     for(int i = 0;*(MS0->switch1 + i) >0;i++){
12483         Suicchi[*(MS0->switch1+i)] = true;
12484
12485     }
12486     if(MS0->switch2)
12487     for(int i = 0;*(MS0->switch2 + i) >0;i++){
12488         Suicchi[*(MS0->switch2+i)] = false;
12489
12490     }
12491
12492     MS0->succeessfulFlag = true;
12493     MS0->endFlag = true;
12494     return MS0;
12495 }
12496
12497 -(MAPSCRIPT0*)setBranch:(MAPSCRIPT0*)MS0{
12498
12499     MAPSCRIPT0 *CRMS0 = MS0;
12500     bool branchEndFlag = false;
12501     bool branchSuceedFlag = false;
12502     bool trueFlag = true;
12503
12504
12505     if(MS0->endFlag)
12506         return MS0;
12507
12508     /*
12509     if(!Uselected){
12510         MS0->endFlag = true;
12511         return MS0;
12512     }*/
12513
12514     if(1){
12515
12516         if(MS0->S4.suicchiFlag){
12517             if(MS0->S4.suicchiONOFF == 0){
12518                 if(MS0->S4.suicchi)
12519                 for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12520                     if(!Suicchi[*(MS0->S4.suicchi + i)]){
12521                         trueFlag = false;
12522                     }
12523                 }
12524             }else{
12525                 if(MS0->S4.suicchi)
12526                     for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12527                         if(Suicchi[*(MS0->S4.suicchi + i)]){
12528                             trueFlag = false;
12529                         }
12530                     }
12531             }
12532         }
12533
12534         if(MS0->S4.hensuFlag){
12535
12536             if(MS0->S4.teisuFlag){
12537                 if(MS0->S4.hensuType == 0){
12538                     if([Hensuu[MS0->S4.hensu1] intValue] == MS0->S4.teisuValue){
12539
12540                     }else{
12541                         trueFlag = false;
12542                     }
12543                 }else if(MS0->S4.hensuType == 1){
12544                     if([Hensuu[MS0->S4.hensu1] intValue] >= MS0->S4.teisuValue){
12545
12546                     }else{
12547                         trueFlag = false;
12548                     }
12549                 }else if(MS0->S4.hensuType == 2){
12550                     if([Hensuu[MS0->S4.hensu1] intValue] <= MS0->S4.teisuValue){
12551
12552                     }else{
12553                         trueFlag = false;
12554                     }
12555                 }else if(MS0->S4.hensuType == 3){
12556                     if([Hensuu[MS0->S4.hensu1] intValue] > MS0->S4.teisuValue){
12557
12558                     }else{
12559                         trueFlag = false;
12560                     }
12561                 }else if(MS0->S4.hensuType == 4){
12562                     if([Hensuu[MS0->S4.hensu1] intValue] < MS0->S4.teisuValue){
12563
12564                     }else{
12565                         trueFlag = false;
12566                     }
12567                 }else if(MS0->S4.hensuType == 5){
12568                     if([Hensuu[MS0->S4.hensu1] intValue] != MS0->S4.teisuValue){
12569
12570                     }else{
12571                         trueFlag = false;
12572                     }
12573                 }
12574
12575             }if(MS0->S4.hensu2flag){
12576                 if(MS0->S4.hensuType == 0){
12577                     if([Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12578
12579                     }else{
12580                         trueFlag = false;
12581                     }
12582                 }else if(MS0->S4.hensuType == 1){
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 == 2){
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 == 3){
12595                     if([Hensuu[MS0->S4.hensu1] intValue] > [Hensuu[MS0->S4.hensu2] intValue]){
12596
12597                     }else{
12598                         trueFlag = false;
12599                     }
12600                 }else if(MS0->S4.hensuType == 4){
12601                     if([Hensuu[MS0->S4.hensu1] intValue] < [Hensuu[MS0->S4.hensu2] intValue]){
12602
12603                     }else{
12604                         trueFlag = false;
12605                     }
12606                 }else if(MS0->S4.hensuType == 5){
12607                     if(![Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12608
12609                     }else{
12610                         trueFlag = false;
12611                     }
12612                 }
12613             }
12614
12615         }
12616         if(MS0->S4.timerFlag){
12617
12618             if(MS0->S4.timerType == 0){
12619                 if(MS0->S4.timerMin <= cntTimerMin){
12620
12621                 }else if(MS0->S4.timerSec <= cntTimerSec && MS0->S4.timerMin <= cntTimerMin){
12622
12623                 }else{
12624                     trueFlag = false;
12625                 }
12626
12627
12628
12629             }else{
12630                 if(MS0->S4.timerMin >= cntTimerMin){
12631
12632                 }else if(MS0->S4.timerSec >= cntTimerSec && MS0->S4.timerMin >= cntTimerMin){
12633
12634                 }else{
12635                     trueFlag = false;
12636                 }
12637
12638             }
12639         }
12640
12641
12642
12643         if(MS0->S4.unitNumFlag){
12644
12645
12646             int Unum = 0;
12647             U = UTop;;
12648             while (U) {
12649                 Unum++;
12650                 U = U->next;
12651             }U = UTop;
12652
12653             int objeSCSunitCnt = 0;
12654
12655             if(MS0->S4.objeFlag){
12656
12657                 UNIT2 *objeT = MS0->S4.obje;
12658
12659                 while (MS0->S4.obje) {
12660
12661
12662
12663                     U = UTop;
12664                     static bool okflag = true;
12665                     while(U){
12666                         for (int i = 0;i < 1002;i++) {
12667                             for (int k = 0;k < 1002;k++) {
12668                                 objeR[i][k] = 0;
12669                             }
12670                         }
12671
12672                         U2 = UTop;
12673                         while(U2){
12674                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
12675                                 break;
12676                             }
12677                             U2 = U2->next;
12678                         }
12679
12680                         if(!U2){
12681                             U2 = UTop;
12682                             break;
12683                         }
12684
12685                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
12686
12687                         int Cnum = 0;
12688
12689                         for(int bx=1;bx<=chipWidth;bx++){
12690                             for(int by=1;by<=chipHeight;by++){
12691                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
12692
12693                                     if(objeR[U->x][U->y] > 0){
12694                                         Cnum++;
12695                                         if(Unum < Cnum) goto omfgUnitOver2;
12696
12697
12698
12699
12700
12701                                         if(UP)
12702                                         {
12703                                             if(!UPT){
12704                                                 UPT = UP;
12705                                             }
12706
12707                                             UP = UPT;
12708                                             while (UP) {
12709                                                 if(UP->x == U->x && UP->y == U->y){
12710
12711                                                     break;
12712                                                 }else{
12713                                                     okflag = true;
12714                                                 }
12715
12716                                                 UP = UP->next;
12717                                             }
12718
12719                                         }
12720                                         UP = UPT;
12721
12722                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
12723                                         else if(UP){
12724                                             while(UP->next) UP = UP->next;
12725                                         }
12726                                         if(okflag){
12727                                             UP->x = U->x;
12728                                             UP->y = U->y;
12729                                             UP->next = calloc(1, sizeof(UNITPOINT));
12730                                             okflag = false;
12731                                             objeSCSunitCnt++;
12732                                         }
12733                                     }
12734
12735                                 }
12736                             }
12737                         }
12738
12739                     omfgUnitOver2:
12740                         UP = NULL;
12741                         UPT = NULL;
12742
12743                         //NSLog(@"%@, %d, %d", U->C.name, objeSCSunitCnt, objeR[0][0]);
12744
12745                         U = U->next;
12746                     }U = UTop;
12747                     okflag = true;
12748                     MS0->S4.obje = MS0->S4.obje->next;
12749                 }
12750                 MS0->S4.obje = objeT;
12751             }
12752
12753             /*
12754             if(MS0->S4.buildFlag){
12755                 if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12756
12757                 }
12758
12759                 if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
12760                    BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
12761                    Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12762
12763                 }
12764             }
12765             */
12766
12767             int team0num = 0;
12768             int team1num = 0;
12769             int team2num = 0;
12770             if(MS0->S4.team == 0){
12771                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12772                 U = UTop;
12773                 while (U) {
12774                     if(U->team == 0 && !U->dead)
12775                         team0num++;
12776                     U = U->next;
12777                 }U = UTop;
12778                 }
12779                 if(MS0->S4.unitType == 0){
12780                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
12781
12782                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12783
12784                     }else if((MS0->S4.unitNum == team0num) && !MS0->S4.objeFlag){
12785
12786                     }else{
12787                         trueFlag = false;
12788                     }
12789                 }else if(MS0->S4.unitType == 1){
12790                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = 65000;
12791
12792                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12793
12794                     }else if((MS0->S4.unitNum <= team0num) && !MS0->S4.objeFlag){
12795
12796                     }else{
12797                         trueFlag = false;
12798                     }
12799                 }else if(MS0->S4.unitType == 2){
12800                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12801
12802                     }else if((MS0->S4.unitNum >= team0num) && !MS0->S4.objeFlag){
12803
12804                     }else{
12805                         trueFlag = false;
12806                     }
12807                 }
12808
12809
12810             }else if(MS0->S4.team == 1){
12811                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12812                 U = UTop;
12813                 while (U) {
12814                     if(U->team == 1 && !U->dead)
12815                         team1num++;
12816                     U = U->next;
12817                 }U = UTop;
12818                 }
12819                 if(MS0->S4.unitType == 0){
12820                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
12821
12822                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12823
12824                     }else if((MS0->S4.unitNum == team1num) && !MS0->S4.objeFlag){
12825
12826                     }else{
12827                         trueFlag = false;
12828                     }
12829                 }else if(MS0->S4.unitType == 1){
12830                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = 65000;
12831                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12832
12833                     }else if((MS0->S4.unitNum <= team1num) && !MS0->S4.objeFlag){
12834
12835                     }else{
12836                         trueFlag = false;
12837                     }
12838                 }else if(MS0->S4.unitType == 2){
12839
12840                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12841
12842                     }else if((MS0->S4.unitNum >= team1num) && !MS0->S4.objeFlag){
12843
12844                     }else{
12845                         trueFlag = false;
12846                     }
12847                 }
12848             }else if(MS0->S4.team == 2){
12849                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12850                 U = UTop;
12851                 while (U) {
12852                     if(U->team == 2 && !U->dead)
12853                         team2num++;
12854                     U = U->next;
12855                 }U = UTop;
12856                 }
12857                 if(MS0->S4.unitType == 0){
12858                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
12859
12860                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12861
12862                     }else if((MS0->S4.unitNum == team2num) && !MS0->S4.objeFlag){
12863
12864                     }else{
12865                         trueFlag = false;
12866                     }
12867                 }else if(MS0->S4.unitType == 1){
12868                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = 65000;
12869
12870                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12871
12872                     }else if((MS0->S4.unitNum <= team2num) && !MS0->S4.objeFlag){
12873
12874                     }else{
12875                         trueFlag = false;
12876                     }
12877                 }else if(MS0->S4.unitType == 2){
12878                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12879
12880                     }else if((MS0->S4.unitNum >= team2num) && !MS0->S4.objeFlag){
12881
12882                     }else{
12883                         trueFlag = false;
12884                     }
12885                 }
12886             }
12887
12888         }
12889
12890
12891
12892         if(MS0->S4.unitTypeFlag && MS0->S4.unitNumFlag){
12893             UNIT2 *sjt = MS0->S4.subj;
12894             UNIT *chosen = NULL;
12895             UNIT *chosenT = NULL;
12896             int cntUnit = 0;
12897             bool lmao = false;
12898             while(MS0->S4.subj){
12899                 U = UTop;
12900                 while(U){
12901                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
12902                         if(chosen){
12903                             chosen->next = calloc(1, sizeof(UNIT));
12904                             if(!lmao){
12905                                 chosenT = chosen;
12906                                 lmao = true;
12907                             }
12908                             chosen = chosen->next;
12909                         }
12910                         if(!chosen){
12911                             chosen = calloc(1, sizeof(UNIT));
12912                         }
12913                         chosen->x = U->x;
12914                         chosen->y = U->y;
12915                         chosen->C.name = U->C.name;
12916
12917                         if(!U->dead)
12918                             cntUnit++;
12919                     }
12920                     U = U->next;
12921                 }U = UTop;
12922                 if(!lmao){
12923                     chosenT = chosen;
12924                     lmao = true;
12925                 }
12926                 MS0->S4.subj = MS0->S4.subj->next;
12927             }MS0->S4.subj = sjt;
12928             chosen = chosenT;
12929
12930             int objeSCSunitCnt = 0;
12931
12932
12933             int Unum = 0;
12934
12935
12936             while (chosen) {
12937                 Unum++;
12938                 chosen = chosen->next;
12939             }chosen = chosenT;
12940
12941             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
12942
12943                 UNIT2 *objeT = MS0->S4.obje;
12944
12945                 while (MS0->S4.obje) {
12946
12947
12948
12949                     chosen = chosenT;
12950                     static bool okflag = true;
12951                     while(chosen){
12952                         for (int i = 0;i < 1002;i++) {
12953                             for (int k = 0;k < 1002;k++) {
12954                                 objeR[i][k] = 0;
12955                             }
12956                         }
12957
12958                         U2 = UTop;
12959                         while(U2){
12960                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
12961                                 break;
12962                             }
12963                             U2 = U2->next;
12964                         }
12965
12966                         if(!U2){
12967                             U2 = UTop;
12968                             break;
12969                         }
12970
12971
12972                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
12973
12974                         int Cnum = 0;
12975
12976                         for(int bx=1;bx<=chipWidth;bx++){
12977                             for(int by=1;by<=chipHeight;by++){
12978                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
12979
12980                                     if(objeR[chosen->x][chosen->y] > 0){
12981                                         Cnum++;
12982                                         if(Unum < Cnum) goto omfgUnitOver3;
12983
12984
12985
12986
12987
12988                                         if(UP)
12989                                         {
12990                                             if(!UPT){
12991                                                 UPT = UP;
12992                                             }
12993
12994                                             UP = UPT;
12995                                             while (UP) {
12996                                                 if(UP->x == chosen->x && UP->y == chosen->y){
12997
12998                                                     break;
12999                                                 }else{
13000                                                     okflag = true;
13001                                                 }
13002
13003                                                 UP = UP->next;
13004                                             }
13005
13006                                         }
13007                                         UP = UPT;
13008
13009                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13010                                         else if(UP){
13011                                             while(UP->next) UP = UP->next;
13012                                         }
13013                                         if(okflag){
13014                                             UP->x = chosen->x;
13015                                             UP->y = chosen->y;
13016                                             UP->next = calloc(1, sizeof(UNITPOINT));
13017                                             okflag = false;
13018                                             objeSCSunitCnt++;
13019                                         }
13020                                     }
13021
13022                                 }
13023                             }
13024                         }
13025
13026                     omfgUnitOver3:
13027                         UP = NULL;
13028                         UPT = NULL;
13029
13030                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13031
13032                         chosen = chosen->next;
13033                     }chosen = chosenT;
13034                     okflag = true;
13035                     MS0->S4.obje = MS0->S4.obje->next;
13036                 }
13037                 MS0->S4.obje = objeT;
13038             }else if(MS0->S4.objeFlag){
13039
13040                 UNIT2 *objeT = MS0->S4.obje;
13041
13042                 while (MS0->S4.obje) {
13043
13044
13045
13046                     U = UTop;
13047                     static bool okflag = true;
13048                     while(U){
13049                         if(U->team != MS0->S4.team){
13050                             U = U->next;
13051                             continue;
13052                         }
13053                         for (int i = 0;i < 1002;i++) {
13054                             for (int k = 0;k < 1002;k++) {
13055                                 objeR[i][k] = 0;
13056                             }
13057                         }
13058
13059                         U2 = UTop;
13060                         while(U2){
13061                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13062                                 break;
13063                             }
13064                             U2 = U2->next;
13065                         }
13066
13067                         if(!U2){
13068                             U2 = UTop;
13069                             break;
13070                         }
13071
13072                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
13073
13074                         int Cnum = 0;
13075
13076                         for(int bx=1;bx<=chipWidth;bx++){
13077                             for(int by=1;by<=chipHeight;by++){
13078                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13079
13080                                     if(objeR[chosen->x][chosen->y] > 0){
13081                                         Cnum++;
13082                                         if(Unum < Cnum) goto omfgUnitOver30;
13083
13084
13085
13086
13087
13088                                         if(UP)
13089                                         {
13090                                             if(!UPT){
13091                                                 UPT = UP;
13092                                             }
13093
13094                                             UP = UPT;
13095                                             while (UP) {
13096                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13097
13098                                                     break;
13099                                                 }else{
13100                                                     okflag = true;
13101                                                 }
13102
13103                                                 UP = UP->next;
13104                                             }
13105
13106                                         }
13107                                         UP = UPT;
13108
13109                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13110                                         else if(UP){
13111                                             while(UP->next) UP = UP->next;
13112                                         }
13113                                         if(okflag){
13114                                             UP->x = chosen->x;
13115                                             UP->y = chosen->y;
13116                                             UP->next = calloc(1, sizeof(UNITPOINT));
13117                                             okflag = false;
13118                                             objeSCSunitCnt++;
13119                                         }
13120                                     }
13121
13122                                 }
13123                             }
13124                         }
13125
13126                     omfgUnitOver30:
13127                         UP = NULL;
13128                         UPT = NULL;
13129
13130                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13131
13132                         chosen = chosen->next;
13133                     }chosen = chosenT;
13134                     okflag = true;
13135                     MS0->S4.obje = MS0->S4.obje->next;
13136                 }
13137                 MS0->S4.obje = objeT;
13138                 U = UTop;
13139             }
13140
13141
13142             int team0num = 0;
13143             int team1num = 0;
13144             int team2num = 0;
13145             if(MS0->S4.team == 0){
13146                 if(!MS0->S4.unitTypeFlag){
13147                 U = UTop;
13148                 while (U) {
13149                     if(U->team == 0 && !U->dead)
13150                         team0num++;
13151                     U = U->next;
13152                 }U = UTop;
13153                 }
13154                 if(MS0->S4.unitType == 0){
13155                     if(MS0->S4.unitTypeFlag) team0num = MS0->S4.unitNum;
13156
13157                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit)
13158                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13159
13160                     }else if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13161
13162                     }else{
13163                         trueFlag = false;
13164                     }
13165                 }else if(MS0->S4.unitType == 1){
13166                     if(MS0->S4.unitTypeFlag) team0num = 65000;
13167
13168                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit)
13169                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13170
13171                     }else if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13172
13173                     }else{
13174                         trueFlag = false;
13175                     }
13176                 }else if(MS0->S4.unitType == 2){
13177                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit)
13178                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13179
13180                     }else if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13181
13182                     }else{
13183                         trueFlag = false;
13184                     }
13185                 }
13186
13187
13188             }else if(MS0->S4.team == 1){
13189                 if(!MS0->S4.unitTypeFlag){
13190                 U = UTop;
13191                 while (U) {
13192                     if(U->team == 1 && !U->dead)
13193                         team1num++;
13194                     U = U->next;
13195                 }U = UTop;
13196                 }
13197                 if(MS0->S4.unitType == 0){
13198                     if(MS0->S4.unitTypeFlag) team1num = MS0->S4.unitNum;
13199
13200                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit)
13201                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13202
13203                     }else if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13204
13205                     }else{
13206                         trueFlag = false;
13207                     }
13208                 }else if(MS0->S4.unitType == 1){
13209                     if(MS0->S4.unitTypeFlag) team1num = 65000;
13210
13211                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit)
13212                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13213
13214                     }else if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13215
13216                     }else{
13217                         trueFlag = false;
13218                     }
13219                 }else if(MS0->S4.unitType == 2){
13220                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit)
13221                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13222
13223                     }else if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13224
13225                     }else{
13226                         trueFlag = false;
13227                     }
13228                 }
13229             }else if(MS0->S4.team == 2){
13230                 if(!MS0->S4.unitTypeFlag){
13231                 U = UTop;
13232                 while (U) {
13233                     if(U->team == 2 && !U->dead)
13234                         team2num++;
13235                     U = U->next;
13236                 }U = UTop;
13237                 }
13238                 if(MS0->S4.unitType == 0){
13239                     if(MS0->S4.unitTypeFlag) team2num = MS0->S4.unitNum;
13240
13241                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit)
13242                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13243
13244                     }else if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13245
13246                     }else{
13247                         trueFlag = false;
13248                     }
13249                 }else if(MS0->S4.unitType == 1){
13250                     if(MS0->S4.unitTypeFlag) team2num = 65000;
13251
13252                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit)
13253                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13254
13255                     }else if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13256
13257                     }else{
13258                         trueFlag = false;
13259                     }
13260                 }else if(MS0->S4.unitType == 2){
13261                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit)
13262                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13263
13264                     }else if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13265
13266                     }else{
13267                         trueFlag = false;
13268                     }
13269                 }
13270             }
13271
13272
13273
13274
13275
13276
13277         }
13278
13279
13280
13281
13282         if(MS0->S4.placeFlag && MS0->S4.unitNumFlag){
13283             int Unum = 0;
13284             U = UTop;;
13285             while (U) {
13286                 Unum++;
13287                 U = U->next;
13288             }U = UTop;
13289
13290
13291
13292             UNIT2 *sjt = MS0->S4.subj;
13293             UNIT *chosen = NULL;
13294             UNIT *chosenT = NULL;
13295             int cntUnit = 0;
13296             bool lmao = false;
13297             if(MS0->S4.unitTypeFlag){
13298                 while(MS0->S4.subj){
13299                     U = UTop;
13300                     while(U){
13301                         if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13302                             if(chosen){
13303                                 chosen->next = calloc(1, sizeof(UNIT));
13304                                 if(!lmao){
13305                                     chosenT = chosen;
13306                                     lmao = true;
13307                                 }
13308                                 chosen = chosen->next;
13309                             }
13310                             if(!chosen){
13311                                 chosen = calloc(1, sizeof(UNIT));
13312                             }
13313                             chosen->x = U->x;
13314                             chosen->y = U->y;
13315                             chosen->C.name = U->C.name;
13316
13317                             if(!U->dead)
13318                                 cntUnit++;
13319                         }
13320                         U = U->next;
13321                     }U = UTop;
13322                     if(!lmao){
13323                         chosenT = chosen;
13324                         lmao = true;
13325                     }
13326                     MS0->S4.subj = MS0->S4.subj->next;
13327                 }MS0->S4.subj = sjt;
13328                 chosen = chosenT;
13329
13330
13331
13332                 Unum = 0;
13333                 while (chosen) {
13334                     Unum++;
13335                     chosen = chosen->next;
13336                 }chosen = chosenT;
13337
13338             }
13339
13340
13341                 PLACEMENT *wpt = MS0->S4.wayp;
13342                 int waypCnt = 0;
13343                 int waypSCScnt = 0;
13344                 bool waypSCS = false;
13345                 int waypSCSunitCnt = 0;
13346
13347
13348             if(!MS0->S4.unitTypeFlag){
13349
13350             while (MS0->S4.wayp) {
13351                     waypCnt++;
13352
13353
13354
13355
13356                     if(MS0->S4.wayp->type == 0){
13357                     U = UTop;
13358                     while(U){
13359                         if(U->team != MS0->S4.team){
13360                             U = U->next;
13361                             continue;
13362                         }
13363                         if(MS0->S4.wayp->x == U->x && MS0->S4.wayp->y == U->y){
13364                             waypSCScnt++;
13365                             waypSCSunitCnt++;
13366                             break;
13367                         }
13368                         U = U->next;
13369                     }U = UTop;
13370
13371                     }else if(MS0->S4.wayp->type == 1){
13372                         U = UTop;
13373                         static bool okflag = true;
13374                         while(U){
13375                             if(U->team != MS0->S4.team){
13376                                 U = U->next;
13377                                 continue;
13378                             }
13379                             for (int i = 0;i < 1002;i++) {
13380                                 for (int k = 0;k < 1002;k++) {
13381                                     waypR[i][k] = 0;
13382                                 }
13383                             }
13384                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:U scsCnt:&waypSCSunitCnt];
13385
13386                             int Cnum = 0;
13387
13388                             for(int bx=1;bx<=chipWidth;bx++){
13389                                 for(int by=1;by<=chipHeight;by++){
13390                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13391
13392                                         if(waypR[U->x][U->y] > 0){
13393                                             Cnum++;
13394                                             if(Unum < Cnum) goto omfgUnitOver;
13395
13396
13397
13398
13399
13400                                             if(UP)
13401                                             {
13402                                                 if(!UPT){
13403                                                     UPT = UP;
13404                                                 }
13405
13406                                                 UP = UPT;
13407                                                 while (UP) {
13408                                                     if(UP->x == U->x && UP->y == U->y){
13409
13410                                                         break;
13411                                                     }else{
13412                                                         okflag = true;
13413                                                     }
13414
13415                                                     UP = UP->next;
13416                                                 }
13417
13418                                             }
13419                                             UP = UPT;
13420
13421                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13422                                             else if(UP){
13423                                                 while(UP->next) UP = UP->next;
13424                                             }
13425                                             if(okflag){
13426                                                 UP->x = U->x;
13427                                                 UP->y = U->y;
13428                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13429                                                 okflag = false;
13430                                                 waypSCSunitCnt++;
13431                                             }
13432                                         }
13433
13434                                     }
13435                                 }
13436                             }
13437
13438                         omfgUnitOver:
13439                             UP = NULL;
13440                             UPT = NULL;
13441                    //         NSLog(@"%d", waypSCSunitCnt);
13442
13443                              U = U->next;
13444                         }U = UTop;
13445                         okflag = true;
13446
13447
13448
13449                     }else if(MS0->S4.wayp->type == 2){
13450                         U = UTop;
13451                         waypSCSunitCnt = 0;
13452                         static bool okflag = true;
13453                         while(U){
13454                             if(U->team != MS0->S4.team){
13455                                 U = U->next;
13456                                 continue;
13457                             }
13458                             if((MS0->S4.wayp->x <= U->x) && (MS0->S4.wayp->x2 >= U->x) &&
13459                                (MS0->S4.wayp->y <= U->y) && (MS0->S4.wayp->y2 >= U->y)){
13460
13461
13462                                 int Cnum = 0;
13463
13464                                 if(1){
13465                                     Cnum++;
13466                                     if(Unum < Cnum) goto omfgUnitOver;
13467
13468
13469
13470
13471
13472                                     if(UP)
13473                                     {
13474                                         if(!UPT){
13475                                             UPT = UP;
13476                                         }
13477
13478                                         UP = UPT;
13479                                         while (UP) {
13480                                             if(UP->x == U->x && UP->y == U->y){
13481
13482                                                 break;
13483                                             }else{
13484                                                 okflag = true;
13485                                             }
13486
13487                                             UP = UP->next;
13488                                         }
13489
13490                                     }
13491                                     UP = UPT;
13492
13493                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13494                                     else if(UP){
13495                                         while(UP->next) UP = UP->next;
13496                                     }
13497                                     if(okflag){
13498                                         UP->x = U->x;
13499                                         UP->y = U->y;
13500                                         UP->next = calloc(1, sizeof(UNITPOINT));
13501                                         okflag = false;
13502                                         waypSCScnt++;
13503                                         waypSCSunitCnt++;
13504                                     }
13505                                 }
13506
13507
13508
13509
13510                             }
13511                             U = U->next;
13512                         }U = UTop;
13513                         okflag = true;
13514                     }
13515
13516                     MS0->S4.wayp = MS0->S4.wayp->next;
13517                 }MS0->S4.wayp = wpt;
13518            // NSLog(@"%d", waypSCSunitCnt);
13519
13520             if(waypSCScnt >= waypCnt)
13521                 waypSCS = true;
13522
13523             }else if(MS0->S4.unitTypeFlag){
13524
13525                 while (MS0->S4.wayp) {
13526                     waypCnt++;
13527
13528
13529
13530
13531                     if(MS0->S4.wayp->type == 0){
13532                         chosen = chosenT;
13533                         while(chosen){
13534                             if(MS0->S4.wayp->x == chosen->x && MS0->S4.wayp->y == chosen->y){
13535                                 waypSCScnt++;
13536                                 waypSCSunitCnt++;
13537                                 break;
13538                             }
13539                             chosen = chosen->next;
13540                         }chosen = chosenT;
13541
13542                     }else if(MS0->S4.wayp->type == 1){
13543                         chosen = chosenT;
13544                         static bool okflag = true;
13545                         while(chosen){
13546                             for (int i = 0;i < 1002;i++) {
13547                                 for (int k = 0;k < 1002;k++) {
13548                                     waypR[i][k] = 0;
13549                                 }
13550                             }
13551                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:chosen scsCnt:&waypSCSunitCnt];
13552
13553                             int Cnum = 0;
13554
13555                             for(int bx=1;bx<=chipWidth;bx++){
13556                                 for(int by=1;by<=chipHeight;by++){
13557                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13558
13559                                         if(waypR[chosen->x][chosen->y] > 0){
13560                                             Cnum++;
13561                                             if(Unum < Cnum) goto omfgUnitOver5;
13562
13563
13564
13565
13566
13567                                             if(UP)
13568                                             {
13569                                                 if(!UPT){
13570                                                     UPT = UP;
13571                                                 }
13572
13573                                                 UP = UPT;
13574                                                 while (UP) {
13575                                                     if(UP->x == chosen->x && UP->y == chosen->y){
13576
13577                                                         break;
13578                                                     }else{
13579                                                         okflag = true;
13580                                                     }
13581
13582                                                     UP = UP->next;
13583                                                 }
13584
13585                                             }
13586                                             UP = UPT;
13587
13588                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13589                                             else if(UP){
13590                                                 while(UP->next) UP = UP->next;
13591                                             }
13592                                             if(okflag){
13593                                                 UP->x = chosen->x;
13594                                                 UP->y = chosen->y;
13595                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13596                                                 okflag = false;
13597                                                 waypSCSunitCnt++;
13598                                             }
13599                                         }
13600
13601                                     }
13602                                 }
13603                             }
13604
13605                         omfgUnitOver5:
13606                             UP = NULL;
13607                             UPT = NULL;
13608
13609                           //           NSLog(@"%d", waypSCSunitCnt);
13610
13611                             chosen = chosen->next;
13612                         }chosen = chosenT;
13613                         okflag = true;
13614
13615
13616
13617                     }else if(MS0->S4.wayp->type == 2){
13618                         chosen = chosenT;
13619                         waypSCSunitCnt = 0;
13620                         static bool okflag = true;
13621                         while(chosen){
13622                             if((MS0->S4.wayp->x <= chosen->x) && (MS0->S4.wayp->x2 >= chosen->x) &&
13623                                (MS0->S4.wayp->y <= chosen->y) && (MS0->S4.wayp->y2 >= chosen->y)){
13624
13625
13626                                 int Cnum = 0;
13627
13628                                 if(1){
13629                                     Cnum++;
13630                                     if(Unum < Cnum) goto omfgUnitOver;
13631
13632
13633
13634
13635
13636                                     if(UP)
13637                                     {
13638                                         if(!UPT){
13639                                             UPT = UP;
13640                                         }
13641
13642                                         UP = UPT;
13643                                         while (UP) {
13644                                             if(UP->x == chosen->x && UP->y == chosen->y){
13645
13646                                                 break;
13647                                             }else{
13648                                                 okflag = true;
13649                                             }
13650
13651                                             UP = UP->next;
13652                                         }
13653
13654                                     }
13655                                     UP = UPT;
13656
13657                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13658                                     else if(UP){
13659                                         while(UP->next) UP = UP->next;
13660                                     }
13661                                     if(okflag){
13662                                         UP->x = chosen->x;
13663                                         UP->y = chosen->y;
13664                                         UP->next = calloc(1, sizeof(UNITPOINT));
13665                                         okflag = false;
13666                                         waypSCScnt++;
13667                                         waypSCSunitCnt++;
13668                                     }
13669                                 }
13670
13671
13672
13673
13674                             }
13675                             chosen = chosen->next;
13676                         }chosen = chosenT;
13677                         okflag = true;
13678                     }
13679
13680                     MS0->S4.wayp = MS0->S4.wayp->next;
13681                 }MS0->S4.wayp = wpt;
13682               //  NSLog(@"%d", waypSCSunitCnt);
13683
13684                 if(waypSCScnt >= waypCnt)
13685                     waypSCS = true;
13686
13687
13688
13689
13690
13691             }
13692
13693             int team0num = 0;
13694             int team1num = 0;
13695             int team2num = 0;
13696             if(MS0->S4.team == 0){
13697                 if(!MS0->S4.placeFlag){
13698                 U = UTop;
13699                 while (U) {
13700                     if(U->team == 0 && !U->dead)
13701                         team0num++;
13702                     U = U->next;
13703                 }U = UTop;
13704                 }
13705                 if(MS0->S4.unitType == 0){
13706                     if(MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
13707
13708                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13709
13710                     }else{
13711                         trueFlag = false;
13712                     }
13713                 }else if(MS0->S4.unitType == 1){
13714                     if(MS0->S4.placeFlag) team0num = 65000;
13715
13716                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13717
13718                     }else{
13719                         trueFlag = false;
13720                     }
13721                 }else if(MS0->S4.unitType == 2){
13722                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13723
13724                     }else{
13725                         trueFlag = false;
13726                     }
13727                 }
13728
13729
13730             }else if(MS0->S4.team == 1){
13731                 if(!MS0->S4.placeFlag){
13732                 U = UTop;
13733                 while (U) {
13734                     if(U->team == 1 && !U->dead)
13735                         team1num++;
13736                     U = U->next;
13737                 }U = UTop;
13738                 }
13739                 if(MS0->S4.unitType == 0){
13740                     if(MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
13741
13742                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum = waypSCSunitCnt)){
13743
13744                     }else{
13745                         trueFlag = false;
13746                     }
13747                 }else if(MS0->S4.unitType == 1){
13748                     if(MS0->S4.placeFlag) team1num = 65000;
13749
13750                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13751
13752                     }else{
13753                         trueFlag = false;
13754                     }
13755                 }else if(MS0->S4.unitType == 2){
13756                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13757
13758                     }else{
13759                         trueFlag = false;
13760                     }
13761                 }
13762             }else if(MS0->S4.team == 2){
13763                 if(!MS0->S4.placeFlag){
13764                 U = UTop;
13765                 while (U) {
13766                     if(U->team == 2 && !U->dead)
13767                         team2num++;
13768                     U = U->next;
13769                 }U = UTop;
13770                 }
13771                 if(MS0->S4.unitType == 0){
13772                     if(MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
13773
13774                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13775
13776                     }else{
13777                         trueFlag = false;
13778                     }
13779                 }else if(MS0->S4.unitType == 1){
13780                     if(MS0->S4.placeFlag) team2num = 65000;
13781
13782                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13783
13784                     }else{
13785                         trueFlag = false;
13786                     }
13787                 }else if(MS0->S4.unitType == 2){
13788                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13789
13790                     }else{
13791                         trueFlag = false;
13792                     }
13793                 }
13794             }
13795
13796         }
13797
13798
13799         if(MS0->S4.unitCMDflag){
13800
13801             UNIT2 *sjt = MS0->S4.subj;
13802             UNIT *chosen = NULL;
13803             UNIT *chosenT = NULL;
13804             int cntUnit = 0;
13805             bool lmao = false;
13806             while(MS0->S4.subj){
13807                 U = UTop;
13808                 while(U){
13809                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13810                         if(chosen){
13811                             chosen->next = calloc(1, sizeof(UNIT));
13812                             if(!lmao){
13813                                 chosenT = chosen;
13814                                 lmao = true;
13815                             }
13816                             chosen = chosen->next;
13817                         }
13818                         if(!chosen){
13819                             chosen = calloc(1, sizeof(UNIT));
13820                         }
13821                         chosen->x = U->x;
13822                         chosen->y = U->y;
13823                         chosen->C.name = U->C.name;
13824
13825                         if(!U->dead)
13826                             cntUnit++;
13827                     }
13828                     U = U->next;
13829                 }U = UTop;
13830                 if(!lmao){
13831                     chosenT = chosen;
13832                     lmao = true;
13833                 }
13834                 MS0->S4.subj = MS0->S4.subj->next;
13835             }MS0->S4.subj = sjt;
13836             chosen = chosenT;
13837
13838             int objeSCSunitCnt = 0;
13839
13840
13841             int Unum = 0;
13842
13843
13844             while (chosen) {
13845                 Unum++;
13846                 chosen = chosen->next;
13847             }chosen = chosenT;
13848
13849             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
13850
13851                 UNIT2 *objeT = MS0->S4.obje;
13852
13853                 while (MS0->S4.obje) {
13854
13855
13856
13857                     chosen = chosenT;
13858                     static bool okflag = true;
13859                     while(chosen){
13860                         for (int i = 0;i < 1002;i++) {
13861                             for (int k = 0;k < 1002;k++) {
13862                                 objeR[i][k] = 0;
13863                             }
13864                         }
13865
13866                         U2 = UTop;
13867                         while(U2){
13868                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13869                                 break;
13870                             }
13871                             U2 = U2->next;
13872                         }
13873
13874                         if(!U2){
13875                             U2 = UTop;
13876                             break;
13877                         }
13878
13879                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
13880
13881                         int Cnum = 0;
13882
13883                         for(int bx=1;bx<=chipWidth;bx++){
13884                             for(int by=1;by<=chipHeight;by++){
13885                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13886
13887                                     if(objeR[chosen->x][chosen->y] > 0){
13888                                         Cnum++;
13889                                         if(Unum < Cnum) goto omfgUnitOver31;
13890
13891
13892
13893
13894
13895                                         if(UP)
13896                                         {
13897                                             if(!UPT){
13898                                                 UPT = UP;
13899                                             }
13900
13901                                             UP = UPT;
13902                                             while (UP) {
13903                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13904
13905                                                     break;
13906                                                 }else{
13907                                                     okflag = true;
13908                                                 }
13909
13910                                                 UP = UP->next;
13911                                             }
13912
13913                                         }
13914                                         UP = UPT;
13915
13916                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13917                                         else if(UP){
13918                                             while(UP->next) UP = UP->next;
13919                                         }
13920                                         if(okflag){
13921                                             UP->x = chosen->x;
13922                                             UP->y = chosen->y;
13923                                             UP->next = calloc(1, sizeof(UNITPOINT));
13924                                             okflag = false;
13925                                             objeSCSunitCnt++;
13926                                         }
13927                                     }
13928
13929                                 }
13930                             }
13931                         }
13932
13933                     omfgUnitOver31:
13934                         UP = NULL;
13935                         UPT = NULL;
13936
13937                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13938
13939                         chosen = chosen->next;
13940                     }chosen = chosenT;
13941                     okflag = true;
13942                     MS0->S4.obje = MS0->S4.obje->next;
13943                 }
13944                 MS0->S4.obje = objeT;
13945             }else if(MS0->S4.objeFlag){
13946
13947                 UNIT2 *objeT = MS0->S4.obje;
13948
13949                 while (MS0->S4.obje) {
13950
13951
13952
13953                     U = UTop;
13954                     static bool okflag = true;
13955                     while(U){
13956                         if(U->team != MS0->S4.team){
13957                             U = U->next;
13958                             continue;
13959                         }
13960                         for (int i = 0;i < 1002;i++) {
13961                             for (int k = 0;k < 1002;k++) {
13962                                 objeR[i][k] = 0;
13963                             }
13964                         }
13965
13966                         U2 = UTop;
13967                         while(U2){
13968                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13969                                 break;
13970                             }
13971                             U2 = U2->next;
13972                         }
13973
13974                         if(!U2){
13975                             U2 = UTop;
13976                             break;
13977                         }
13978
13979                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
13980
13981                         int Cnum = 0;
13982
13983                         for(int bx=1;bx<=chipWidth;bx++){
13984                             for(int by=1;by<=chipHeight;by++){
13985                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13986
13987                                     if(objeR[chosen->x][chosen->y] > 0){
13988                                         Cnum++;
13989                                         if(Unum < Cnum) goto omfgUnitOver32;
13990
13991
13992
13993
13994
13995                                         if(UP)
13996                                         {
13997                                             if(!UPT){
13998                                                 UPT = UP;
13999                                             }
14000
14001                                             UP = UPT;
14002                                             while (UP) {
14003                                                 if(UP->x == chosen->x && UP->y == chosen->y){
14004
14005                                                     break;
14006                                                 }else{
14007                                                     okflag = true;
14008                                                 }
14009
14010                                                 UP = UP->next;
14011                                             }
14012
14013                                         }
14014                                         UP = UPT;
14015
14016                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
14017                                         else if(UP){
14018                                             while(UP->next) UP = UP->next;
14019                                         }
14020                                         if(okflag){
14021                                             UP->x = chosen->x;
14022                                             UP->y = chosen->y;
14023                                             UP->next = calloc(1, sizeof(UNITPOINT));
14024                                             okflag = false;
14025                                             objeSCSunitCnt++;
14026                                         }
14027                                     }
14028
14029                                 }
14030                             }
14031                         }
14032
14033                     omfgUnitOver32:
14034                         UP = NULL;
14035                         UPT = NULL;
14036
14037                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
14038
14039                         chosen = chosen->next;
14040                     }chosen = chosenT;
14041                     okflag = true;
14042                     MS0->S4.obje = MS0->S4.obje->next;
14043                 }
14044                 MS0->S4.obje = objeT;
14045                 U = UTop;
14046             }
14047
14048             if(MS0->S4.team == 0){
14049
14050                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14051
14052                 if(MS0->S4.unitCMD == 0){
14053                     if(pushStanbyFlag){
14054
14055                     }else{
14056                         trueFlag = false;
14057                     }
14058                 }else if(MS0->S4.unitCMD == 1){
14059                     if(battleSetUp){
14060                         battleSetUpIgnore = true;
14061                     }else{
14062                         trueFlag = false;
14063                     }
14064                 }else if(MS0->S4.unitCMD == 2){
14065
14066                 }
14067
14068
14069                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14070
14071
14072
14073                     BUILD2 *bldt = MS0->S4.build;
14074
14075                     while(MS0->S4.build){
14076                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14077
14078                         if(MS0->S4.unitCMD == 0){
14079                             if(pushStanbyFlag){
14080
14081                             }else{
14082                                 trueFlag = false;
14083                             }
14084                         }else if(MS0->S4.unitCMD == 1){
14085                             if(battleSetUp){
14086                                 battleSetUpIgnore = true;
14087                             }else{
14088                                 trueFlag = false;
14089
14090                             }
14091
14092                         }else if(MS0->S4.unitCMD == 2){
14093
14094
14095                         }
14096                     }else{
14097                         trueFlag = false;
14098                     }
14099                         MS0->S4.build = MS0->S4.build->next;
14100                     }MS0->S4.build = bldt;
14101
14102
14103                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14104
14105
14106                     UNIT2 *sbjt = MS0->S4.subj;
14107
14108                     while(MS0->S4.subj){
14109                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14110
14111                     if(MS0->S4.unitCMD == 0){
14112                         if(pushStanbyFlag){
14113
14114                         }else{
14115                             trueFlag = false;
14116                         }
14117                     }else if(MS0->S4.unitCMD == 1){
14118                         if(battleSetUp){
14119                             battleSetUpIgnore = true;
14120                         }else{
14121                             trueFlag = false;
14122
14123                         }
14124
14125                     }else if(MS0->S4.unitCMD == 2){
14126
14127
14128                     }
14129                     }else{
14130                         trueFlag = false;
14131                     }
14132
14133                         MS0->S4.subj = MS0->S4.subj->next;
14134                     }MS0->S4.subj = sbjt;
14135
14136
14137                 }
14138                 else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14139
14140                     UNIT2 *sbjt = MS0->S4.subj;
14141                     UNIT2 *objt = MS0->S4.obje;
14142
14143                     while(MS0->S4.subj){
14144                         while(MS0->S4.obje){
14145                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14146                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14147
14148                     if(MS0->S4.unitCMD == 0){
14149
14150                         if(MS0->S4.unitType == 0){
14151                         if(objeSCSunitCnt == MS0->S4.unitNum){
14152
14153                             if(pushStanbyFlag){
14154
14155                             }else{
14156                                 trueFlag = false;
14157                             }
14158                         }
14159
14160                         }else if(MS0->S4.unitType == 1){
14161                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14162
14163                                 if(pushStanbyFlag){
14164
14165                                 }else{
14166                                     trueFlag = false;
14167                                 }
14168                             }
14169
14170                         }else if(MS0->S4.unitType == 2){
14171                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14172
14173                                 if(pushStanbyFlag){
14174
14175                                 }else{
14176                                     trueFlag = false;
14177                                 }
14178                             }
14179                         }
14180
14181                     }else if(MS0->S4.unitCMD == 1){
14182
14183                         if(MS0->S4.unitType == 0){
14184                             if(objeSCSunitCnt == MS0->S4.unitNum){
14185
14186                                 if(battleSetUp){
14187                                     battleSetUpIgnore = true;
14188                                 }else{
14189                                     trueFlag = false;
14190                                 }
14191                             }
14192
14193                         }else if(MS0->S4.unitType == 1){
14194                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14195
14196                                 if(battleSetUp){
14197                                     battleSetUpIgnore = true;
14198                                 }else{
14199                                     trueFlag = false;
14200                                 }
14201                             }
14202
14203                         }else if(MS0->S4.unitType == 2){
14204                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14205
14206                                 if(battleSetUp){
14207                                     battleSetUpIgnore = true;
14208                                 }else{
14209                                     trueFlag = false;
14210                                 }
14211                             }
14212                         }
14213
14214                     }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14215
14216
14217                     }
14218
14219
14220
14221
14222
14223                     }else{
14224                         trueFlag = false;
14225                     }
14226                         MS0->S4.obje = MS0->S4.obje->next;
14227                         }MS0->S4.obje = objt;
14228                         MS0->S4.subj = MS0->S4.subj->next;
14229                     }MS0->S4.subj = sbjt;
14230
14231                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14232
14233
14234                     UNIT2 *sbjt = MS0->S4.subj;
14235                     BUILD2 *bldt = MS0->S4.build;
14236
14237                     while(MS0->S4.subj){
14238                         while(MS0->S4.build){
14239                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14240                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14241                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14242
14243                         if(MS0->S4.unitCMD == 0){
14244                             if(pushStanbyFlag){
14245
14246                             }else{
14247                                 trueFlag = false;
14248                             }
14249                         }else if(MS0->S4.unitCMD == 1){
14250                             if(battleSetUp){
14251                                 battleSetUpIgnore = true;
14252                             }else{
14253                                 trueFlag = false;
14254
14255                             }
14256
14257                         }else if(MS0->S4.unitCMD == 2){
14258
14259
14260                         }
14261
14262
14263                     }else{
14264                         trueFlag = false;
14265                     }
14266                         MS0->S4.build = MS0->S4.build->next;
14267                         }MS0->S4.build = bldt;
14268
14269                         MS0->S4.subj = MS0->S4.subj->next;
14270                 }
14271                    MS0->S4.subj = sbjt;
14272
14273                 }
14274             }else if(MS0->S4.team == 1){
14275                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14276
14277                     if(MS0->S4.unitCMD == 0){
14278                         if(pushStanbyFlag){
14279
14280                         }else{
14281                             trueFlag = false;
14282                         }
14283                     }else if(MS0->S4.unitCMD == 1){
14284                         if(battleSetUp){
14285                             battleSetUpIgnore = true;
14286                         }else{
14287                             trueFlag = false;
14288                         }
14289                     }else if(MS0->S4.unitCMD == 2){
14290
14291                     }
14292
14293
14294                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14295
14296
14297
14298                     BUILD2 *bldt = MS0->S4.build;
14299                     while(MS0->S4.build){
14300                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14301
14302                         if(MS0->S4.unitCMD == 0){
14303                             if(pushStanbyFlag){
14304
14305                             }else{
14306                                 trueFlag = false;
14307                             }
14308                         }else if(MS0->S4.unitCMD == 1){
14309                             if(battleSetUp){
14310                                 battleSetUpIgnore = true;
14311                             }else{
14312                                 trueFlag = false;
14313
14314                             }
14315
14316                         }else if(MS0->S4.unitCMD == 2){
14317
14318
14319                         }
14320                     }else{
14321                         trueFlag = false;
14322                     }
14323                         MS0->S4.build = MS0->S4.build->next;
14324                     }MS0->S4.build = bldt;
14325
14326
14327                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14328
14329
14330
14331                     UNIT2 *sbjt = MS0->S4.subj;
14332
14333                     while(MS0->S4.subj){
14334                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14335
14336                         if(MS0->S4.unitCMD == 0){
14337                             if(pushStanbyFlag){
14338
14339                             }else{
14340                                 trueFlag = false;
14341                             }
14342                         }else if(MS0->S4.unitCMD == 1){
14343                             if(battleSetUp){
14344                                 battleSetUpIgnore = true;
14345                             }else{
14346                                 trueFlag = false;
14347
14348                             }
14349
14350                         }else if(MS0->S4.unitCMD == 2){
14351
14352
14353                         }
14354                     }else{
14355                         trueFlag = false;
14356                     }
14357
14358                         MS0->S4.subj = MS0->S4.subj->next;
14359                     }MS0->S4.subj = sbjt;
14360
14361                 }else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14362
14363                     UNIT2 *sbjt = MS0->S4.subj;
14364                     UNIT2 *objt = MS0->S4.obje;
14365
14366                     while(MS0->S4.subj){
14367                         while(MS0->S4.obje){
14368                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14369                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14370
14371                         if(MS0->S4.unitCMD == 0){
14372
14373                             if(MS0->S4.unitType == 0){
14374                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14375
14376                                     if(pushStanbyFlag){
14377
14378                                     }else{
14379                                         trueFlag = false;
14380                                     }
14381                                 }
14382
14383                             }else if(MS0->S4.unitType == 1){
14384                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14385
14386                                     if(pushStanbyFlag){
14387
14388                                     }else{
14389                                         trueFlag = false;
14390                                     }
14391                                 }
14392
14393                             }else if(MS0->S4.unitType == 2){
14394                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14395
14396                                     if(pushStanbyFlag){
14397
14398                                     }else{
14399                                         trueFlag = false;
14400                                     }
14401                                 }
14402                             }
14403
14404                         }else if(MS0->S4.unitCMD == 1){
14405
14406                             if(MS0->S4.unitType == 0){
14407                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14408
14409                                     if(battleSetUp){
14410                                         battleSetUpIgnore = true;
14411                                     }else{
14412                                         trueFlag = false;
14413                                     }
14414                                 }
14415
14416                             }else if(MS0->S4.unitType == 1){
14417                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14418
14419                                     if(battleSetUp){
14420                                         battleSetUpIgnore = true;
14421                                     }else{
14422                                         trueFlag = false;
14423                                     }
14424                                 }
14425
14426                             }else if(MS0->S4.unitType == 2){
14427                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14428
14429                                     if(battleSetUp){
14430                                         battleSetUpIgnore = true;
14431                                     }else{
14432                                         trueFlag = false;
14433                                     }
14434                                 }
14435                             }
14436
14437                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14438
14439
14440                         }
14441
14442
14443
14444
14445                     }else{
14446                         trueFlag = false;
14447                     }
14448
14449
14450                             MS0->S4.obje = MS0->S4.obje->next;
14451                         }MS0->S4.obje = objt;
14452                         MS0->S4.subj = MS0->S4.subj->next;
14453                     }MS0->S4.subj = sbjt;
14454
14455                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14456
14457                     UNIT2 *sbjt = MS0->S4.subj;
14458                     BUILD2 *bldt = MS0->S4.build;
14459                     while(MS0->S4.subj){
14460                         while(MS0->S4.build){
14461                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14462                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14463                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14464
14465                         if(MS0->S4.unitCMD == 0){
14466                             if(pushStanbyFlag){
14467
14468                             }else{
14469                                 trueFlag = false;
14470                             }
14471                         }else if(MS0->S4.unitCMD == 1){
14472                             if(battleSetUp){
14473                                 battleSetUpIgnore = true;
14474                             }else{
14475                                 trueFlag = false;
14476
14477                             }
14478
14479                         }else if(MS0->S4.unitCMD == 2){
14480
14481
14482                         }
14483
14484
14485                     }else{
14486                         trueFlag = false;
14487                     }
14488                         MS0->S4.build = MS0->S4.build->next;
14489                         }MS0->S4.build = bldt;
14490                         MS0->S4.subj = MS0->S4.subj->next;
14491                     }MS0->S4.subj = sbjt;
14492                 }
14493             }else if(MS0->S4.team == 2){
14494                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14495
14496                     if(MS0->S4.unitCMD == 0){
14497                         if(pushStanbyFlag){
14498
14499                         }else{
14500                             trueFlag = false;
14501                         }
14502                     }else if(MS0->S4.unitCMD == 1){
14503                         if(battleSetUp){
14504                             battleSetUpIgnore = true;
14505                         }else{
14506                             trueFlag = false;
14507                         }
14508                     }else if(MS0->S4.unitCMD == 2){
14509
14510                     }
14511
14512
14513                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14514
14515
14516
14517                     BUILD2 *bldt = MS0->S4.build;
14518                     while(MS0->S4.build){
14519                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14520
14521                         if(MS0->S4.unitCMD == 0){
14522                             if(pushStanbyFlag){
14523
14524                             }else{
14525                                 trueFlag = false;
14526                             }
14527                         }else if(MS0->S4.unitCMD == 1){
14528                             if(battleSetUp){
14529                                 battleSetUpIgnore = true;
14530                             }else{
14531                                 trueFlag = false;
14532
14533                             }
14534
14535                         }else if(MS0->S4.unitCMD == 2){
14536
14537
14538                         }
14539                     }else{
14540                         trueFlag = false;
14541                     }
14542                         MS0->S4.build = MS0->S4.build->next;
14543                     }MS0->S4.build = bldt;
14544
14545
14546                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14547
14548                     UNIT2 *sbjt = MS0->S4.subj;
14549
14550                     while(MS0->S4.subj){
14551                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14552
14553                         if(MS0->S4.unitCMD == 0){
14554                             if(pushStanbyFlag){
14555
14556                             }else{
14557                                 trueFlag = false;
14558                             }
14559                         }else if(MS0->S4.unitCMD == 1){
14560                             if(battleSetUp){
14561                                 battleSetUpIgnore = true;
14562                             }else{
14563                                 trueFlag = false;
14564
14565                             }
14566
14567                         }else if(MS0->S4.unitCMD == 2){
14568
14569
14570                         }
14571                     }else{
14572                         trueFlag = false;
14573                     }
14574                       MS0->S4.subj = MS0->S4.subj->next;
14575                     }MS0->S4.subj = sbjt;
14576
14577                 }else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14578
14579                     UNIT2 *sbjt = MS0->S4.subj;
14580                     UNIT2 *objt = MS0->S4.obje;
14581
14582                     while(MS0->S4.subj){
14583                         while(MS0->S4.obje){
14584                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14585                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14586
14587                         if(MS0->S4.unitCMD == 0){
14588
14589                             if(MS0->S4.unitType == 0){
14590                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14591
14592                                     if(pushStanbyFlag){
14593
14594                                     }else{
14595                                         trueFlag = false;
14596                                     }
14597                                 }
14598
14599                             }else if(MS0->S4.unitType == 1){
14600                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14601
14602                                     if(pushStanbyFlag){
14603
14604                                     }else{
14605                                         trueFlag = false;
14606                                     }
14607                                 }
14608
14609                             }else if(MS0->S4.unitType == 2){
14610                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14611
14612                                     if(pushStanbyFlag){
14613
14614                                     }else{
14615                                         trueFlag = false;
14616                                     }
14617                                 }
14618                             }
14619
14620                         }else if(MS0->S4.unitCMD == 1){
14621
14622                             if(MS0->S4.unitType == 0){
14623                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14624
14625                                     if(battleSetUp){
14626                                         battleSetUpIgnore = true;
14627                                     }else{
14628                                         trueFlag = false;
14629                                     }
14630                                 }
14631
14632                             }else if(MS0->S4.unitType == 1){
14633                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14634
14635                                     if(battleSetUp){
14636                                         battleSetUpIgnore = true;
14637                                     }else{
14638                                         trueFlag = false;
14639                                     }
14640                                 }
14641
14642                             }else if(MS0->S4.unitType == 2){
14643                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14644
14645                                     if(battleSetUp){
14646                                         battleSetUpIgnore = true;
14647                                     }else{
14648                                         trueFlag = false;
14649                                     }
14650                                 }
14651                             }
14652
14653                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14654
14655
14656                         }
14657
14658                     }else{
14659                         trueFlag = false;
14660                     }
14661                             MS0->S4.obje = MS0->S4.obje->next;
14662                         }MS0->S4.obje = objt;
14663                         MS0->S4.subj = MS0->S4.subj->next;
14664                     }MS0->S4.subj = sbjt;
14665                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14666
14667                     UNIT2 *sbjt = MS0->S4.subj;
14668                     BUILD2 *bldt = MS0->S4.build;
14669                     while(MS0->S4.subj){
14670                         while(MS0->S4.build){
14671                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14672                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14673                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14674
14675                         if(MS0->S4.unitCMD == 0){
14676                             if(pushStanbyFlag){
14677
14678                             }else{
14679                                 trueFlag = false;
14680                             }
14681                         }else if(MS0->S4.unitCMD == 1){
14682                             if(battleSetUp){
14683                                 battleSetUpIgnore = true;
14684                             }else{
14685                                 trueFlag = false;
14686
14687                             }
14688
14689                         }else if(MS0->S4.unitCMD == 2){
14690
14691
14692                         }
14693
14694
14695                     }else{
14696                         trueFlag = false;
14697                     }
14698                         MS0->S4.build = MS0->S4.build->next;
14699                         }MS0->S4.build = bldt;
14700                         MS0->S4.subj = MS0->S4.subj->next;
14701                     }MS0->S4.subj = sbjt;
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
14727
14728
14729
14730     }
14731
14732
14733
14734
14735
14736
14737
14738
14739     branchEndFlag = true;
14740     MS0->succeessfulFlag = false;
14741     if(trueFlag){
14742         branchSuceedFlag = true;
14743         MS0->succeessfulFlag = true;
14744     }else{
14745         MS0->succeessfulFlag = false;
14746     }
14747
14748     CRMS0 = MS0;
14749     if(branchEndFlag){
14750         if(!branchSuceedFlag){
14751             MS0 = MSDPtop;
14752             while(MS0){
14753                 MS0->endFlag = false;
14754                 MS0 = MS0->next;
14755             }
14756
14757             MS0 = CRMS0;
14758             MS0->endFlag = true;
14759             MS0 = MSDPtop;
14760
14761             if([CRMS0->S4.FAILrabel isEqualToString:MS0->label] && 0){
14762                 //ここはどうやら使えない
14763                 MS0->succeessfulFlag = false;
14764                 MS0->endFlag = false;
14765             }else{
14766
14767                 while (MS0) {
14768
14769                     if(MS0->next)
14770                         if([CRMS0->S4.FAILrabel isEqualToString:MS0->next->label]){
14771
14772                             if(MS0->type == 6 && MS0->endFlag){
14773
14774                             }else{
14775                                 MS0->succeessfulFlag = true;
14776                             }
14777                             MS0->endFlag = true;
14778                             MS0 = MS0->next;
14779                             break;
14780                         }
14781                     if(MS0->type == 6 && MS0->endFlag){
14782
14783                     }else{
14784                         MS0->succeessfulFlag = true;
14785                     }
14786                     MS0->endFlag = true;
14787                     MS0 = MS0->next;
14788                 }
14789             }
14790
14791             if(!MS0){
14792                 MS0 = CRMS0;
14793                 //MS0->endFlag = true;
14794                 return MS0;
14795             }
14796
14797         }else if(branchSuceedFlag){
14798             MS0 = MSDPtop;
14799             while(MS0){
14800                 MS0->endFlag = false;
14801                 MS0 = MS0->next;
14802             }
14803
14804             MS0 = CRMS0;
14805             MS0->endFlag = true;
14806
14807             MS0 = MSDPtop;
14808
14809             if([CRMS0->S4.COMPrabel isEqualToString:MS0->label] && 0){
14810                 MS0->succeessfulFlag = false;
14811                 MS0->endFlag = false;
14812             }else{
14813
14814                 while (MS0) {
14815
14816                     if(MS0->next)
14817                         if([CRMS0->S4.COMPrabel isEqualToString:MS0->next->label]){
14818
14819                             if(MS0->type == 6 && MS0->endFlag){
14820
14821                             }else{
14822                                 MS0->succeessfulFlag = true;
14823                             }
14824                             MS0->endFlag = true;
14825                             MS0 = MS0->next;
14826                             break;
14827                         }
14828
14829                     if(MS0->type == 6 && MS0->endFlag){
14830
14831                     }else{
14832                         MS0->succeessfulFlag = true;
14833                     }
14834                     MS0->endFlag = true;
14835                     MS0 = MS0->next;
14836                 }
14837             }
14838
14839             if(!MS0){
14840                 MS0 = CRMS0;
14841                 //MS0->endFlag = true;
14842                 return MS0;
14843             }
14844         }
14845     }
14846
14847     //NSLog(@"%g", eventTime);
14848     //NSLog(@"%d", MSDPtop->succeessfulFlag);
14849     //MS0->endFlag = true;
14850
14851     MS0 = [self setEvent:MS0];
14852
14853     return MS0;
14854 }
14855
14856
14857 -(void)checkPlaceHani:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap u:(UNIT*)u scsCnt:(int*)scsCnt{
14858
14859     if(cnsPow < 0) return;
14860
14861     int i0;
14862     int *j0 = scsCnt;
14863     if(aMap[startY][startX] <= cnsPow)
14864         aMap[startY][startX] = cnsPow;
14865
14866     if(startY < 0) startY = 0;
14867     if(startX < 0) startX = 0;
14868     if(cnsPow < 0) cnsPow = 0;
14869
14870     i0 = cnsPow - 1;
14871
14872     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
14873         [self checkPlaceHani:i0 tX:startX tY:startY-1 aMap:aMap u:u scsCnt:j0];
14874
14875     i0 = cnsPow - 1;
14876     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
14877         [self checkPlaceHani:i0 tX:startX tY:startY+1 aMap:aMap u:u scsCnt:j0];
14878
14879     i0 = cnsPow - 1;
14880     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
14881         [self checkPlaceHani:i0 tX:startX-1 tY:startY aMap:aMap u:u scsCnt:j0];
14882
14883     i0 = cnsPow - 1;
14884     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
14885         [self checkPlaceHani:i0 tX:startX+1 tY:startY aMap:aMap u:u scsCnt:j0];
14886
14887
14888 }
14889
14890 -(MAPSCRIPT0*)setLabelJump:(MAPSCRIPT0*)MS0{
14891
14892     MAPSCRIPT0 *CRMS0 = MS0;
14893     MS0 = MSDPtop;
14894     while(MS0){
14895         MS0->endFlag = false;
14896         MS0 = MS0->next;
14897     }
14898     MS0 = CRMS0;
14899     MS0->endFlag = true;
14900     MS0->succeessfulFlag = true;
14901
14902     MS0 = MSDPtop;
14903
14904     if([CRMS0->labelJump isEqualToString:MS0->label]){
14905         MS0->succeessfulFlag = false;
14906         MS0->endFlag = false;
14907     }else{
14908
14909         while (MS0) {
14910
14911             if(MS0->next)
14912                 if([CRMS0->labelJump isEqualToString:MS0->next->label]){
14913                     if(MS0->type == 6 && MS0->endFlag){
14914
14915                     }else{
14916                         MS0->succeessfulFlag = true;
14917                     }
14918                     MS0->endFlag = true;
14919                     MS0 = MS0->next;
14920                     break;
14921                 }
14922             if(MS0->type == 6 && MS0->endFlag){
14923
14924             }else{
14925                 MS0->succeessfulFlag = true;
14926             }
14927             MS0->endFlag = true;
14928                 MS0 = MS0->next;
14929         }
14930     }
14931     if(!MS0){
14932         MS0 = CRMS0;
14933         return MS0;
14934     }
14935
14936     return MS0;
14937 }
14938
14939 -(MAPSCRIPT0*)setDefault:(MAPSCRIPT0*)MS0{
14940
14941     MS0->succeessfulFlag = true;
14942     MS0->endFlag = true;
14943     return MS0;
14944 }
14945
14946 -(MAPSCRIPT0*)setStatus:(MAPSCRIPT0*)MS0{
14947
14948     NSString *value = @"";
14949
14950     if(MS0->S7.valueType == 0)
14951         value = [MS0->S7.value retain];
14952     else if(MS0->S7.valueType == 1)
14953         value = [Hensuu[MS0->S7.rdm] retain];
14954
14955     if(MS0->S7.teamFlag){
14956         U = UTop;
14957         while (U) {
14958
14959             if(MS0->S7.team == U->team)
14960                 [self setStatus0:U MS0:MS0 value:value];
14961
14962             U = U->next;
14963         }U = UTop;
14964     }
14965
14966     if(MS0->S7.unitFlag){
14967         U = UTop;
14968         while (U) {
14969
14970             MAPSCRIPT7A *MS7A = MS0->S7.A;
14971             while (MS0->S7.A) {
14972
14973                 if(U->ix == MS0->S7.A->x || U->iy == MS0->S7.A->y){
14974                     [self setStatus0:U MS0:MS0 value:value];
14975                     break;
14976                 }
14977                 MS0->S7.A = MS0->S7.A->next;
14978             }MS0->S7.A = MS7A;
14979
14980             U = U->next;
14981         }U = UTop;
14982     }
14983
14984     if(MS0->S7.valueFlag){
14985         U = UTop;
14986         while (U) {
14987
14988             MAPSCRIPT7B *MS7B = MS0->S7.B;
14989             while (MS0->S7.B) {
14990
14991             if(U->ix == MS0->S7.B->x || U->iy == MS0->S7.B->y){
14992                 [self setStatus0:U MS0:MS0 value:value];
14993                 break;
14994             }
14995                 MS0->S7.B = MS0->S7.B->next;
14996             }MS0->S7.B = MS7B;
14997
14998             U = U->next;
14999         }U = UTop;
15000     }
15001
15002     MS0->succeessfulFlag = true;
15003     MS0->endFlag = true;
15004     return MS0;
15005 }
15006
15007 -(UNIT*)setStatus0:(UNIT*)U MS0:(MAPSCRIPT0*)MS0 value:(NSString*)value{
15008
15009     if(!MS0->S7.maxFlag){
15010
15011         if (!MS0->S7.percentFlag) {
15012
15013             switch (MS0->S7.type) {
15014                 case 0:
15015                     if(MS0->S7.fluctuate == 0)
15016                         U->C.S_C.HP += [value doubleValue];
15017                     else if(MS0->S7.fluctuate == 1)
15018                         U->C.S_C.HP -= [value doubleValue];
15019                     else if(MS0->S7.fluctuate == 2)
15020                         U->C.S_C.HP = [value doubleValue];
15021                     if(MS0->S7.extendFlag)
15022                     if(U->C.S_C.HP > U->C.S_M.HP)
15023                         U->C.S_C.HP = U->C.S_M.HP;
15024                     if(U->C.S_C.HP < 0)
15025                         U->C.S_C.HP = 0;
15026                     break;
15027                 case 1:
15028                     if(MS0->S7.fluctuate == 0)
15029                         U->C.S_C.MP += [value doubleValue];
15030                     else if(MS0->S7.fluctuate == 1)
15031                         U->C.S_C.MP -= [value doubleValue];
15032                     else if(MS0->S7.fluctuate == 2)
15033                         U->C.S_C.MP = [value doubleValue];
15034                     if(MS0->S7.extendFlag)
15035                     if(U->C.S_C.MP > U->C.S_M.MP)
15036                         U->C.S_C.MP = U->C.S_M.MP;
15037                     if(U->C.S_C.MP < 0)
15038                         U->C.S_C.MP = 0;
15039                     break;
15040                 case 2:
15041                     if(MS0->S7.fluctuate == 0)
15042                         U->C.S_C.WT += [value doubleValue];
15043                     else if(MS0->S7.fluctuate == 1)
15044                         U->C.S_C.WT -= [value doubleValue];
15045                     else if(MS0->S7.fluctuate == 2)
15046                         U->C.S_C.WT = [value doubleValue];
15047                     if(MS0->S7.extendFlag)
15048                     if(U->C.S_C.WT > U->C.S_M.WT)
15049                         U->C.S_C.WT = U->C.S_M.WT;
15050                     if(U->C.S_C.WT < 0)
15051                         U->C.S_C.WT = 0;
15052                     break;
15053                 case 3:
15054                     if(MS0->S7.fluctuate == 0)
15055                         U->C.S_C.STR += [value doubleValue];
15056                     else if(MS0->S7.fluctuate == 1)
15057                         U->C.S_C.STR -= [value doubleValue];
15058                     else if(MS0->S7.fluctuate == 2)
15059                         U->C.S_C.STR = [value doubleValue];
15060                     if(MS0->S7.extendFlag)
15061                     if(U->C.S_C.STR > U->C.S_M.STR)
15062                         U->C.S_C.STR = U->C.S_M.STR;
15063                     if(U->C.S_C.STR < 0)
15064                         U->C.S_C.STR = 0;
15065                     break;
15066                 case 4:
15067                     if(MS0->S7.fluctuate == 0)
15068                         U->C.S_C.VIT += [value doubleValue];
15069                     else if(MS0->S7.fluctuate == 1)
15070                         U->C.S_C.VIT -= [value doubleValue];
15071                     else if(MS0->S7.fluctuate == 2)
15072                         U->C.S_C.VIT = [value doubleValue];
15073                     if(MS0->S7.extendFlag)
15074                     if(U->C.S_C.VIT > U->C.S_M.VIT)
15075                         U->C.S_C.VIT = U->C.S_M.VIT;
15076                     if(U->C.S_C.VIT < 0)
15077                         U->C.S_C.VIT = 0;
15078                     break;
15079                 case 5:
15080                     if(MS0->S7.fluctuate == 0)
15081                         U->C.S_C.AGI += [value doubleValue];
15082                     else if(MS0->S7.fluctuate == 1)
15083                         U->C.S_C.AGI -= [value doubleValue];
15084                     else if(MS0->S7.fluctuate == 2)
15085                         U->C.S_C.AGI = [value doubleValue];
15086                     if(MS0->S7.extendFlag)
15087                     if(U->C.S_C.AGI > U->C.S_M.AGI)
15088                         U->C.S_C.AGI = U->C.S_M.AGI;
15089                     if(U->C.S_C.AGI < 0)
15090                         U->C.S_C.AGI = 0;
15091                     break;
15092                 case 6:
15093                     if(MS0->S7.fluctuate == 0)
15094                         U->C.S_C.DEX += [value doubleValue];
15095                     else if(MS0->S7.fluctuate == 1)
15096                         U->C.S_C.DEX -= [value doubleValue];
15097                     else if(MS0->S7.fluctuate == 2)
15098                         U->C.S_C.DEX = [value doubleValue];
15099                     if(MS0->S7.extendFlag)
15100                     if(U->C.S_C.DEX > U->C.S_M.DEX)
15101                         U->C.S_C.DEX = U->C.S_M.DEX;
15102                     if(U->C.S_C.DEX < 0)
15103                         U->C.S_C.DEX = 0;
15104                     break;
15105                 case 7:
15106                     if(MS0->S7.fluctuate == 0)
15107                         U->C.S_C.MEN += [value doubleValue];
15108                     else if(MS0->S7.fluctuate == 1)
15109                         U->C.S_C.MEN -= [value doubleValue];
15110                     else if(MS0->S7.fluctuate == 2)
15111                         U->C.S_C.MEN = [value doubleValue];
15112                     if(MS0->S7.extendFlag)
15113                     if(U->C.S_C.MEN > U->C.S_M.MEN)
15114                         U->C.S_C.MEN = U->C.S_M.MEN;
15115                     if(U->C.S_C.MEN < 0)
15116                         U->C.S_C.MEN = 0;
15117                     break;
15118                 case 8:
15119                     if(MS0->S7.fluctuate == 0)
15120                         U->C.S_C.INT += [value doubleValue];
15121                     else if(MS0->S7.fluctuate == 1)
15122                         U->C.S_C.INT -= [value doubleValue];
15123                     else if(MS0->S7.fluctuate == 2)
15124                         U->C.S_C.INT = [value doubleValue];
15125                     if(MS0->S7.extendFlag)
15126                     if(U->C.S_C.INT > U->C.S_M.INT)
15127                         U->C.S_C.INT = U->C.S_M.INT;
15128                     if(U->C.S_C.INT < 0)
15129                         U->C.S_C.INT = 0;
15130                     break;
15131                 case 9:
15132                     if(MS0->S7.fluctuate == 0)
15133                         U->C.S_C.LUK += [value doubleValue];
15134                     else if(MS0->S7.fluctuate == 1)
15135                         U->C.S_C.LUK -= [value doubleValue];
15136                     else if(MS0->S7.fluctuate == 2)
15137                         U->C.S_C.LUK = [value doubleValue];
15138                     if(MS0->S7.extendFlag)
15139                     if(U->C.S_C.LUK > U->C.S_M.LUK)
15140                         U->C.S_C.LUK = U->C.S_M.LUK;
15141                     if(U->C.S_C.LUK < 0)
15142                         U->C.S_C.LUK = 0;
15143                     break;
15144                 case 10:
15145                     if(MS0->S7.fluctuate == 0)
15146                         U->C.S_C.MOV += [value doubleValue];
15147                     else if(MS0->S7.fluctuate == 1)
15148                         U->C.S_C.MOV -= [value doubleValue];
15149                     else if(MS0->S7.fluctuate == 2)
15150                         U->C.S_C.MOV = [value doubleValue];
15151                     if(MS0->S7.extendFlag)
15152                     if(U->C.S_C.MOV > U->C.S_M.MOV)
15153                         U->C.S_C.MOV = U->C.S_M.MOV;
15154                     if(U->C.S_C.MOV < 0)
15155                         U->C.S_C.MOV = 0;
15156                     break;
15157                 case 11:
15158                     if(MS0->S7.fluctuate == 0)
15159                         U->C.S_C.MEL += [value doubleValue];
15160                     else if(MS0->S7.fluctuate == 1)
15161                         U->C.S_C.MEL -= [value doubleValue];
15162                     else if(MS0->S7.fluctuate == 2)
15163                         U->C.S_C.MEL = [value doubleValue];
15164                     if(MS0->S7.extendFlag)
15165                     if(U->C.S_C.MEL > U->C.S_M.MEL)
15166                         U->C.S_C.MEL = U->C.S_M.MEL;
15167                     if(U->C.S_C.MEL < 0)
15168                         U->C.S_C.MEL = 0;
15169                     break;
15170                 case 12:
15171                     if(MS0->S7.fluctuate == 0)
15172                         U->C.S_C.MIS += [value doubleValue];
15173                     else if(MS0->S7.fluctuate == 1)
15174                         U->C.S_C.MIS -= [value doubleValue];
15175                     else if(MS0->S7.fluctuate == 2)
15176                         U->C.S_C.MIS = [value doubleValue];
15177                     if(MS0->S7.extendFlag)
15178                     if(U->C.S_C.MIS > U->C.S_M.MIS)
15179                         U->C.S_C.MIS = U->C.S_M.MIS;
15180                     if(U->C.S_C.MIS < 0)
15181                         U->C.S_C.MIS = 0;
15182                     break;
15183                 case 13:
15184                     if(MS0->S7.fluctuate == 0)
15185                         U->C.S_C.HIT += [value doubleValue];
15186                     else if(MS0->S7.fluctuate == 1)
15187                         U->C.S_C.HIT -= [value doubleValue];
15188                     else if(MS0->S7.fluctuate == 2)
15189                         U->C.S_C.HIT = [value doubleValue];
15190                     if(MS0->S7.extendFlag)
15191                     if(U->C.S_C.HIT > U->C.S_M.HIT)
15192                         U->C.S_C.HIT = U->C.S_M.HIT;
15193                     if(U->C.S_C.HIT < 0)
15194                         U->C.S_C.HIT = 0;
15195                     break;
15196                 case 14:
15197                     if(MS0->S7.fluctuate == 0)
15198                         U->C.S_C.DOD += [value doubleValue];
15199                     else if(MS0->S7.fluctuate == 1)
15200                         U->C.S_C.DOD -= [value doubleValue];
15201                     else if(MS0->S7.fluctuate == 2)
15202                         U->C.S_C.DOD = [value doubleValue];
15203                     if(MS0->S7.extendFlag)
15204                     if(U->C.S_C.DOD > U->C.S_M.DOD)
15205                         U->C.S_C.DOD = U->C.S_M.DOD;
15206                     if(U->C.S_C.DOD < 0)
15207                         U->C.S_C.DOD = 0;
15208                     break;
15209                 case 15:
15210                     if(MS0->S7.fluctuate == 0)
15211                         U->C.S_C.REA += [value doubleValue];
15212                     else if(MS0->S7.fluctuate == 1)
15213                         U->C.S_C.REA -= [value doubleValue];
15214                     else if(MS0->S7.fluctuate == 2)
15215                         U->C.S_C.REA = [value doubleValue];
15216                     if(MS0->S7.extendFlag)
15217                     if(U->C.S_C.REA > U->C.S_M.REA)
15218                         U->C.S_C.REA = U->C.S_M.REA;
15219                     if(U->C.S_C.REA < 0)
15220                         U->C.S_C.REA = 0;
15221                     break;
15222                 case 16:
15223                     if(MS0->S7.fluctuate == 0)
15224                         U->C.S_C.SKI += [value doubleValue];
15225                     else if(MS0->S7.fluctuate == 1)
15226                         U->C.S_C.SKI -= [value doubleValue];
15227                     else if(MS0->S7.fluctuate == 2)
15228                         U->C.S_C.SKI = [value doubleValue];
15229                     if(MS0->S7.extendFlag)
15230                     if(U->C.S_C.SKI > U->C.S_M.SKI)
15231                         U->C.S_C.SKI = U->C.S_M.SKI;
15232                     if(U->C.S_C.SKI < 0)
15233                         U->C.S_C.SKI = 0;
15234                     break;
15235                 case 17:
15236                     U->C.name =  [value retain];
15237                     break;
15238                 case 18:
15239                     U->C.nameNick =  [value retain];
15240                     break;
15241                 case 19:
15242                     U->C.nameClass =  [value retain];
15243                     break;
15244                 case 20:
15245                     U->C.S_C.typeMONS =  [value doubleValue];
15246                     break;
15247                 case 21:
15248                     U->C.S_C.typeMOVE =  [value doubleValue];
15249                     break;
15250                 case 22:
15251                     if(MS0->S7.fluctuate == 0)
15252                         U->C.S_C.cSupply += [value doubleValue];
15253                     else if(MS0->S7.fluctuate == 1)
15254                         U->C.S_C.cSupply -= [value doubleValue];
15255                     else if(MS0->S7.fluctuate == 2)
15256                         U->C.S_C.cSupply = [value doubleValue];
15257                     if(MS0->S7.extendFlag)
15258                     if(U->C.S_C.cSupply > U->C.S_M.cSupply)
15259                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15260                     if(U->C.S_C.cSupply < 0)
15261                         U->C.S_C.cSupply = 0;
15262                     break;
15263                 case 23:
15264                     if(MS0->S7.fluctuate == 0)
15265                         U->C.S_C.cFood += [value doubleValue];
15266                     else if(MS0->S7.fluctuate == 1)
15267                         U->C.S_C.cFood -= [value doubleValue];
15268                     else if(MS0->S7.fluctuate == 2)
15269                         U->C.S_C.cFood = [value doubleValue];
15270                     if(MS0->S7.extendFlag)
15271                     if(U->C.S_C.cFood > U->C.S_M.cFood)
15272                         U->C.S_C.cFood = U->C.S_M.cFood;
15273                     if(U->C.S_C.cFood < 0)
15274                         U->C.S_C.cFood = 0;
15275                     break;
15276                 case 24:
15277                     if(MS0->S7.fluctuate == 0)
15278                         U->C.S_C.cMoney += [value doubleValue];
15279                     else if(MS0->S7.fluctuate == 1)
15280                         U->C.S_C.cMoney -= [value doubleValue];
15281                     else if(MS0->S7.fluctuate == 2)
15282                         U->C.S_C.cMoney = [value doubleValue];
15283                     if(MS0->S7.extendFlag)
15284                     if(U->C.S_C.cMoney > U->C.S_M.cMoney)
15285                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15286                     if(U->C.S_C.cMoney < 0)
15287                         U->C.S_C.cMoney = 0;
15288                     break;
15289                 case 25:
15290                     if(MS0->S7.fluctuate == 0)
15291                         U->C.S_C.cWT += [value doubleValue];
15292                     else if(MS0->S7.fluctuate == 1)
15293                         U->C.S_C.cWT -= [value doubleValue];
15294                     else if(MS0->S7.fluctuate == 2)
15295                         U->C.S_C.cWT = [value doubleValue];
15296                     if(MS0->S7.extendFlag)
15297                         if(U->C.S_C.cWT > U->C.S_M.cWT)
15298                             U->C.S_C.cWT = U->C.S_M.cWT;
15299                     if(U->C.S_C.cWT < 0)
15300                         U->C.S_C.cWT = 0;
15301                     break;
15302                 case 26:
15303                     if(MS0->S7.fluctuate == 0)
15304                         U->C.S_C.vigor += [value doubleValue];
15305                     else if(MS0->S7.fluctuate == 1)
15306                         U->C.S_C.vigor -= [value doubleValue];
15307                     else if(MS0->S7.fluctuate == 2)
15308                         U->C.S_C.vigor = [value doubleValue];
15309                     if(MS0->S7.extendFlag)
15310                         if(U->C.S_C.vigor > U->C.S_M.vigor)
15311                             U->C.S_C.vigor = U->C.S_M.vigor;
15312                     if(U->C.S_C.vigor < 0)
15313                         U->C.S_C.vigor = 0;
15314                     break;
15315
15316                 default:
15317                     break;
15318             }
15319
15320         }else{
15321
15322             switch (MS0->S7.type) {
15323                 case 0:
15324                     if(MS0->S7.fluctuate == 0)
15325                         U->C.S_C.HP += U->C.S_M.HP*[value doubleValue]/100;
15326                     else if(MS0->S7.fluctuate == 1)
15327                         U->C.S_C.HP -= U->C.S_M.HP*[value doubleValue]/100;
15328                     else if(MS0->S7.fluctuate == 2)
15329                         U->C.S_C.HP = U->C.S_M.HP*[value doubleValue]/100;
15330                     if(MS0->S7.extendFlag)
15331                     if(U->C.S_C.HP > U->C.S_M.HP)
15332                         U->C.S_C.HP = U->C.S_M.HP;
15333                     if(U->C.S_C.HP < 0)
15334                         U->C.S_C.HP = 0;
15335                     break;
15336                 case 1:
15337                     if(MS0->S7.fluctuate == 0)
15338                         U->C.S_C.MP += U->C.S_M.MP*[value doubleValue]/100;
15339                     else if(MS0->S7.fluctuate == 1)
15340                         U->C.S_C.MP -= U->C.S_M.MP*[value doubleValue]/100;
15341                     else if(MS0->S7.fluctuate == 2)
15342                         U->C.S_C.MP = U->C.S_M.MP*[value doubleValue]/100;
15343                     if(MS0->S7.extendFlag)
15344                     if(U->C.S_C.MP > U->C.S_M.MP)
15345                         U->C.S_C.MP = U->C.S_M.MP;
15346                     if(U->C.S_C.MP < 0)
15347                         U->C.S_C.MP = 0;
15348                     break;
15349                 case 2:
15350                     if(MS0->S7.fluctuate == 0)
15351                         U->C.S_C.WT += U->C.S_M.WT*[value doubleValue]/100;
15352                     else if(MS0->S7.fluctuate == 1)
15353                         U->C.S_C.WT -= U->C.S_M.WT*[value doubleValue]/100;
15354                     else if(MS0->S7.fluctuate == 2)
15355                         U->C.S_C.MP = U->C.S_M.WT*[value doubleValue]/100;
15356                     if(MS0->S7.extendFlag)
15357                     if(U->C.S_C.WT > U->C.S_M.WT)
15358                         U->C.S_C.WT = U->C.S_M.WT;
15359                     if(U->C.S_C.WT < 0)
15360                         U->C.S_C.WT = 0;
15361                     break;
15362                 case 3:
15363                     if(MS0->S7.fluctuate == 0)
15364                         U->C.S_C.STR += U->C.S_M.STR*[value doubleValue]/100;
15365                     else if(MS0->S7.fluctuate == 1)
15366                         U->C.S_C.STR -= U->C.S_M.STR*[value doubleValue]/100;
15367                     else if(MS0->S7.fluctuate == 2)
15368                         U->C.S_C.STR = U->C.S_M.STR*[value doubleValue]/100;
15369                     if(MS0->S7.extendFlag)
15370                     if(U->C.S_C.STR > U->C.S_M.STR)
15371                         U->C.S_C.STR = U->C.S_M.STR;
15372                     if(U->C.S_C.STR < 0)
15373                         U->C.S_C.STR = 0;
15374                     break;
15375                 case 4:
15376                     if(MS0->S7.fluctuate == 0)
15377                         U->C.S_C.VIT += U->C.S_M.VIT*[value doubleValue]/100;
15378                     else if(MS0->S7.fluctuate == 1)
15379                         U->C.S_C.VIT -= U->C.S_M.VIT*[value doubleValue]/100;
15380                     else if(MS0->S7.fluctuate == 2)
15381                         U->C.S_C.VIT = U->C.S_M.VIT*[value doubleValue]/100;
15382                     if(MS0->S7.extendFlag)
15383                     if(U->C.S_C.VIT > U->C.S_M.VIT)
15384                         U->C.S_C.VIT = U->C.S_M.VIT;
15385                     if(U->C.S_C.VIT < 0)
15386                         U->C.S_C.VIT = 0;
15387                     break;
15388                 case 5:
15389                     if(MS0->S7.fluctuate == 0)
15390                         U->C.S_C.AGI += U->C.S_M.AGI*[value doubleValue]/100;
15391                     else if(MS0->S7.fluctuate == 1)
15392                         U->C.S_C.AGI -= U->C.S_M.AGI*[value doubleValue]/100;
15393                     else if(MS0->S7.fluctuate == 2)
15394                         U->C.S_C.AGI = U->C.S_M.AGI*[value doubleValue]/100;
15395                     if(MS0->S7.extendFlag)
15396                     if(U->C.S_C.AGI > U->C.S_M.AGI)
15397                         U->C.S_C.AGI = U->C.S_M.AGI;
15398                     if(U->C.S_C.AGI < 0)
15399                         U->C.S_C.AGI = 0;
15400                     break;
15401                 case 6:
15402                     if(MS0->S7.fluctuate == 0)
15403                         U->C.S_C.DEX += U->C.S_M.DEX*[value doubleValue]/100;
15404                     else if(MS0->S7.fluctuate == 1)
15405                         U->C.S_C.DEX -= U->C.S_M.DEX*[value doubleValue]/100;
15406                     else if(MS0->S7.fluctuate == 2)
15407                         U->C.S_C.DEX = U->C.S_M.DEX*[value doubleValue]/100;
15408                     if(MS0->S7.extendFlag)
15409                     if(U->C.S_C.DEX > U->C.S_M.DEX)
15410                         U->C.S_C.DEX = U->C.S_M.DEX;
15411                     if(U->C.S_C.DEX < 0)
15412                         U->C.S_C.DEX = 0;
15413                     break;
15414                 case 7:
15415                     if(MS0->S7.fluctuate == 0)
15416                         U->C.S_C.MEN += U->C.S_M.MEN*[value doubleValue]/100;
15417                     else if(MS0->S7.fluctuate == 1)
15418                         U->C.S_C.MEN -= U->C.S_M.MEN*[value doubleValue]/100;
15419                     else if(MS0->S7.fluctuate == 2)
15420                         U->C.S_C.MEN = U->C.S_M.MEN*[value doubleValue]/100;
15421                     if(MS0->S7.extendFlag)
15422                     if(U->C.S_C.MEN > U->C.S_M.MEN)
15423                         U->C.S_C.MEN = U->C.S_M.MEN;
15424                     if(U->C.S_C.MEN < 0)
15425                         U->C.S_C.MEN = 0;
15426                     break;
15427                 case 8:
15428                     if(MS0->S7.fluctuate == 0)
15429                         U->C.S_C.INT += U->C.S_M.INT*[value doubleValue]/100;
15430                     else if(MS0->S7.fluctuate == 1)
15431                         U->C.S_C.INT -= U->C.S_M.INT*[value doubleValue]/100;
15432                     else if(MS0->S7.fluctuate == 2)
15433                         U->C.S_C.INT = U->C.S_M.INT*[value doubleValue]/100;
15434                     if(MS0->S7.extendFlag)
15435                     if(U->C.S_C.INT > U->C.S_M.INT)
15436                         U->C.S_C.INT = U->C.S_M.INT;
15437                     if(U->C.S_C.INT < 0)
15438                         U->C.S_C.INT = 0;
15439                     break;
15440                 case 9:
15441                     if(MS0->S7.fluctuate == 0)
15442                         U->C.S_C.LUK += U->C.S_M.LUK*[value doubleValue]/100;
15443                     else if(MS0->S7.fluctuate == 1)
15444                         U->C.S_C.LUK -= U->C.S_M.LUK*[value doubleValue]/100;
15445                     else if(MS0->S7.fluctuate == 2)
15446                         U->C.S_C.LUK = U->C.S_M.LUK*[value doubleValue]/100;
15447                     if(MS0->S7.extendFlag)
15448                     if(U->C.S_C.LUK > U->C.S_M.LUK)
15449                         U->C.S_C.LUK = U->C.S_M.LUK;
15450                     if(U->C.S_C.LUK < 0)
15451                         U->C.S_C.LUK = 0;
15452                     break;
15453                 case 10:
15454                     if(MS0->S7.fluctuate == 0)
15455                         U->C.S_C.MOV += U->C.S_M.MOV*[value doubleValue]/100;
15456                     else if(MS0->S7.fluctuate == 1)
15457                         U->C.S_C.MOV -= U->C.S_M.MOV*[value doubleValue]/100;
15458                     else if(MS0->S7.fluctuate == 2)
15459                         U->C.S_C.MOV = U->C.S_M.MOV*[value doubleValue]/100;
15460                     if(MS0->S7.extendFlag)
15461                     if(U->C.S_C.MOV > U->C.S_M.MOV)
15462                         U->C.S_C.MOV = U->C.S_M.MOV;
15463                     if(U->C.S_C.MOV < 0)
15464                         U->C.S_C.MOV = 0;
15465                     break;
15466                 case 11:
15467                     if(MS0->S7.fluctuate == 0)
15468                         U->C.S_C.MEL += U->C.S_M.MEL*[value doubleValue]/100;
15469                     else if(MS0->S7.fluctuate == 1)
15470                         U->C.S_C.MEL -= U->C.S_M.MEL*[value doubleValue]/100;
15471                     else if(MS0->S7.fluctuate == 2)
15472                         U->C.S_C.MEL = U->C.S_M.MEL*[value doubleValue]/100;
15473                     if(MS0->S7.extendFlag)
15474                     if(U->C.S_C.MEL > U->C.S_M.MEL)
15475                         U->C.S_C.MEL = U->C.S_M.MEL;
15476                     if(U->C.S_C.MEL < 0)
15477                         U->C.S_C.MEL = 0;
15478                     break;
15479                 case 12:
15480                     if(MS0->S7.fluctuate == 0)
15481                         U->C.S_C.MIS += U->C.S_M.MIS*[value doubleValue]/100;
15482                     else if(MS0->S7.fluctuate == 1)
15483                         U->C.S_C.MIS -= U->C.S_M.MIS*[value doubleValue]/100;
15484                     else if(MS0->S7.fluctuate == 2)
15485                         U->C.S_C.MIS = U->C.S_M.MIS*[value doubleValue]/100;
15486                     if(MS0->S7.extendFlag)
15487                     if(U->C.S_C.MIS > U->C.S_M.MIS)
15488                         U->C.S_C.MIS = U->C.S_M.MIS;
15489                     if(U->C.S_C.MIS < 0)
15490                         U->C.S_C.MIS = 0;
15491                     break;
15492                 case 13:
15493                     if(MS0->S7.fluctuate == 0)
15494                         U->C.S_C.HIT += U->C.S_M.HIT*[value doubleValue]/100;
15495                     else if(MS0->S7.fluctuate == 1)
15496                         U->C.S_C.HIT -= U->C.S_M.HIT*[value doubleValue]/100;
15497                     else if(MS0->S7.fluctuate == 2)
15498                         U->C.S_C.HIT = U->C.S_M.HIT*[value doubleValue]/100;
15499                     if(MS0->S7.extendFlag)
15500                     if(U->C.S_C.HIT > U->C.S_M.HIT)
15501                         U->C.S_C.HIT = U->C.S_M.HIT;
15502                     if(U->C.S_C.HIT < 0)
15503                         U->C.S_C.HIT = 0;
15504                     break;
15505                 case 14:
15506                     if(MS0->S7.fluctuate == 0)
15507                         U->C.S_C.DOD += U->C.S_M.DOD*[value doubleValue]/100;
15508                     else if(MS0->S7.fluctuate == 1)
15509                         U->C.S_C.DOD -= U->C.S_M.DOD*[value doubleValue]/100;
15510                     else if(MS0->S7.fluctuate == 2)
15511                         U->C.S_C.DOD = U->C.S_M.DOD*[value doubleValue]/100;
15512                     if(MS0->S7.extendFlag)
15513                     if(U->C.S_C.HIT > U->C.S_M.DOD)
15514                         U->C.S_C.DOD = U->C.S_M.DOD;
15515                     if(U->C.S_C.DOD < 0)
15516                         U->C.S_C.DOD = 0;
15517                     break;
15518                 case 15:
15519                     if(MS0->S7.fluctuate == 0)
15520                         U->C.S_C.REA += U->C.S_M.REA*[value doubleValue]/100;
15521                     else if(MS0->S7.fluctuate == 1)
15522                         U->C.S_C.REA -= U->C.S_M.REA*[value doubleValue]/100;
15523                     else if(MS0->S7.fluctuate == 2)
15524                         U->C.S_C.REA = U->C.S_M.REA*[value doubleValue]/100;
15525                     if(MS0->S7.extendFlag)
15526                     if(U->C.S_C.REA > U->C.S_M.REA)
15527                         U->C.S_C.REA = U->C.S_M.REA;
15528                     if(U->C.S_C.REA < 0)
15529                         U->C.S_C.REA = 0;
15530                     break;
15531                 case 16:
15532                     if(MS0->S7.fluctuate == 0)
15533                         U->C.S_C.SKI += U->C.S_M.SKI*[value doubleValue]/100;
15534                     else if(MS0->S7.fluctuate == 1)
15535                         U->C.S_C.SKI -= U->C.S_M.SKI*[value doubleValue]/100;
15536                     else if(MS0->S7.fluctuate == 2)
15537                         U->C.S_C.SKI = U->C.S_M.SKI*[value doubleValue]/100;
15538                     if(MS0->S7.extendFlag)
15539                     if(U->C.S_C.SKI > U->C.S_M.SKI)
15540                         U->C.S_C.SKI = U->C.S_M.SKI;
15541                     if(U->C.S_C.SKI < 0)
15542                         U->C.S_C.SKI = 0;
15543                     break;
15544                 case 17:
15545                     U->C.name =  [MS0->S7.value retain];
15546                     break;
15547                 case 18:
15548                     U->C.nameNick =  [MS0->S7.value retain];
15549                     break;
15550                 case 19:
15551                     U->C.nameClass =  [MS0->S7.value retain];
15552                     break;
15553                 case 20:
15554                     U->C.S_C.typeMONS =  [MS0->S7.value doubleValue];
15555                     break;
15556                 case 21:
15557                     U->C.S_C.typeMOVE =  [MS0->S7.value doubleValue];
15558                     break;
15559                 case 22:
15560                     if(MS0->S7.fluctuate == 0)
15561                         U->C.S_C.cSupply += U->C.S_M.cSupply*[value doubleValue]/100;
15562                     else if(MS0->S7.fluctuate == 1)
15563                         U->C.S_C.cSupply -= U->C.S_M.cSupply*[value doubleValue]/100;
15564                     else if(MS0->S7.fluctuate == 2)
15565                         U->C.S_C.cSupply = U->C.S_M.cSupply*[value doubleValue]/100;
15566                     if(MS0->S7.extendFlag)
15567                     if(U->C.S_C.cSupply > U->C.S_M.cSupply)
15568                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15569                     if(U->C.S_C.cSupply < 0)
15570                         U->C.S_C.cSupply = 0;
15571                     break;
15572                 case 23:
15573                     if(MS0->S7.fluctuate == 0)
15574                         U->C.S_C.cFood += U->C.S_M.cFood*[value doubleValue]/100;
15575                     else if(MS0->S7.fluctuate == 1)
15576                         U->C.S_C.cFood -= U->C.S_M.cFood*[value doubleValue]/100;
15577                     else if(MS0->S7.fluctuate == 2)
15578                         U->C.S_C.cFood = U->C.S_M.cFood*[value doubleValue]/100;
15579                     if(MS0->S7.extendFlag)
15580                     if(U->C.S_C.cFood > U->C.S_M.cFood)
15581                         U->C.S_C.cFood = U->C.S_M.cFood;
15582                     if(U->C.S_C.cFood < 0)
15583                         U->C.S_C.cFood = 0;
15584                     break;
15585                 case 24:
15586                     if(MS0->S7.fluctuate == 0)
15587                         U->C.S_C.cMoney += U->C.S_M.cMoney*[value doubleValue]/100;
15588                     else if(MS0->S7.fluctuate == 1)
15589                         U->C.S_C.cMoney -= U->C.S_M.cMoney*[value doubleValue]/100;
15590                     else if(MS0->S7.fluctuate == 2)
15591                         U->C.S_C.cMoney = U->C.S_M.cMoney*[value doubleValue]/100;
15592                     if(MS0->S7.extendFlag)
15593                     if(U->C.S_C.cMoney > U->C.S_M.cMoney)
15594                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15595                     if(U->C.S_C.cMoney < 0)
15596                         U->C.S_C.cMoney = 0;
15597                     break;
15598                 case 25:
15599                     if(MS0->S7.fluctuate == 0)
15600                         U->C.S_C.cWT += U->C.S_M.cWT*[value doubleValue]/100;
15601                     else if(MS0->S7.fluctuate == 1)
15602                         U->C.S_C.cWT -= U->C.S_M.cWT*[value doubleValue]/100;
15603                     else if(MS0->S7.fluctuate == 2)
15604                         U->C.S_C.cWT = U->C.S_M.cWT*[value doubleValue]/100;
15605                     if(MS0->S7.extendFlag)
15606                     if(U->C.S_C.cWT > U->C.S_M.cWT)
15607                         U->C.S_C.cWT = U->C.S_M.cWT;
15608                     if(U->C.S_C.cWT < 0)
15609                         U->C.S_C.cWT = 0;
15610                     break;
15611                 case 26:
15612                     if(MS0->S7.fluctuate == 0)
15613                         U->C.S_C.vigor += U->C.S_M.vigor*[value doubleValue]/100;
15614                     else if(MS0->S7.fluctuate == 1)
15615                         U->C.S_C.vigor -= U->C.S_M.vigor*[value doubleValue]/100;
15616                     else if(MS0->S7.fluctuate == 2)
15617                         U->C.S_C.vigor = U->C.S_M.vigor*[value doubleValue]/100;
15618                     if(MS0->S7.extendFlag)
15619                         if(U->C.S_C.vigor > U->C.S_M.vigor)
15620                             U->C.S_C.vigor = U->C.S_M.vigor;
15621                     if(U->C.S_C.vigor < 0)
15622                         U->C.S_C.vigor = 0;
15623                     break;
15624                 default:
15625                     break;
15626             }
15627         }
15628
15629     }else{
15630
15631         if (!MS0->S7.percentFlag) {
15632
15633             switch (MS0->S7.type) {
15634                 case 0:
15635                     if(MS0->S7.fluctuate == 0)
15636                         U->C.S_M.HP += [value doubleValue];
15637                     else if(MS0->S7.fluctuate == 1)
15638                         U->C.S_M.HP -= [value doubleValue];
15639                     else if(MS0->S7.fluctuate == 2)
15640                         U->C.S_M.HP = [value doubleValue];
15641
15642                     if(U->C.S_M.HP < 0)
15643                         U->C.S_M.HP = 0;
15644                     if(MS0->S7.extendFlag)
15645                         U->C.S_C.HP = U->C.S_M.HP;
15646                     break;
15647                 case 1:
15648                     if(MS0->S7.fluctuate == 0)
15649                         U->C.S_M.MP += [value doubleValue];
15650                     else if(MS0->S7.fluctuate == 1)
15651                         U->C.S_M.MP -= [value doubleValue];
15652                     else if(MS0->S7.fluctuate == 2)
15653                         U->C.S_M.MP = [value doubleValue];
15654
15655                     if(U->C.S_M.MP < 0)
15656                         U->C.S_M.MP = 0;
15657                     if(MS0->S7.extendFlag)
15658                         U->C.S_C.MP = U->C.S_M.MP;
15659                     break;
15660                 case 2:
15661                     if(MS0->S7.fluctuate == 0)
15662                         U->C.S_M.WT += [value doubleValue];
15663                     else if(MS0->S7.fluctuate == 1)
15664                         U->C.S_M.WT -= [value doubleValue];
15665                     else if(MS0->S7.fluctuate == 2)
15666                         U->C.S_M.WT = [value doubleValue];
15667
15668                     if(U->C.S_M.WT < 0)
15669                         U->C.S_M.WT = 0;
15670                     if(MS0->S7.extendFlag)
15671                         U->C.S_C.WT = U->C.S_M.WT;
15672                     break;
15673                 case 3:
15674                     if(MS0->S7.fluctuate == 0)
15675                         U->C.S_M.STR += [value doubleValue];
15676                     else if(MS0->S7.fluctuate == 1)
15677                         U->C.S_M.STR -= [value doubleValue];
15678                     else if(MS0->S7.fluctuate == 2)
15679                         U->C.S_M.STR = [value doubleValue];
15680
15681                     if(U->C.S_M.STR < 0)
15682                         U->C.S_M.STR = 0;
15683                     if(MS0->S7.extendFlag)
15684                         U->C.S_C.STR = U->C.S_M.STR;
15685                     break;
15686                 case 4:
15687                     if(MS0->S7.fluctuate == 0)
15688                         U->C.S_M.VIT += [value doubleValue];
15689                     else if(MS0->S7.fluctuate == 1)
15690                         U->C.S_M.VIT -= [value doubleValue];
15691                     else if(MS0->S7.fluctuate == 2)
15692                         U->C.S_M.VIT = [value doubleValue];
15693
15694                     if(U->C.S_M.VIT < 0)
15695                         U->C.S_M.VIT = 0;
15696                     if(MS0->S7.extendFlag)
15697                         U->C.S_C.VIT = U->C.S_M.VIT;
15698                     break;
15699                 case 5:
15700                     if(MS0->S7.fluctuate == 0)
15701                         U->C.S_M.AGI += [value doubleValue];
15702                     else if(MS0->S7.fluctuate == 1)
15703                         U->C.S_M.AGI -= [value doubleValue];
15704                     else if(MS0->S7.fluctuate == 2)
15705                         U->C.S_M.AGI = [value doubleValue];
15706
15707                     if(U->C.S_M.AGI < 0)
15708                         U->C.S_M.AGI = 0;
15709                     if(MS0->S7.extendFlag)
15710                         U->C.S_C.AGI = U->C.S_M.AGI;
15711                     break;
15712                 case 6:
15713                     if(MS0->S7.fluctuate == 0)
15714                         U->C.S_M.DEX += [value doubleValue];
15715                     else if(MS0->S7.fluctuate == 1)
15716                         U->C.S_M.DEX -= [value doubleValue];
15717                     else if(MS0->S7.fluctuate == 2)
15718                         U->C.S_M.DEX = [value doubleValue];
15719
15720                     if(U->C.S_M.DEX < 0)
15721                         U->C.S_M.DEX = 0;
15722                     if(MS0->S7.extendFlag)
15723                         U->C.S_C.DEX = U->C.S_M.DEX;
15724                     break;
15725                 case 7:
15726                     if(MS0->S7.fluctuate == 0)
15727                         U->C.S_M.MEN += [value doubleValue];
15728                     else if(MS0->S7.fluctuate == 1)
15729                         U->C.S_M.MEN -= [value doubleValue];
15730                     else if(MS0->S7.fluctuate == 2)
15731                         U->C.S_M.MEN = [value doubleValue];
15732
15733                     if(U->C.S_M.MEN < 0)
15734                         U->C.S_M.MEN = 0;
15735                     if(MS0->S7.extendFlag)
15736                         U->C.S_C.MEN = U->C.S_M.MEN;
15737                     break;
15738                 case 8:
15739                     if(MS0->S7.fluctuate == 0)
15740                         U->C.S_M.INT += [value doubleValue];
15741                     else if(MS0->S7.fluctuate == 1)
15742                         U->C.S_M.INT -= [value doubleValue];
15743                     else if(MS0->S7.fluctuate == 2)
15744                         U->C.S_M.INT = [value doubleValue];
15745
15746                     if(U->C.S_M.INT < 0)
15747                         U->C.S_M.INT = 0;
15748                     if(MS0->S7.extendFlag)
15749                         U->C.S_C.INT = U->C.S_M.INT;
15750                     break;
15751                 case 9:
15752                     if(MS0->S7.fluctuate == 0)
15753                         U->C.S_M.LUK += [value doubleValue];
15754                     else if(MS0->S7.fluctuate == 1)
15755                         U->C.S_M.LUK -= [value doubleValue];
15756                     else if(MS0->S7.fluctuate == 2)
15757                         U->C.S_M.LUK = [value doubleValue];
15758
15759                     if(U->C.S_M.LUK < 0)
15760                         U->C.S_M.LUK = 0;
15761                     if(MS0->S7.extendFlag)
15762                         U->C.S_C.LUK = U->C.S_M.LUK;
15763                     break;
15764                 case 10:
15765                     if(MS0->S7.fluctuate == 0)
15766                         U->C.S_M.MOV += [value doubleValue];
15767                     else if(MS0->S7.fluctuate == 1)
15768                         U->C.S_M.MOV -= [value doubleValue];
15769                     else if(MS0->S7.fluctuate == 2)
15770                         U->C.S_M.MOV = [value doubleValue];
15771
15772                     if(U->C.S_M.MOV < 0)
15773                         U->C.S_M.MOV = 0;
15774                     if(MS0->S7.extendFlag)
15775                         U->C.S_C.MOV = U->C.S_M.MOV;
15776                     break;
15777                 case 11:
15778                     if(MS0->S7.fluctuate == 0)
15779                         U->C.S_M.MEL += [value doubleValue];
15780                     else if(MS0->S7.fluctuate == 1)
15781                         U->C.S_M.MEL -= [value doubleValue];
15782                     else if(MS0->S7.fluctuate == 2)
15783                         U->C.S_M.MEL = [value doubleValue];
15784
15785                     if(U->C.S_M.MEL < 0)
15786                         U->C.S_M.MEL = 0;
15787                     if(MS0->S7.extendFlag)
15788                         U->C.S_C.MEL = U->C.S_M.MEL;
15789                     break;
15790                 case 12:
15791                     if(MS0->S7.fluctuate == 0)
15792                         U->C.S_M.MIS += [value doubleValue];
15793                     else if(MS0->S7.fluctuate == 1)
15794                         U->C.S_M.MIS -= [value doubleValue];
15795                     else if(MS0->S7.fluctuate == 2)
15796                         U->C.S_M.MIS = [value doubleValue];
15797
15798                     if(U->C.S_M.MIS < 0)
15799                         U->C.S_M.MIS = 0;
15800                     if(MS0->S7.extendFlag)
15801                         U->C.S_C.MIS = U->C.S_M.MIS;
15802
15803                     break;
15804                 case 13:
15805                     if(MS0->S7.fluctuate == 0)
15806                         U->C.S_M.HIT += [value doubleValue];
15807                     else if(MS0->S7.fluctuate == 1)
15808                         U->C.S_M.HIT -= [value doubleValue];
15809                     else if(MS0->S7.fluctuate == 2)
15810                         U->C.S_M.HIT = [value doubleValue];
15811
15812                     if(U->C.S_M.HIT < 0)
15813                         U->C.S_M.HIT = 0;
15814                     if(MS0->S7.extendFlag)
15815                         U->C.S_C.HIT = U->C.S_M.HIT;
15816                     break;
15817                 case 14:
15818                     if(MS0->S7.fluctuate == 0)
15819                         U->C.S_M.DOD += [value doubleValue];
15820                     else if(MS0->S7.fluctuate == 1)
15821                         U->C.S_M.DOD -= [value doubleValue];
15822                     else if(MS0->S7.fluctuate == 2)
15823                         U->C.S_M.DOD = [value doubleValue];
15824
15825                     if(U->C.S_M.DOD < 0)
15826                         U->C.S_M.DOD = 0;
15827                     if(MS0->S7.extendFlag)
15828                         U->C.S_C.DOD = U->C.S_M.DOD;
15829                     break;
15830                 case 15:
15831                     if(MS0->S7.fluctuate == 0)
15832                         U->C.S_M.REA += [value doubleValue];
15833                     else if(MS0->S7.fluctuate == 1)
15834                         U->C.S_M.REA -= [value doubleValue];
15835                     else if(MS0->S7.fluctuate == 2)
15836                         U->C.S_M.REA = [value doubleValue];
15837
15838                     if(U->C.S_M.REA < 0)
15839                         U->C.S_M.REA = 0;
15840                     if(MS0->S7.extendFlag)
15841                         U->C.S_C.REA = U->C.S_M.REA;
15842                     break;
15843                 case 16:
15844                     if(MS0->S7.fluctuate == 0)
15845                         U->C.S_M.SKI += [value doubleValue];
15846                     else if(MS0->S7.fluctuate == 1)
15847                         U->C.S_M.SKI -= [value doubleValue];
15848                     else if(MS0->S7.fluctuate == 2)
15849                         U->C.S_M.SKI = [value doubleValue];
15850
15851                     if(U->C.S_M.SKI < 0)
15852                         U->C.S_M.SKI = 0;
15853                     if(MS0->S7.extendFlag)
15854                         U->C.S_C.SKI = U->C.S_M.SKI;
15855                     break;
15856                 case 17:
15857                     U->C.name =  [value retain];
15858                     break;
15859                 case 18:
15860                     U->C.nameNick =  [value retain];
15861                     break;
15862                 case 19:
15863                     U->C.nameClass =  [value retain];
15864                     break;
15865                 case 20:
15866                     U->C.S_C.typeMONS =  [value doubleValue];
15867                     break;
15868                 case 21:
15869                     U->C.S_C.typeMOVE =  [value doubleValue];
15870                     break;
15871                 case 22:
15872                     if(MS0->S7.fluctuate == 0)
15873                         U->C.S_M.cSupply += [value doubleValue];
15874                     else if(MS0->S7.fluctuate == 1)
15875                         U->C.S_M.cSupply -= [value doubleValue];
15876                     else if(MS0->S7.fluctuate == 2)
15877                         U->C.S_M.cSupply = [value doubleValue];
15878
15879                     if(U->C.S_M.cSupply < 0)
15880                         U->C.S_M.cSupply = 0;
15881                     if(MS0->S7.extendFlag)
15882                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15883                     break;
15884                 case 23:
15885                     if(MS0->S7.fluctuate == 0)
15886                         U->C.S_M.cFood += [value doubleValue];
15887                     else if(MS0->S7.fluctuate == 1)
15888                         U->C.S_M.cFood -= [value doubleValue];
15889                     else if(MS0->S7.fluctuate == 2)
15890                         U->C.S_M.cFood = [value doubleValue];
15891
15892                     if(U->C.S_M.cFood < 0)
15893                         U->C.S_M.cFood = 0;
15894                     if(MS0->S7.extendFlag)
15895                         U->C.S_C.cFood = U->C.S_M.cFood;
15896                     break;
15897                 case 24:
15898                     if(MS0->S7.fluctuate == 0)
15899                         U->C.S_M.cMoney += [value doubleValue];
15900                     else if(MS0->S7.fluctuate == 1)
15901                         U->C.S_M.cMoney -= [value doubleValue];
15902                     else if(MS0->S7.fluctuate == 2)
15903                         U->C.S_M.cMoney = [value doubleValue];
15904                     if(U->C.S_M.cMoney < 0)
15905                         U->C.S_M.cMoney = 0;
15906                     if(MS0->S7.extendFlag)
15907                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15908                     break;
15909                 case 25:
15910                     if(MS0->S7.fluctuate == 0)
15911                         U->C.S_M.cWT += [value doubleValue];
15912                     else if(MS0->S7.fluctuate == 1)
15913                         U->C.S_M.cWT -= [value doubleValue];
15914                     else if(MS0->S7.fluctuate == 2)
15915                         U->C.S_M.cWT = [value doubleValue];
15916                     if(U->C.S_M.cWT < 0)
15917                         U->C.S_M.cWT = 0;
15918                     if(MS0->S7.extendFlag)
15919                         U->C.S_C.cWT = U->C.S_M.cWT;
15920                     break;
15921                 case 26:
15922                     if(MS0->S7.fluctuate == 0)
15923                         U->C.S_M.vigor += [value doubleValue];
15924                     else if(MS0->S7.fluctuate == 1)
15925                         U->C.S_M.vigor -= [value doubleValue];
15926                     else if(MS0->S7.fluctuate == 2)
15927                         U->C.S_M.vigor = [value doubleValue];
15928                     if(U->C.S_M.vigor < 0)
15929                         U->C.S_M.vigor = 0;
15930                     if(MS0->S7.extendFlag)
15931                         U->C.S_C.vigor = U->C.S_M.vigor;
15932                     break;
15933
15934                 default:
15935                     break;
15936             }
15937
15938         }else{
15939
15940             switch (MS0->S7.type) {
15941                 case 0:
15942                     if(MS0->S7.fluctuate == 0)
15943                         U->C.S_M.HP += U->C.S_M.HP*[value doubleValue]/100;
15944                     else if(MS0->S7.fluctuate == 1)
15945                         U->C.S_M.HP -= U->C.S_M.HP*[value doubleValue]/100;
15946                     else if(MS0->S7.fluctuate == 2)
15947                         U->C.S_M.HP = U->C.S_M.HP*[value doubleValue]/100;
15948
15949                     if(U->C.S_M.HP < 0)
15950                         U->C.S_M.HP = 0;
15951                     if(MS0->S7.extendFlag)
15952                         U->C.S_C.HP = U->C.S_M.HP;
15953                     break;
15954                 case 1:
15955                     if(MS0->S7.fluctuate == 0)
15956                         U->C.S_M.MP += U->C.S_M.MP*[value doubleValue]/100;
15957                     else if(MS0->S7.fluctuate == 1)
15958                         U->C.S_M.MP -= U->C.S_M.MP*[value doubleValue]/100;
15959                     else if(MS0->S7.fluctuate == 2)
15960                         U->C.S_M.MP = U->C.S_M.MP*[value doubleValue]/100;
15961
15962                     if(U->C.S_M.MP < 0)
15963                         U->C.S_M.MP = 0;
15964                     if(MS0->S7.extendFlag)
15965                         U->C.S_C.MP = U->C.S_M.MP;
15966                     break;
15967                 case 2:
15968                     if(MS0->S7.fluctuate == 0)
15969                         U->C.S_M.WT += U->C.S_M.WT*[value doubleValue]/100;
15970                     else if(MS0->S7.fluctuate == 1)
15971                         U->C.S_M.WT -= U->C.S_M.WT*[value doubleValue]/100;
15972                     else if(MS0->S7.fluctuate == 2)
15973                         U->C.S_M.MP = U->C.S_M.WT*[value doubleValue]/100;
15974
15975                     if(U->C.S_M.WT < 0)
15976                         U->C.S_M.WT = 0;
15977                     if(MS0->S7.extendFlag)
15978                         U->C.S_C.WT = U->C.S_M.WT;
15979                     break;
15980                 case 3:
15981                     if(MS0->S7.fluctuate == 0)
15982                         U->C.S_M.STR += U->C.S_M.STR*[value doubleValue]/100;
15983                     else if(MS0->S7.fluctuate == 1)
15984                         U->C.S_M.STR -= U->C.S_M.STR*[value doubleValue]/100;
15985                     else if(MS0->S7.fluctuate == 2)
15986                         U->C.S_M.STR = U->C.S_M.STR*[value doubleValue]/100;
15987
15988                     if(U->C.S_M.STR < 0)
15989                         U->C.S_M.STR = 0;
15990                     if(MS0->S7.extendFlag)
15991                         U->C.S_C.STR = U->C.S_M.STR;
15992                     break;
15993                 case 4:
15994                     if(MS0->S7.fluctuate == 0)
15995                         U->C.S_M.VIT += U->C.S_M.VIT*[value doubleValue]/100;
15996                     else if(MS0->S7.fluctuate == 1)
15997                         U->C.S_M.VIT -= U->C.S_M.VIT*[value doubleValue]/100;
15998                     else if(MS0->S7.fluctuate == 2)
15999                         U->C.S_M.VIT = U->C.S_M.VIT*[value doubleValue]/100;
16000
16001                     if(U->C.S_M.VIT < 0)
16002                         U->C.S_M.VIT = 0;
16003                     if(MS0->S7.extendFlag)
16004                         U->C.S_C.VIT = U->C.S_M.VIT;
16005                     break;
16006                 case 5:
16007                     if(MS0->S7.fluctuate == 0)
16008                         U->C.S_M.AGI += U->C.S_M.AGI*[value doubleValue]/100;
16009                     else if(MS0->S7.fluctuate == 1)
16010                         U->C.S_M.AGI -= U->C.S_M.AGI*[value doubleValue]/100;
16011                     else if(MS0->S7.fluctuate == 2)
16012                         U->C.S_M.AGI = U->C.S_M.AGI*[value doubleValue]/100;
16013
16014                     if(U->C.S_M.AGI < 0)
16015                         U->C.S_M.AGI = 0;
16016                     if(MS0->S7.extendFlag)
16017                         U->C.S_C.AGI = U->C.S_M.AGI;
16018                     break;
16019                 case 6:
16020                     if(MS0->S7.fluctuate == 0)
16021                         U->C.S_M.DEX += U->C.S_M.DEX*[value doubleValue]/100;
16022                     else if(MS0->S7.fluctuate == 1)
16023                         U->C.S_M.DEX -= U->C.S_M.DEX*[value doubleValue]/100;
16024                     else if(MS0->S7.fluctuate == 2)
16025                         U->C.S_M.DEX = U->C.S_M.DEX*[value doubleValue]/100;
16026
16027                     if(U->C.S_M.DEX < 0)
16028                         U->C.S_M.DEX = 0;
16029                     if(MS0->S7.extendFlag)
16030                         U->C.S_C.DEX = U->C.S_M.DEX;
16031                     break;
16032                 case 7:
16033                     if(MS0->S7.fluctuate == 0)
16034                         U->C.S_M.MEN += U->C.S_M.MEN*[value doubleValue]/100;
16035                     else if(MS0->S7.fluctuate == 1)
16036                         U->C.S_M.MEN -= U->C.S_M.MEN*[value doubleValue]/100;
16037                     else if(MS0->S7.fluctuate == 2)
16038                         U->C.S_M.MEN = U->C.S_M.MEN*[value doubleValue]/100;
16039
16040                     if(U->C.S_M.MEN < 0)
16041                         U->C.S_M.MEN = 0;
16042                     if(MS0->S7.extendFlag)
16043                         U->C.S_C.MEN = U->C.S_M.MEN;
16044                     break;
16045                 case 8:
16046                     if(MS0->S7.fluctuate == 0)
16047                         U->C.S_M.INT += U->C.S_M.INT*[value doubleValue]/100;
16048                     else if(MS0->S7.fluctuate == 1)
16049                         U->C.S_M.INT -= U->C.S_M.INT*[value doubleValue]/100;
16050                     else if(MS0->S7.fluctuate == 2)
16051                         U->C.S_M.INT = U->C.S_M.INT*[value doubleValue]/100;
16052
16053                     if(U->C.S_M.INT < 0)
16054                         U->C.S_M.INT = 0;
16055                     if(MS0->S7.extendFlag)
16056                         U->C.S_C.INT = U->C.S_M.INT;
16057                     break;
16058                 case 9:
16059                     if(MS0->S7.fluctuate == 0)
16060                         U->C.S_M.LUK += U->C.S_M.LUK*[value doubleValue]/100;
16061                     else if(MS0->S7.fluctuate == 1)
16062                         U->C.S_M.LUK -= U->C.S_M.LUK*[value doubleValue]/100;
16063                     else if(MS0->S7.fluctuate == 2)
16064                         U->C.S_M.LUK = U->C.S_M.LUK*[value doubleValue]/100;
16065
16066                     if(U->C.S_M.LUK < 0)
16067                         U->C.S_M.LUK = 0;
16068                     if(MS0->S7.extendFlag)
16069                         U->C.S_C.LUK = U->C.S_M.LUK;
16070                     break;
16071                 case 10:
16072                     if(MS0->S7.fluctuate == 0)
16073                         U->C.S_M.MOV += U->C.S_M.MOV*[value doubleValue]/100;
16074                     else if(MS0->S7.fluctuate == 1)
16075                         U->C.S_M.MOV -= U->C.S_M.MOV*[value doubleValue]/100;
16076                     else if(MS0->S7.fluctuate == 2)
16077                         U->C.S_M.MOV = U->C.S_M.MOV*[value doubleValue]/100;
16078
16079                     if(U->C.S_M.MOV < 0)
16080                         U->C.S_M.MOV = 0;
16081                     if(MS0->S7.extendFlag)
16082                         U->C.S_C.MOV = U->C.S_M.MOV;
16083                     break;
16084                 case 11:
16085                     if(MS0->S7.fluctuate == 0)
16086                         U->C.S_M.MEL += U->C.S_M.MEL*[value doubleValue]/100;
16087                     else if(MS0->S7.fluctuate == 1)
16088                         U->C.S_M.MEL -= U->C.S_M.MEL*[value doubleValue]/100;
16089                     else if(MS0->S7.fluctuate == 2)
16090                         U->C.S_M.MEL = U->C.S_M.MEL*[value doubleValue]/100;
16091
16092                     if(U->C.S_C.MEL < 0)
16093                         U->C.S_M.MEL = 0;
16094                     if(MS0->S7.extendFlag)
16095                         U->C.S_C.MEL = U->C.S_M.MEL;
16096                     break;
16097                 case 12:
16098                     if(MS0->S7.fluctuate == 0)
16099                         U->C.S_C.MIS += U->C.S_M.MIS*[value doubleValue]/100;
16100                     else if(MS0->S7.fluctuate == 1)
16101                         U->C.S_C.MIS -= U->C.S_M.MIS*[value doubleValue]/100;
16102                     else if(MS0->S7.fluctuate == 2)
16103                         U->C.S_C.MIS = U->C.S_M.MIS*[value doubleValue]/100;
16104
16105                     if(U->C.S_C.MIS < 0)
16106                         U->C.S_C.MIS = 0;
16107                     if(MS0->S7.extendFlag)
16108                         U->C.S_C.MIS = U->C.S_M.MIS;
16109                     break;
16110                 case 13:
16111                     if(MS0->S7.fluctuate == 0)
16112                         U->C.S_M.HIT += U->C.S_M.HIT*[value doubleValue]/100;
16113                     else if(MS0->S7.fluctuate == 1)
16114                         U->C.S_M.HIT -= U->C.S_M.HIT*[value doubleValue]/100;
16115                     else if(MS0->S7.fluctuate == 2)
16116                         U->C.S_M.HIT = U->C.S_M.HIT*[value doubleValue]/100;
16117
16118                     if(U->C.S_M.HIT < 0)
16119                         U->C.S_M.HIT = 0;
16120                     if(MS0->S7.extendFlag)
16121                         U->C.S_C.HIT = U->C.S_M.HIT;
16122                     break;
16123                 case 14:
16124                     if(MS0->S7.fluctuate == 0)
16125                         U->C.S_M.DOD += U->C.S_M.DOD*[value doubleValue]/100;
16126                     else if(MS0->S7.fluctuate == 1)
16127                         U->C.S_M.DOD -= U->C.S_M.DOD*[value doubleValue]/100;
16128                     else if(MS0->S7.fluctuate == 2)
16129                         U->C.S_M.DOD = U->C.S_M.DOD*[value doubleValue]/100;
16130
16131                     if(U->C.S_M.DOD < 0)
16132                         U->C.S_M.DOD = 0;
16133                     if(MS0->S7.extendFlag)
16134                         U->C.S_C.DOD = U->C.S_M.DOD;
16135                     break;
16136                 case 15:
16137                     if(MS0->S7.fluctuate == 0)
16138                         U->C.S_M.REA += U->C.S_M.REA*[value doubleValue]/100;
16139                     else if(MS0->S7.fluctuate == 1)
16140                         U->C.S_M.REA -= U->C.S_M.REA*[value doubleValue]/100;
16141                     else if(MS0->S7.fluctuate == 2)
16142                         U->C.S_M.REA = U->C.S_M.REA*[value doubleValue]/100;
16143
16144                     if(U->C.S_M.REA < 0)
16145                         U->C.S_M.REA = 0;
16146                     if(MS0->S7.extendFlag)
16147                         U->C.S_C.REA = U->C.S_M.REA;
16148                     break;
16149                 case 16:
16150                     if(MS0->S7.fluctuate == 0)
16151                         U->C.S_M.SKI += U->C.S_M.SKI*[value doubleValue]/100;
16152                     else if(MS0->S7.fluctuate == 1)
16153                         U->C.S_M.SKI -= U->C.S_M.SKI*[value doubleValue]/100;
16154                     else if(MS0->S7.fluctuate == 2)
16155                         U->C.S_M.SKI = U->C.S_M.SKI*[value doubleValue]/100;
16156
16157                     if(U->C.S_M.SKI < 0)
16158                         U->C.S_M.SKI = 0;
16159                     if(MS0->S7.extendFlag)
16160                         U->C.S_C.SKI = U->C.S_M.SKI;
16161                     break;
16162                 case 17:
16163                     U->C.name =  [MS0->S7.value retain];
16164                     break;
16165                 case 18:
16166                     U->C.nameNick =  [MS0->S7.value retain];
16167                     break;
16168                 case 19:
16169                     U->C.nameClass =  [MS0->S7.value retain];
16170                     break;
16171                 case 20:
16172                     U->C.S_C.typeMONS =  [MS0->S7.value doubleValue];
16173                     break;
16174                 case 21:
16175                     U->C.S_C.typeMOVE =  [MS0->S7.value doubleValue];
16176                     break;
16177                 case 22:
16178                     if(MS0->S7.fluctuate == 0)
16179                         U->C.S_M.cSupply += U->C.S_M.cSupply*[value doubleValue]/100;
16180                     else if(MS0->S7.fluctuate == 1)
16181                         U->C.S_M.cSupply -= U->C.S_M.cSupply*[value doubleValue]/100;
16182                     else if(MS0->S7.fluctuate == 2)
16183                         U->C.S_M.cSupply = U->C.S_M.cSupply*[value doubleValue]/100;
16184
16185                     if(U->C.S_M.cSupply < 0)
16186                         U->C.S_M.cSupply = 0;
16187                     if(MS0->S7.extendFlag)
16188                         U->C.S_C.cSupply = U->C.S_M.cSupply;
16189                     break;
16190                 case 23:
16191                     if(MS0->S7.fluctuate == 0)
16192                         U->C.S_M.cFood += U->C.S_M.cFood*[value doubleValue]/100;
16193                     else if(MS0->S7.fluctuate == 1)
16194                         U->C.S_M.cFood -= U->C.S_M.cFood*[value doubleValue]/100;
16195                     else if(MS0->S7.fluctuate == 2)
16196                         U->C.S_M.cFood = U->C.S_M.cFood*[value doubleValue]/100;
16197
16198
16199                     if(U->C.S_M.cFood < 0)
16200                         U->C.S_M.cFood = 0;
16201                     if(MS0->S7.extendFlag)
16202                         U->C.S_C.cFood = U->C.S_M.cFood;
16203                     break;
16204                 case 24:
16205                     if(MS0->S7.fluctuate == 0)
16206                         U->C.S_M.cMoney += U->C.S_M.cMoney*[value doubleValue]/100;
16207                     else if(MS0->S7.fluctuate == 1)
16208                         U->C.S_M.cMoney -= U->C.S_M.cMoney*[value doubleValue]/100;
16209                     else if(MS0->S7.fluctuate == 2)
16210                         U->C.S_M.cMoney = U->C.S_M.cMoney*[value doubleValue]/100;
16211
16212                     if(U->C.S_M.cMoney < 0)
16213                         U->C.S_M.cMoney = 0;
16214                     if(MS0->S7.extendFlag)
16215                         U->C.S_C.cMoney = U->C.S_M.cMoney;
16216                     break;
16217                 case 25:
16218                     if(MS0->S7.fluctuate == 0)
16219                         U->C.S_M.cWT += U->C.S_M.cWT*[value doubleValue]/100;
16220                     else if(MS0->S7.fluctuate == 1)
16221                         U->C.S_M.cWT -= U->C.S_M.cWT*[value doubleValue]/100;
16222                     else if(MS0->S7.fluctuate == 2)
16223                         U->C.S_M.cWT = U->C.S_M.cWT*[value doubleValue]/100;
16224
16225                     if(U->C.S_M.cWT < 0)
16226                         U->C.S_M.cWT = 0;
16227                     if(MS0->S7.extendFlag)
16228                         U->C.S_C.cWT = U->C.S_M.cWT;
16229                     break;
16230                 case 26:
16231                     if(MS0->S7.fluctuate == 0)
16232                         U->C.S_M.vigor += U->C.S_M.vigor*[value doubleValue]/100;
16233                     else if(MS0->S7.fluctuate == 1)
16234                         U->C.S_M.vigor -= U->C.S_M.vigor*[value doubleValue]/100;
16235                     else if(MS0->S7.fluctuate == 2)
16236                         U->C.S_M.vigor = U->C.S_M.vigor*[value doubleValue]/100;
16237
16238                     if(U->C.S_M.vigor < 0)
16239                         U->C.S_M.vigor = 0;
16240                     if(MS0->S7.extendFlag)
16241                         U->C.S_C.vigor = U->C.S_M.vigor;
16242                     break;
16243
16244                 default:
16245                     break;
16246             }
16247         }
16248     }
16249
16250     return U;
16251 }
16252
16253
16254 -(MAPSCRIPT0*)setResource:(MAPSCRIPT0*)MS0{
16255
16256     if(MS0->S6.team == 0){
16257
16258         if(MS0->S6.RCsupply){
16259             if(MS0->S6.RCsupplyS){
16260                 if(MS0->S6.RCsupplyAdd)
16261                     P[0].resource += MS0->S6.RCsupplyValue;
16262                 else
16263                     P[0].resource -= MS0->S6.RCsupplyValue;
16264             }else{
16265                 if(MS0->S6.RCsupplyAdd)
16266                     P[0].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16267                 else
16268                     P[0].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16269             }
16270         }
16271         if(MS0->S6.RCfood){
16272             if(MS0->S6.RCfoodS){
16273                 if(MS0->S6.RCfoodAdd)
16274                     P[0].food += MS0->S6.RCfoodValue;
16275                 else
16276                     P[0].food -= MS0->S6.RCfoodValue;
16277             }else{
16278                 if(MS0->S6.RCfoodAdd)
16279                     P[0].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16280                 else
16281                     P[0].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16282             }
16283         }
16284         if(MS0->S6.RCmoney){
16285             if(MS0->S6.RCmoneyS){
16286                 if(MS0->S6.RCmoneyAdd)
16287                     P[0].money += MS0->S6.RCmoneyValue;
16288                 else
16289                     P[0].money -= MS0->S6.RCmoneyValue;
16290             }else{
16291                 if(MS0->S6.RCmoneyAdd)
16292                     P[0].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16293                 else
16294                     P[0].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16295             }
16296         }
16297
16298     }else if(MS0->S6.team == 1){
16299         if(MS0->S6.RCsupply){
16300         if(MS0->S6.RCsupplyS){
16301             if(MS0->S6.RCsupplyAdd)
16302                 P[1].resource += MS0->S6.RCsupplyValue;
16303             else
16304                 P[1].resource -= MS0->S6.RCsupplyValue;
16305         }else{
16306             if(MS0->S6.RCsupplyAdd)
16307                 P[1].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16308             else
16309                 P[1].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16310         }
16311         }
16312     if(MS0->S6.RCfood){
16313         if(MS0->S6.RCfoodS){
16314             if(MS0->S6.RCfoodAdd)
16315                 P[1].food += MS0->S6.RCfoodValue;
16316             else
16317                 P[1].food -= MS0->S6.RCfoodValue;
16318         }else{
16319             if(MS0->S6.RCfoodAdd)
16320                 P[1].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16321             else
16322                 P[1].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16323         }
16324     }
16325     if(MS0->S6.RCmoney){
16326         if(MS0->S6.RCmoneyS){
16327             if(MS0->S6.RCmoneyAdd)
16328                 P[1].money += MS0->S6.RCmoneyValue;
16329             else
16330                 P[1].money -= MS0->S6.RCmoneyValue;
16331         }else{
16332             if(MS0->S6.RCmoneyAdd)
16333                 P[1].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16334             else
16335                 P[1].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16336         }
16337     }
16338     }else if(MS0->S6.team == 2){
16339         if(MS0->S6.RCsupply){
16340         if(MS0->S6.RCsupplyS){
16341             if(MS0->S6.RCsupplyAdd)
16342                 P[2].resource += MS0->S6.RCsupplyValue;
16343             else
16344                 P[2].resource -= MS0->S6.RCsupplyValue;
16345         }else{
16346             if(MS0->S6.RCsupplyAdd)
16347                 P[2].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16348             else
16349                 P[2].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16350         }
16351         }
16352
16353     if(MS0->S6.RCfood){
16354         if(MS0->S6.RCfoodS){
16355             if(MS0->S6.RCfoodAdd)
16356                 P[2].food += MS0->S6.RCfoodValue;
16357             else
16358                 P[2].food -= MS0->S6.RCfoodValue;
16359         }else{
16360             if(MS0->S6.RCfoodAdd)
16361                 P[2].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16362             else
16363                 P[2].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16364         }
16365     }
16366     if(MS0->S6.RCmoney){
16367         if(MS0->S6.RCmoneyS){
16368             if(MS0->S6.RCmoneyAdd)
16369                 P[2].money += MS0->S6.RCmoneyValue;
16370             else
16371                 P[2].money -= MS0->S6.RCmoneyValue;
16372         }else{
16373             if(MS0->S6.RCmoneyAdd)
16374                 P[2].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16375             else
16376                 P[2].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16377         }
16378     }
16379     }
16380
16381     if(P[0].resource < 0) P[0].resource = 0;
16382     if(P[1].resource < 0) P[1].resource = 0;
16383     if(P[2].resource < 0) P[2].resource = 0;
16384
16385     if(P[0].food < 0) P[0].food = 0;
16386     if(P[1].food < 0) P[1].food = 0;
16387     if(P[2].food < 0) P[2].food = 0;
16388
16389     if(P[0].money < 0) P[0].money = 0;
16390     if(P[1].money < 0) P[1].money = 0;
16391     if(P[2].money < 0) P[2].money = 0;
16392
16393     MS0->succeessfulFlag = true;
16394     MS0->endFlag = true;
16395     return MS0;
16396 }
16397
16398 -(MAPSCRIPT0*)setLabel:(MAPSCRIPT0*)MS0{
16399
16400     //NSLog(@"%d", MSDP0top->succeessfulFlag);
16401     MS0->succeessfulFlag = true;
16402     MS0->endFlag = true;
16403     return MS0;
16404 }
16405
16406 -(MAPSCRIPT0*)setComment:(MAPSCRIPT0*)MS0{
16407
16408     MS0->succeessfulFlag = true;
16409     MS0->endFlag = true;
16410     return MS0;
16411 }
16412
16413
16414 -(MAPSCRIPT0*)setSelection:(MAPSCRIPT0*)MS0{
16415
16416     static bool initFlag = false;
16417
16418     if(!initFlag){
16419         initFlag = true;
16420
16421         MAPSCRIPT2 *MS2top = MS0->S2;
16422
16423         slctPoint.x = [mapWindow frame].origin.x + 100;
16424         slctPoint.y = [mapWindow frame].origin.y + 300;
16425
16426         [slctBtn1 setHidden:YES];
16427         [slctBtn2 setHidden:YES];
16428         [slctBtn3 setHidden:YES];
16429         [slctBtn4 setHidden:YES];
16430         [slctBtn5 setHidden:YES];
16431         [slctBtn6 setHidden:YES];
16432         [slctBtn7 setHidden:YES];
16433         [slctBtn8 setHidden:YES];
16434         [slctBtn9 setHidden:YES];
16435
16436         for(int i = 1;MS0->S2;i++){
16437
16438             if(i == 1){
16439                 [slctBtn1 setTitle:MS0->S2->selection];
16440                 [slctBtn1 setHidden:NO];
16441                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 60) display:YES];
16442             }
16443             if(i == 2){
16444                 [slctBtn2 setTitle:MS0->S2->selection];
16445                 [slctBtn2 setHidden:NO];
16446                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 90) display:YES];
16447             }
16448             if(i == 3){
16449                 [slctBtn3 setTitle:MS0->S2->selection];
16450                 [slctBtn3 setHidden:NO];
16451                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 120) display:YES];
16452             }
16453
16454             if(i == 4){
16455                 [slctBtn4 setTitle:MS0->S2->selection];
16456                 [slctBtn4 setHidden:NO];
16457                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 150) display:YES];
16458             }
16459             if(i == 5){
16460                 [slctBtn5 setTitle:MS0->S2->selection];
16461                 [slctBtn5 setHidden:NO];
16462                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 180) display:YES];
16463             }
16464             if(i == 6){
16465                 [slctBtn6 setTitle:MS0->S2->selection];
16466                 [slctBtn6 setHidden:NO];
16467                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 210) display:YES];
16468             }
16469             if(i == 7){
16470                 [slctBtn7 setTitle:MS0->S2->selection];
16471                 [slctBtn7 setHidden:NO];
16472                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 240) display:YES];
16473             }
16474             if(i == 8){
16475                 [slctBtn8 setTitle:MS0->S2->selection];
16476                 [slctBtn8 setHidden:NO];
16477                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 270) display:YES];
16478             }
16479             if(i == 9){
16480                 [slctBtn9 setTitle:MS0->S2->selection];
16481                 [slctBtn9 setHidden:NO];
16482                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 300) display:YES];
16483             }
16484             slctBtnNum = i;
16485             if(slctBtnNum > 9)
16486                 slctBtnNum = 9;
16487             MS0->S2 = MS0->S2->next;
16488         }
16489         MS0->S2 = MS2top;
16490
16491
16492
16493         [selectionWindow makeKeyAndOrderFront:nil];
16494     }
16495
16496
16497     if(slctedBtnNum > 0){
16498         MAPSCRIPT0 *CRMS0 = MS0;
16499
16500         MS0 = MSDPtop;
16501         while(MS0){
16502             MS0->endFlag = false;
16503             MS0 = MS0->next;
16504         }MS0 = CRMS0;
16505
16506         MAPSCRIPT2 *MS2top = MS0->S2;
16507         MAPSCRIPT2 *CRMS2;
16508
16509         for(int i = 1;i < slctedBtnNum;i++){
16510             MS0->S2 = MS0->S2->next;
16511         }
16512             CRMS2 = MS0->S2;
16513
16514         MS0->S2 = MS2top;
16515
16516         MS0 = MSDPtop;
16517         if([CRMS2->labelJump isEqualToString:MS0->label]){
16518             MS0->endFlag = false;
16519         }else{
16520
16521             while (MS0) {
16522
16523                 if(MS0->next)
16524                     if([CRMS2->labelJump isEqualToString:MS0->next->label]){
16525                         if(MS0->type == 6 && MS0->endFlag){
16526
16527                         }else{
16528                             MS0->succeessfulFlag = true;
16529                         }
16530                         MS0->endFlag = true;
16531                         MS0 = MS0->next;
16532                         break;
16533                     }
16534                 if(MS0->type == 6 && MS0->endFlag){
16535
16536                 }else{
16537                     MS0->succeessfulFlag = true;
16538                 }
16539                 MS0->endFlag = true;
16540                 MS0 = MS0->next;
16541             }
16542         }
16543         if(!MS0){
16544             MS0 = CRMS0;
16545             return MS0;
16546         }
16547
16548         MS0->endFlag = true;
16549         MS0->succeessfulFlag = true;
16550         initFlag = false;
16551         slctedBtnNum = 0;
16552         }
16553
16554     return MS0;
16555 }
16556
16557 -(MAPSCRIPT0*)setAppearance:(MAPSCRIPT0*)MS0{
16558
16559     MS3T = MS0->S3;
16560     while(MS0->S3){
16561         int x, y;
16562         UNITCHIP u;
16563         u = MS0->S3->U;
16564         x = MS0->S3->x;
16565         y = MS0->S3->y;
16566
16567         if(unitNum[x][y] == -1){
16568
16569             if(MS0->S3->flag){
16570
16571
16572             }else{
16573                 unitTeam[x][y] = MS0->S3->team;
16574                 unitNum[x][y] = u.chipNumb;
16575                 loadNum[x][y] = u.chipNumb;
16576                 [self addAppearanceStatus:u x:x y:y];
16577             }
16578         }else{
16579
16580             if(MS0->S3->flag){
16581
16582
16583             }else{
16584                 int *p = calloc(1, sizeof(int));
16585                 int *o = calloc(1, sizeof(int));
16586                 appearanceSAIKIflag = false;
16587                 wtflag = 0;
16588
16589                 for (int i = 0;i < 1002;i++) {
16590                     for (int k = 0;k < 1002;k++) {
16591                         apprR[i][k] = 0;
16592                     }
16593                 }
16594
16595                 [self checkAppearanceRange:5 tX:y tY:x aMap:apprR];
16596
16597                 int postInt = 0;
16598                 for (int i = 0;i < 1002;i++) {
16599                     for (int k = 0;k < 1002;k++) {
16600                         if(apprR[i][k] > postInt && unitNum[i][k] == -1){
16601                             postInt = apprR[i][k];
16602                             *p = i;
16603                             *o = k;
16604                         }
16605                     }
16606                 }
16607
16608                 if(*p > 0 && *o >0){
16609                     x = *p;
16610                     y = *o;
16611                     unitTeam[x][y] = MS0->S3->team;
16612                     unitNum[x][y] = u.chipNumb;
16613                     loadNum[x][y] = u.chipNumb;
16614                     [self addAppearanceStatus:u x:x y:y];
16615                 }else{
16616                     MS0->succeessfulFlag = false;
16617                     MS0->endFlag = true;
16618                     MS0->S3 = MS3T;
16619                     return MS0;
16620                 }
16621             }
16622         }
16623         MS0->S3 = MS0->S3->next;
16624     }MS0->S3 = MS3T;
16625     unitColorInitFlag = true;
16626
16627     MS0->succeessfulFlag = true;
16628     MS0->endFlag = true;
16629     return MS0;
16630 }
16631
16632 -(MAPSCRIPT0*)setDissappearance:(MAPSCRIPT0*)MS0{
16633
16634     MS5T = MS0->S5;
16635     while(MS0->S5){
16636         int x, y;
16637         UNITCHIP u;
16638         u = MS0->S5->U;
16639         x = MS0->S5->x;
16640         y = MS0->S5->y;
16641
16642         if(1){
16643
16644
16645             if(MS0->S5->unitNum >= 0){
16646                 unitNum[x][y] = -1;
16647                 unitTeam[x][y] = -1;
16648                 unitNum[x][y] = -1;
16649                 loadNum[x][y] = -1;
16650
16651                 U = UTop;
16652                 while(U){
16653                     if(U->ix == x && U->iy == y)
16654                         break;
16655                     U = U->next;
16656                 }
16657                 if(U)
16658                     U->dead = true;
16659
16660                 U = UTop;
16661
16662             }else{
16663                 MS0->succeessfulFlag = false;
16664                 MS0->endFlag = true;
16665                 MS0->S5 = MS5T;
16666                 return MS0;
16667             }
16668
16669         }
16670         MS0->S5 = MS0->S5->next;
16671     }MS0->S5 = MS5T;
16672     unitColorInitFlag = true;
16673
16674     MS0->succeessfulFlag = true;
16675     MS0->endFlag = true;
16676     return MS0;
16677 }
16678
16679
16680 -(void)checkAppearanceRange:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap{
16681
16682     if(cnsPow < 0) return;
16683
16684     int i0;
16685     if(aMap[startY][startX] <= cnsPow)
16686         aMap[startY][startX] = cnsPow;
16687
16688     if(startY < 0) startY = 0;
16689     if(startX < 0) startX = 0;
16690     if(cnsPow < 0) cnsPow = 0;
16691
16692     i0 = cnsPow - 1;
16693
16694     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
16695         [self checkAppearanceRange:i0 tX:startX tY:startY-1 aMap:aMap];
16696
16697     i0 = cnsPow - 1;
16698     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
16699         [self checkAppearanceRange:i0 tX:startX tY:startY+1 aMap:aMap];
16700
16701     i0 = cnsPow - 1;
16702     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
16703         [self checkAppearanceRange:i0 tX:startX-1 tY:startY aMap:aMap];
16704
16705     i0 = cnsPow - 1;
16706     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
16707         [self checkAppearanceRange:i0 tX:startX+1 tY:startY aMap:aMap];
16708
16709 }
16710
16711 -(void)addAppearanceStatus:(UNITCHIP)u x:(int)x y:(int)y{
16712     registerNum++;
16713
16714     int omgCnt = 0;
16715     U = UTop;
16716     while (U->next) {omgCnt++;
16717         U = U->next;
16718     }
16719     U->next = calloc(1, sizeof(UNIT));
16720     U = U->next;
16721     U->next = NULL;
16722     if(omgCnt == 0) U = UTop;
16723     U->number = registerNum;
16724     U->chipNumber = -1;
16725     U->chipNumberL = -1;
16726     U->C.chipNumb = -1;
16727     U->CL.chipNumb = -1;
16728
16729     U->x = x;
16730     U->y = y;
16731
16732     U->C = u;
16733     if(unitTeam[x][y] == 0 || unitTeam[x][y] == 1){
16734         U->team = 0;
16735         if(unitTeam[x][y] == 1){
16736             U->joinArmyFromNext = true;
16737             U->persuasion = true;
16738         }
16739         if(MF[MFselectedRow+1].MS.playerSet1 == 2)
16740             U->CPU = true;
16741
16742     }
16743     if(unitTeam[x][y] == 2 || unitTeam[x][y] == 3){
16744         U->team = 2;
16745         if(unitTeam[x][y] == 3){
16746             U->joinArmyFromNext = true;
16747             U->persuasion = true;
16748         }
16749         if(MF[MFselectedRow+1].MS.playerSet2 == 2)
16750             U->CPU = true;
16751
16752     }
16753     if(unitTeam[x][y] == 4 || unitTeam[x][y] == 5){
16754         U->team = 1;
16755         if(unitTeam[x][y] == 5){
16756             U->joinArmyFromNext = true;
16757             U->persuasion = true;
16758         }
16759         U->CPU = true;
16760     }
16761     if(unitTeam[x][y] == -1){
16762         U->team = -1;
16763         if(unitTeam[x][y] == 0){
16764             U->joinArmyFromNext = false;
16765             U->persuasion = true;
16766         }
16767         U->CPU = true;
16768     }
16769     unitNum[x][y] = u.chipNumb;
16770     [self SetUnitStatus:unitNum[x][y]];
16771
16772     for(int i = 0;i < UCN;i++){
16773         if([U->C.nameID isEqualToString:UC[i].nameID])
16774             U->chipNumber = i;
16775     }
16776     for(int i = 0;i < LCN;i++){
16777         if([U->CL.nameID isEqualToString:LC[i].nameID])
16778             U->chipNumberL = i;
16779     }
16780     for(int i = 0;i < UCN;i++){
16781         if([U->C.nameID isEqualToString:UC[i].nameID])
16782             U->C.chipNumb = i;
16783     }
16784     for(int i = 0;i < LCN;i++){
16785         if([U->CL.nameID isEqualToString:LC[i].nameID])
16786             U->CL.chipNumb = i;
16787     }
16788
16789     registerNum++;
16790     U = UTop;
16791
16792 }
16793
16794
16795 -(MAPSCRIPT0*)setWait:(MAPSCRIPT0*)MS0{
16796
16797     static bool waitin = false;
16798
16799     if(!waitin){
16800         waitinTime = 0;
16801         waitinTime = MS0->wait;
16802
16803         waitin = true;
16804     }
16805
16806     waitSwtichFlag = true;
16807
16808     if(waitAllOverFlag){
16809         MS0->succeessfulFlag = true;
16810         MS0->endFlag = true;
16811         waitAllOverFlag = false;
16812         waitSwtichFlag = false;
16813         waitin = false;
16814         waitx10flag = false;
16815         waitinTime = 0;
16816     }
16817
16818     return MS0;
16819 }
16820
16821 -(MAPSCRIPT0*)setBGM:(MAPSCRIPT0*)MS0{
16822
16823     if(BGMsub)
16824         BGMsub = NULL;
16825
16826     BGMsub = [MS0->BGM.snd retain];
16827
16828     [BGMsub setLoops:NO];
16829     [BGMsub play];
16830
16831     MS0->succeessfulFlag = true;
16832     MS0->endFlag = true;
16833
16834     return MS0;
16835 }
16836
16837 -(MAPSCRIPT0*)setSE:(MAPSCRIPT0*)MS0{
16838
16839     if(SEsub)
16840         [SEsub stop];
16841     SEsub = [MS0->SE.snd retain];
16842
16843     [SEsub play];
16844
16845     MS0->succeessfulFlag = true;
16846     MS0->endFlag = true;
16847
16848     return MS0;
16849 }
16850
16851 -(MAPSCRIPT0*)setTitleBack:(MAPSCRIPT0*)MS0{
16852
16853     backTitleFlag = true;
16854     battleBegin = false;
16855
16856     MS0->succeessfulFlag = true;
16857     MS0->endFlag = true;
16858
16859     return MS0;
16860 }
16861
16862 -(MAPSCRIPT0*)setStageClear:(MAPSCRIPT0*)MS0{
16863
16864     stageClearFlag = true;
16865
16866     if(MS0->sc.edcdFlag)
16867         stageClearFlag2 = true;
16868     battleBegin = false;
16869
16870     MS0->succeessfulFlag = true;
16871     MS0->endFlag = true;
16872
16873     return MS0;
16874 }
16875
16876 -(MAPSCRIPT0*)setGameOver:(MAPSCRIPT0*)MS0{
16877
16878     gaov.img = MS0->gaov.img;
16879
16880     gameOverFlag = true;
16881     battleBegin = false;
16882
16883     MS0->succeessfulFlag = true;
16884     MS0->endFlag = true;
16885
16886     return MS0;
16887 }
16888
16889 -(IBAction)gameOverSubmit:(id)sender{
16890
16891
16892     gaov.img = nil;
16893
16894     [BGMsub stop];
16895     BGMsub = NULL;
16896
16897     [GameOverWindow close];
16898     [titleWindow makeKeyAndOrderFront:nil];
16899
16900 }
16901
16902 -(IBAction)battleReadyUpStartBtn:(id)sender{
16903
16904
16905     P[0].resource = [battleReadyUpSupply1 intValue];
16906     P[0].food = [battleReadyUpFood1 intValue];
16907     P[0].money = [battleReadyUpMoney1 intValue];
16908
16909     P[1].resource = [battleReadyUpSupply2 intValue];
16910     P[1].food = [battleReadyUpFood2 intValue];
16911     P[1].money = [battleReadyUpMoney2 intValue];
16912
16913     setBattleModeFlag = false;
16914     [bsWindow close];
16915
16916 }
16917
16918 -(IBAction)battleReadyUpState1:(id)sender{
16919     retardhelp1 = true;
16920 }
16921 -(IBAction)battleReadyUpState2:(id)sender{
16922     retardhelp2 = true;
16923 }
16924
16925
16926
16927
16928
16929
16930
16931 -(IBAction)selectionBtn1:(id)sender{
16932     slctedBtnNum = 1;
16933     [selectionWindow close];
16934 }
16935 -(IBAction)selectionBtn2:(id)sender{
16936     slctedBtnNum = 2;
16937     [selectionWindow close];
16938 }
16939 -(IBAction)selectionBtn3:(id)sender{
16940     slctedBtnNum = 3;
16941     [selectionWindow close];
16942 }
16943 -(IBAction)selectionBtn4:(id)sender{
16944     slctedBtnNum = 4;
16945     [selectionWindow close];
16946 }
16947 -(IBAction)selectionBtn5:(id)sender{
16948     slctedBtnNum = 5;
16949     [selectionWindow close];
16950 }
16951 -(IBAction)selectionBtn6:(id)sender{
16952     slctedBtnNum = 6;
16953     [selectionWindow close];
16954 }
16955 -(IBAction)selectionBtn7:(id)sender{
16956     slctedBtnNum = 7;
16957     [selectionWindow close];
16958 }
16959 -(IBAction)selectionBtn8:(id)sender{
16960     slctedBtnNum = 8;
16961     [selectionWindow close];
16962 }
16963 -(IBAction)selectionBtn9:(id)sender{
16964     slctedBtnNum = 9;
16965     [selectionWindow close];
16966 }
16967
16968
16969
16970 -(void)HensuuLoad{
16971
16972     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
16973     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
16974
16975
16976     NSData *InitialData = [NSData dataWithContentsOfFile:@"data/Others/var.txt"];
16977     NSString *pathVar = @"data/Others/var.txt";
16978     NSString *fileData = @"";
16979
16980     if(!InitialData){
16981         [[NSFileManager defaultManager] createFileAtPath:pathVar contents:nil attributes:nil];
16982     }
16983
16984     HensuuNum = 0;
16985     fileData = [NSString stringWithContentsOfFile:pathVar encoding:NSUTF8StringEncoding error:nil];
16986     NSArray *fileDataArray = [fileData componentsSeparatedByString:@"\n"];
16987
16988     for(int i = 0;i < [fileDataArray count];i++){
16989
16990         NSArray *item = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
16991
16992         Hensuu[i] = [[item objectAtIndex:1] retain];
16993         HensuuName[i] = [[item objectAtIndex:2] retain];
16994         HensuuNum++;
16995     }
16996
16997
16998 }
16999
17000
17001 -(void)displaySideMenu{
17002
17003     [FSMenu setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - FSMenu.frame.size.width/2,
17004                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - FSMenu.frame.size.height/2)];
17005     [menuPanel close];
17006     moveFlag = false;
17007     attackFlag = false;
17008     summonFlag = false;
17009     menuDisplayFlag = false;
17010     [FSMenu makeKeyAndOrderFront:nil];
17011
17012     coolTime = true;
17013 }
17014
17015 -(IBAction)FSVsave:(id)sender{
17016
17017     [saveGamePanel setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - saveGamePanel.frame.size.width/2,
17018                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - saveGamePanel.frame.size.height/2)];
17019
17020     [self saveGameDataDatViewImage];
17021
17022     [saveGameTF setStringValue:@""];
17023
17024     [saveGamePanel makeKeyAndOrderFront:nil];
17025
17026 }
17027
17028 -(IBAction)FSVtitle:(id)sender{
17029
17030     stopByFSVmenuFlag = false;
17031     [BGMsub stop];
17032     BGMsub = NULL;
17033     if(titleBGM) [titleBGM play];
17034
17035     [titleWindow makeKeyAndOrderFront:nil];
17036     [fsWindow close];
17037     [FSMenu close];
17038
17039     esSceneProc = 0;
17040
17041
17042     endGameCondition = false;
17043     initMapFlag = false;
17044     TeamCountFlag = false;
17045     initStatusFlag = false;
17046     battleBegin = false;
17047     startES = false;
17048
17049     cpuModeMOVEflag = false;
17050     cpuModeATTACKflag = false;
17051
17052     redWinFlag = false;
17053     blueWinFlag = false;
17054     cpuAImodeflag = false;
17055     cpuTurnEndFlag = true;
17056     backTitleFlag = false;
17057     backTitleFlag2 = true;
17058     waitSwtichFlag = false;
17059     battleReadyUpFlag = false;
17060     setBattleModeFlag = false;
17061     mapChipDataLoadProc = 0;
17062
17063     wtRdy = false;
17064     wtRdy2 = false;
17065
17066     Uselected = NULL;
17067
17068 }
17069 -(IBAction)FSVcancel:(id)sender{
17070
17071     stopByFSVmenuFlag = false;
17072     coolTime = false;
17073     [FSMenu close];
17074
17075 }
17076
17077
17078 -(void)displaySaveFileDialog{
17079
17080     [saveDataList initFileDirectory];
17081     [self initSaveFileInputList];
17082     [saveFileDialog makeKeyAndOrderFront:nil];
17083 }
17084
17085
17086 -(IBAction)saveFileInputSubmit:(id)sender{
17087
17088     if([saveFileInputTF stringValue] == nil || [[saveFileInputTF stringValue] isEqualToString:@""]){
17089         return;
17090     }
17091
17092     saveFileNameSDL = [[saveFileInputTF stringValue] retain];
17093     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
17094     [saveDataList saveSaveList];
17095     [levelList saveLevelList];
17096
17097     [titleWindow makeKeyAndOrderFront:nil];
17098     [saveFileInputPanel close];
17099 }
17100 -(IBAction)saveFileInputCancel:(id)sender{
17101
17102
17103     [titleWindow makeKeyAndOrderFront:nil];
17104     [saveFileInputPanel close];
17105 }
17106
17107 -(IBAction)saveFileDialogSubmit:(id)sender{
17108
17109     saveFileFlag = true;
17110     [saveFileInputPanel makeKeyAndOrderFront:nil];
17111     [fsWindow close];
17112     [saveFileDialog close];
17113
17114 }
17115 -(IBAction)saveFileDialogCancel:(id)sender{
17116
17117     saveFileNameSDL = [@"preset.txt" retain];
17118     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
17119     [saveDataList saveSaveList];
17120
17121     saveFileFlag = true;
17122     [titleWindow makeKeyAndOrderFront:nil];
17123
17124     [fsWindow close];
17125     [saveFileDialog close];
17126
17127 }
17128
17129 -(void)initSaveFileInputList{
17130
17131     [self willChangeValueForKey:@"saveFileInputListMA"];
17132     [saveFileInputListMA removeAllObjects];
17133     [self didChangeValueForKey:@"saveFileInputListMA"];
17134
17135
17136     for(int i = 1;i <= saveNumb;i++){
17137
17138
17139         NSMutableDictionary* dict = [NSMutableDictionary new];
17140         [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
17141         [self willChangeValueForKey:@"saveFileInputListMA"];
17142         [saveFileInputListMA addObject:dict];
17143         [self didChangeValueForKey:@"saveFileInputListMA"];
17144     }
17145
17146 }
17147
17148 -(void)initLoadFileOutputList{
17149
17150     [self willChangeValueForKey:@"loadFileOutputListMA"];
17151     [loadFileOutputListMA removeAllObjects];
17152     [self didChangeValueForKey:@"loadFileOutputListMA"];
17153
17154
17155     for(int i = 1;i <= saveNumb;i++){
17156
17157
17158         if([SC[storyNumb].name isEqualToString:SDL[i].levelName]){
17159             NSMutableDictionary* dict = [NSMutableDictionary new];
17160             [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
17161             [self willChangeValueForKey:@"loadFileOutputListMA"];
17162             [loadFileOutputListMA addObject:dict];
17163             [self didChangeValueForKey:@"loadFileOutputListMA"];
17164         }
17165     }
17166
17167     LFOLrow = -1;
17168     [loadFileOutputListAC setSelectionIndex:9999];
17169
17170     [loadFileOutputTF setStringValue:[NSString stringWithFormat:@""]];
17171
17172     [loadFileOutputPanel makeKeyAndOrderFront:nil];
17173
17174 }
17175
17176 -(IBAction)loadFileOutputSubmit:(id)sender{
17177
17178     if(LFOLrow < 0)
17179         return;
17180
17181     SC[storyNumb].saveFileName = [SDL[SDLrow+1].name retain];
17182     SC[storyNumb].CrntLevelName = [SDL[SDLrow+1].levelName retain];
17183     SC[storyNumb].scenarioNumbCrnt[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbCrnt];
17184     SC[storyNumb].scenarioNumbNext[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbNext];
17185
17186     [levelList saveLevelList];
17187     [scenarioList initFileDirectory];
17188     [mapEditor initFileDirectoryOthers];
17189     [scenarioList setScenarioList:selectNumb];
17190
17191     [loadFileOutputPanel close];
17192 }
17193
17194 -(void)initFileOutPutListSet{
17195
17196     SC[storyNumb].saveFileName = NULL;
17197
17198     [levelList saveLevelList];
17199     [scenarioList setScenarioList:selectNumb];
17200 }
17201
17202 -(IBAction)loadFileOutputCancel:(id)sender{
17203
17204     [loadFileOutputPanel close];
17205 }
17206
17207
17208
17209
17210
17211
17212
17213
17214 -(IBAction)saveGameSubmit:(id)sender{
17215
17216     if([[saveGameTF stringValue] isEqualToString:@""])
17217         return;
17218
17219     sdd.name = [[saveGameTF stringValue] retain];
17220     datFilePath = calloc(255, sizeof(char));
17221     strcpy(datFilePath, [sdd.name UTF8String]);
17222
17223     [self saveGameDataDatViewImage];
17224     [self saveGameDataDat];
17225     [saveDataList initSaveList];
17226
17227     [saveGamePanel close];
17228
17229 }
17230
17231 -(void)saveGameDataDatViewImage{
17232
17233     NSString *directoryPath;
17234
17235     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
17236     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
17237
17238     [fieldView lockFocus];
17239     NSBitmapImageRep* rep = [fieldView bitmapImageRepForCachingDisplayInRect:fieldView.bounds];
17240     [fieldView cacheDisplayInRect:fieldView.bounds toBitmapImageRep:rep];
17241     [fieldView unlockFocus];
17242
17243     NSMutableData* data = [rep representationUsingType:NSPNGFileType properties:nil];
17244     sdd.img = [[[NSImage alloc] initWithData:data] retain];
17245
17246     [saveGameIV setImage:sdd.img];
17247     [saveGameIV setImageScaling:NSScaleToFit];
17248
17249
17250     NSString *path = @"SaveData/";
17251
17252     NSArray *ary = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:nil];
17253
17254     [SAV removeAllObjects];
17255     for(NSString *name in ary){
17256
17257         NSArray *arr = [name componentsSeparatedByString:@".sav"];
17258
17259         if([arr count] > 1){
17260             [SAV addObject:name];
17261         }
17262     }
17263
17264     [self willChangeValueForKey:@"saveGameListMA"];
17265     [saveGameListMA removeAllObjects];
17266     [self didChangeValueForKey:@"saveGameListMA"];
17267
17268     for(int i = 0;i < [SAV count];i++){
17269
17270         NSMutableDictionary* dict = [NSMutableDictionary new];
17271         [dict setValue:[NSString stringWithFormat:@"%@", SAV[i]] forKey:@"name"];
17272
17273         [self willChangeValueForKey:@"saveGameListMA"];
17274         [saveGameListMA addObject:dict];
17275         [self didChangeValueForKey:@"saveGameListMA"];
17276
17277     }
17278
17279     [saveGameListAC setSelectionIndex:9999];
17280
17281 }
17282
17283 -(void)loadGameDataDat{
17284
17285     if(!datFilePath)
17286         return;
17287
17288
17289
17290     [self loadStruct];
17291
17292
17293     NSString *directoryPath;
17294     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
17295     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
17296
17297
17298     NSString *path = @"SaveData/";
17299     path = [path stringByAppendingString:SAV[SDLrow]];
17300
17301     NSData *data = [[NSData alloc] initWithContentsOfFile:path];
17302
17303     MFselectedRow = sdd2[datRow].MFselectedRow;
17304     MF[MFselectedRow+1].fileName = sdd2[datRow].mapfileName;
17305
17306     storyNumb = sdd2[datRow].storyNumb;
17307     scenarioNumb = sdd2[datRow].scenarioNumb;
17308
17309     SC[storyNumb].name = sdd2[datRow].levelName;
17310     SC[storyNumb].nameMAP[scenarioNumb] = sdd2[datRow].scenarioName;
17311
17312     posX = sdd2[datRow].posX;
17313     posX = sdd2[datRow].posY;
17314
17315     chipHeight = sdd2[datRow].chipHeight;
17316     chipWidth = sdd2[datRow].chipWidth;
17317     eSlctX = sdd2[datRow].eSlctX;
17318     eSlctY = sdd2[datRow].eSlctY;
17319
17320     registerNum = sdd2[datRow].registerNum;
17321     registerNumB = sdd2[datRow].registerNumB;
17322
17323     esSceneProc = sdd2[datRow].esSceneProc;
17324
17325     endGameCondition = sdd2[datRow].endGameCondition;
17326     initMapFlag = sdd2[datRow].initMapFlag;
17327     TeamCountFlag = sdd2[datRow].TeamCountFlag;
17328     initStatusFlag = sdd2[datRow].initStatusFlag;
17329     battleBegin = sdd2[datRow].battleBegin;
17330     startES = sdd2[datRow].startES;
17331
17332     cpuAImodeflag = sdd2[datRow].cpuAImodeflag;
17333     cpuTurnEndFlag = sdd2[datRow].cpuTurnEndFlag;
17334     cpuModeMOVEflag = sdd2[datRow].cpuModeMOVEflag;
17335     cpuModeATTACKflag = sdd2[datRow].cpuModeATTACKflag;
17336     waitSwtichFlag = sdd2[datRow].waitSwtichFlag;
17337     battleReadyUpFlag = sdd2[datRow].battleReadyUpFlag;
17338     setBattleModeFlag = sdd2[datRow].setBattleModeFlag;
17339
17340     wtRdy = sdd2[datRow].wtRdy;
17341     wtRdy2 = sdd2[datRow].wtRdy2;
17342     wtRdy3 = sdd2[datRow].wtRdy3;
17343
17344     wtMovedFlag = sdd2[datRow].wtMovedFlag;
17345     wtAttackedFlag = sdd2[datRow].wtAttackedFlag;
17346     unitMoveEndFlag = sdd2[datRow].unitMoveEndFlag;
17347     battleSetUp = sdd2[datRow].battleSetUp;
17348     pushStanbyFlag = sdd2[datRow].pushStanbyFlag;
17349     battleEndFlag = sdd2[datRow].battleEndFlag;
17350     wtUnitNum = sdd2[datRow].wtUnitNum;
17351     messageDialog = sdd2[datRow].messageDialog;
17352
17353 /*
17354     for(int i = 0;i < 1002;i++){
17355         for(int j = 0;j < 1002;j++){
17356             chipNum[i][j] = sdd2[datRow].chipNum[i][j];
17357         }
17358     }
17359
17360     for(int i = 0;i < 1002;i++){
17361         for(int j = 0;j < 1002;j++){
17362             buildNum[i][j] = sdd2[datRow].buildNum[i][j];
17363         }
17364     }
17365
17366     for(int i = 0;i < 1002;i++){
17367         for(int j = 0;j < 1002;j++){
17368             unitNum[i][j] = sdd2[datRow].unitNum[i][j];
17369         }
17370     }
17371
17372     for(int i = 0;i < 1002;i++){
17373         for(int j = 0;j < 1002;j++){
17374             loadNum[i][j] = sdd2[datRow].loadNum[i][j];
17375         }
17376     }
17377
17378     for(int i = 0;i < 1002;i++){
17379         for(int j = 0;j < 1002;j++){
17380             buildTeam[i][j] = sdd2[datRow].buildTeam[i][j];
17381         }
17382     }
17383
17384     for(int i = 0;i < 1002;i++){
17385         for(int j = 0;j < 1002;j++){
17386             unitTeam[i][j] = sdd2[datRow].unitTeam[i][j];
17387         }
17388     }
17389 */
17390
17391     P[0] = sdd2[datRow].P[0];
17392     P[1] = sdd2[datRow].P[1];
17393     P[2] = sdd2[datRow].P[2];
17394
17395     for(int i = 0;i < 9999;i++)
17396         Suicchi[i] = sdd2[datRow].Suicchi[i];
17397
17398     sdd.HensuuNum = HensuuNum;
17399     for(int i = 0;i < 65000;i++)
17400         Hensuu[i] = [sdd2[datRow].Hensuu[i] retain];
17401     for(int i = 0;i < 65000;i++)
17402         HensuuName[i] = [sdd2[datRow].HensuuName[i] retain];
17403
17404     MF[MFselectedRow+1].MS = sdd2[datRow].MS;
17405     MF[MFselectedRow+1].MS.D = sdd2[datRow].MS.D;
17406
17407     /*
17408      UTop = sdd.UTop;
17409      BTop = sdd.BTop;
17410
17411
17412      Uselected = sdd.Uselected;
17413      unitBreak = sdd.unitBreak;
17414      Utarget = sdd.Utarget;
17415
17416      */
17417
17418     //NSLog(@"%d", MF[MFselectedRow+1].MS.playerSet1);
17419 }
17420
17421 -(void)saveGameDataDat{
17422     //おまんこ
17423
17424
17425     sdd.name = [[saveGameTF stringValue] retain];
17426
17427     sdd.MFselectedRow = MFselectedRow;
17428     sdd.storyNumb = storyNumb;
17429     sdd.scenarioNumb = scenarioNumb;
17430
17431     sdd.mapfileName = [MF[MFselectedRow+1].fileName retain];
17432     sdd.levelName = [SC[storyNumb].name retain];
17433     sdd.scenarioName = [SC[storyNumb].nameMAP[scenarioNumb] retain];
17434
17435     sdd.posX = posX;
17436     sdd.posX = posY;
17437
17438     sdd.chipHeight = chipHeight;
17439     sdd.chipWidth = chipWidth;
17440     sdd.eSlctX = eSlctX;
17441     sdd.eSlctY = eSlctY;
17442
17443     sdd.registerNum = registerNum;
17444     sdd.registerNumB = registerNumB;
17445
17446     sdd.esSceneProc = esSceneProc;
17447
17448     sdd.endGameCondition = endGameCondition;
17449     sdd.initMapFlag = initMapFlag;
17450     sdd.TeamCountFlag = TeamCountFlag;
17451     sdd.initStatusFlag = initStatusFlag;
17452     sdd.battleBegin = battleBegin;
17453     sdd.startES = startES;
17454
17455     sdd.cpuModeMOVEflag = cpuModeMOVEflag;
17456     sdd.cpuModeATTACKflag = cpuModeATTACKflag;
17457
17458     sdd.cpuAImodeflag = cpuAImodeflag;
17459     sdd.cpuTurnEndFlag = cpuTurnEndFlag;
17460     sdd.waitSwtichFlag = waitSwtichFlag;
17461     sdd.battleReadyUpFlag = battleReadyUpFlag;
17462     sdd.setBattleModeFlag = setBattleModeFlag;
17463
17464
17465     sdd.wtRdy = wtRdy;
17466     sdd.wtRdy2 = wtRdy2;
17467     sdd.wtRdy3 = wtRdy3;
17468
17469
17470     sdd.wtMovedFlag = wtMovedFlag;
17471     sdd.wtAttackedFlag = wtAttackedFlag;
17472     sdd.unitMoveEndFlag = unitMoveEndFlag;
17473     sdd.battleSetUp = battleSetUp;
17474     sdd.pushStanbyFlag = pushStanbyFlag;
17475     sdd.battleEndFlag = battleEndFlag;
17476     sdd.wtUnitNum = wtUnitNum;
17477     sdd.messageDialog = messageDialog;
17478
17479     /*
17480     for(int i = 0;i < 1002;i++){
17481         for(int j = 0;j < 1002;j++){
17482             sdd.chipNum[i][j] = chipNum[i][j];
17483         }
17484     }
17485
17486     for(int i = 0;i < 1002;i++){
17487         for(int j = 0;j < 1002;j++){
17488             sdd.buildNum[i][j] = buildNum[i][j];
17489         }
17490     }
17491
17492     for(int i = 0;i < 1002;i++){
17493         for(int j = 0;j < 1002;j++){
17494             sdd.unitNum[i][j] = unitNum[i][j];
17495         }
17496     }
17497
17498     for(int i = 0;i < 1002;i++){
17499         for(int j = 0;j < 1002;j++){
17500             sdd.loadNum[i][j] = loadNum[i][j];
17501         }
17502     }
17503
17504     for(int i = 0;i < 1002;i++){
17505         for(int j = 0;j < 1002;j++){
17506             sdd.buildTeam[i][j] = buildTeam[i][j];
17507         }
17508     }
17509
17510     for(int i = 0;i < 1002;i++){
17511         for(int j = 0;j < 1002;j++){
17512             sdd.unitTeam[i][j] = unitTeam[i][j];
17513         }
17514     }
17515     */
17516
17517     U = UTop;
17518     int r = 0;
17519     while(U && r < registerNum){
17520         sdd.dU[r].CPU = U->CPU;
17521         sdd.dU[r].number = U->number;
17522         sdd.dU[r].team = U->team;
17523         sdd.dU[r].chipNumber = U->chipNumber;
17524         sdd.dU[r].chipNumberL = U->chipNumberL;
17525
17526         sdd.dU[r].x = U->x;
17527         sdd.dU[r].y = U->y;
17528         sdd.dU[r].z = U->z;
17529
17530         sdd.dU[r].ix = U->ix;
17531         sdd.dU[r].iy = U->iy;
17532         sdd.dU[r].iz = U->iz;
17533
17534         sdd.dU[r].dead = U->dead;
17535
17536         sdd.dU[r].loadChipFlag = U->loadChipFlag;
17537
17538         sdd.dU[r].unControlable = U->unControlable;
17539         sdd.dU[r].joinArmyFromNext = U->joinArmyFromNext;
17540         sdd.dU[r].persuasion = U->persuasion;
17541
17542         sdd.dU[r].targType1L = U->targType1L;
17543         sdd.dU[r].targType2L = U->targType2L;
17544         sdd.dU[r].targType1D = U->targType1D;
17545         sdd.dU[r].targType2D = U->targType2D;
17546
17547         sdd.dU[r].army = U->army;
17548         sdd.dU[r].img = [U->img retain];
17549
17550         sdd.dU[r].C.chipNumb = U->C.chipNumb;
17551         sdd.dU[r].C.name = [U->C.name retain];
17552         sdd.dU[r].C.nameNick = [U->C.nameNick retain];
17553         sdd.dU[r].C.nameClass = [U->C.nameClass retain];
17554         sdd.dU[r].C.nameID = [U->C.nameID retain];
17555
17556         sdd.dU[r].C.R_C = U->C.R_C;
17557         sdd.dU[r].C.S_C = U->C.S_C;
17558
17559         U = U->next;
17560         r++;
17561     }U = UTop;
17562
17563     B = BTop;
17564     r = 0;
17565     while(B && r < registerNumB){
17566         sdd.dB[r].number = B->number;
17567         sdd.dB[r].team = B->team;
17568         sdd.dB[r].chipNumber = B->chipNumber;
17569         sdd.dB[r].makeLv = B->makeLv;
17570
17571         sdd.dB[r].x = B->x;
17572         sdd.dB[r].y = B->y;
17573         sdd.dB[r].z = B->z;
17574
17575         sdd.dB[r].dead = B->dead;
17576
17577         sdd.dB[r].img = [B->img retain];
17578         sdd.dB[r].C.chipNumb = B->C.chipNumb;
17579         sdd.dB[r].C.name = [B->C.name retain];
17580         sdd.dB[r].C.nameID = [B->C.nameID retain];
17581         sdd.dB[r].C.S_C = B->C.S_C;
17582
17583         B = B->next;
17584         r++;
17585     }B = BTop;
17586
17587     sdd.P[0] = P[0];
17588     sdd.P[1] = P[1];
17589     sdd.P[2] = P[2];
17590
17591
17592     for(int i = 0;i < 9999;i++)
17593         sdd.Suicchi[i] = Suicchi[i];
17594
17595     sdd.HensuuNum = HensuuNum;
17596     for(int i = 0;i < 65000;i++)
17597         sdd.Hensuu[i] = [Hensuu[i] retain];
17598     for(int i = 0;i < 65000;i++)
17599         sdd.HensuuName[i] = [HensuuName[i] retain];
17600
17601     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
17602
17603      sdd.MS = MS;
17604
17605     /*
17606      sdd->UTop = UTop;
17607      sdd->BTop = BTop;
17608      */
17609
17610
17611     [self saveStruct];
17612 }
17613
17614 -(NSData *)sddToNSData:(NSString *) path{
17615
17616     /*
17617     NSData *archivedData = [NSKeyedArchiver archivedDataWithRootObject:sdd];
17618
17619     [archivedData writeToFile:path atomically:YES];
17620
17621     return archivedData;
17622     */
17623
17624
17625 }
17626
17627 -(IBAction)saveGameCancel:(id)sender{
17628
17629     [saveGamePanel close];
17630
17631 }
17632
17633 @end
17634
17635
17636
17637
17638
17639 @implementation FieldSceneEF
17640
17641
17642 -(BOOL)isFlipped{
17643     return YES;
17644 }
17645
17646 - (id)initWithFrame:(NSRect)frame
17647 {
17648     self = [super initWithFrame:frame];
17649     if (self) {
17650         // Initialization code here.
17651         time  = [NSTimer
17652                  scheduledTimerWithTimeInterval:0.015
17653                  target:self
17654                  selector:@selector(EventLoopBV:)
17655                  userInfo:nil
17656                  repeats:YES
17657                  ];
17658     }
17659
17660     return self;
17661 }
17662
17663 -(void)scrollWheel:(NSEvent *)theEvent{
17664
17665     theEvent = NULL;
17666
17667 }
17668
17669 -(void)EventLoopBV:(NSTimer*)timer{
17670
17671     [battleView setNeedsDisplay:YES];
17672
17673     static int aniFrame = 0;
17674
17675     if(animationFlag3){
17676         aniFrame = 0;
17677         aniFrameCnt = 0;
17678         return;
17679     }
17680
17681     if(!animationFlag1 && !animationFlag2){
17682         aniFrame = 0;
17683         aniFrameCnt = 0;
17684         return;
17685     }
17686
17687     U = effCun;
17688
17689     if(animationFlag1)
17690         U->C.A = attackCR;
17691     if(animationFlag2)
17692         U->C.A = attackCR2;
17693
17694     static bool pussyMikoto = false;
17695
17696     if(aniFrame == 0){
17697
17698         ani = U->C.A->AN.ANI;
17699         ANI *aniTop = ani;
17700
17701         for (int i = 0; i < aniFrameCnt;i++) {
17702             ani = ani->next;
17703         }
17704
17705         if(ani->snd){
17706             [ani->snd setCurrentTime:0];
17707             [ani->snd play];
17708             ani->snd.loops = NO;
17709         }
17710         if(!ani->next){
17711             pussyMikoto = true;
17712         }
17713         ani = aniTop;
17714
17715         U->C.A->AN.ANI = ani;
17716     }
17717
17718     if(aniFrame < U->C.A->AN.frame){
17719         aniFrame++;
17720     }else{
17721         aniFrame = 0;
17722         aniFrameCnt++;
17723         if(pussyMikoto){
17724             pussyMikoto = false;
17725             animationFlag3 = true;
17726         }
17727     }
17728
17729
17730
17731
17732
17733     [self setNeedsDisplay:YES];
17734
17735
17736 }
17737
17738 -(void)DrawImage:(NSImage*)image x:(float)x y:(float)y a:(float)a{
17739     NSRect frRect;
17740     frRect.size.height = image.size.height;
17741     frRect.size.width = image.size.width;
17742
17743     frRect.origin.x = 0;
17744     frRect.origin.y = 0;
17745
17746     NSRect drRect;
17747     drRect.origin.x = x;
17748     drRect.origin.y = y;
17749     drRect.size.height = image.size.height;
17750     drRect.size.width = image.size.width;
17751
17752     [image drawInRect:drRect fromRect:frRect operation:NSCompositeSourceOver fraction:a respectFlipped:YES hints:nil];
17753
17754 }
17755
17756 - (void)drawRect:(NSRect)dirtyRect
17757 {
17758     // Drawing code here.
17759     if(animationFlag3) return;
17760
17761
17762
17763
17764     if(animationFlag1 || animationFlag2){
17765         U = effCun;
17766
17767         if(animationFlag1)
17768                 U->C.A = attackCR;
17769         if(animationFlag2)
17770             U->C.A = attackCR2;
17771
17772     ani = U->C.A->AN.ANI;
17773
17774     ANI *aniTop = ani;
17775
17776
17777     for (int i = 0; i < aniFrameCnt;i++) {
17778         ani = ani->next;
17779     }
17780         if(!ani)
17781         {
17782             ani = aniTop;
17783             return;
17784         }
17785     [self DrawImage:ani->img x:ani->x + ani->ax y:ani->y + ani->ay a:1.0f];
17786     ani = aniTop;
17787     }
17788
17789
17790
17791
17792 }
17793
17794
17795
17796
17797
17798
17799
17800
17801
17802
17803 @end
17804
17805
17806
17807
17808
17809
17810
17811
17812