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             if(sdd.MS.D->P->type == 15)
 415                 [self writeMapScript7:fp];
 416
 417             sdd.MS.D->P = sdd.MS.D->P->next;
 418         }sdd.MS.D->P = SMSPtop;
 419
 420
 421         sdd.MS.D = sdd.MS.D->next;
 422     }sdd.MS.D = SMSDtop;
 423
 424 }
 425
 426 -(void)writeMapScript1:(FILE*)fp{
 427
 428     if(!sdd.MS.D->P->S1.name)
 429         sdd.MS.D->P->S1.name = [@"" retain];
 430     if(!sdd.MS.D->P->S1.str)
 431         sdd.MS.D->P->S1.str = [@"" retain];
 432     if(!sdd.MS.D->P->S1.iName)
 433         sdd.MS.D->P->S1.iName = [@"" retain];
 434     if(!sdd.MS.D->P->S1.nameID)
 435         sdd.MS.D->P->S1.nameID = [@"" retain];
 436
 437     [self writeNSString:fp str:sdd.MS.D->P->S1.name];
 438     [self writeNSString:fp str:sdd.MS.D->P->S1.str];
 439     [self writeNSString:fp str:sdd.MS.D->P->S1.iName];
 440     [self writeNSString:fp str:sdd.MS.D->P->S1.nameID];
 441
 442     /*
 443      NSString *name;
 444      NSString *str;
 445      //NSImage *img;
 446      NSString *iName;
 447      NSString *nameID;
 448      */
 449 }
 450
 451 -(void)writeMapScript2:(FILE*)fp{
 452
 453     [self writeNSString:fp str:sdd.MS.D->P->S2->selection];
 454     [self writeNSString:fp str:sdd.MS.D->P->S2->labelJump];
 455
 456     /*
 457      //struct _MAPSCRIPT2 *next;
 458
 459      NSString *selection;
 460      NSString *labelJump;
 461      */
 462 }
 463
 464 -(void)writeMapScript3:(FILE*)fp{
 465
 466     [self writeInt:fp val:sdd.MS.D->P->S3->x];
 467     [self writeInt:fp val:sdd.MS.D->P->S3->y];
 468     [self writeInt:fp val:sdd.MS.D->P->S3->flag];
 469
 470     [self writeInt:fp val:sdd.MS.D->P->S3->type];
 471     [self writeInt:fp val:sdd.MS.D->P->S3->team];
 472
 473     [self writeInt:fp val:sdd.MS.D->P->S3->unitNum];
 474     [self writeInt:fp val:sdd.MS.D->P->S3->loadInt];
 475
 476     /*
 477      //struct _MAPSCRIPT3 *next;
 478
 479      int x;
 480      int y;
 481      bool flag;
 482
 483      int type;
 484      int team;
 485
 486      //UNITCHIP U;
 487      int unitNum;
 488
 489      int loadInt;
 490      */
 491 }
 492
 493 -(void)writeMapScript4:(FILE*)fp{
 494
 495     [self writeInt:fp val:sdd.MS.D->P->S4.lagFixFlag];
 496     [self writeNSString:fp str:sdd.MS.D->P->S4.COMPrabel];
 497     [self writeNSString:fp str:sdd.MS.D->P->S4.FAILrabel];
 498
 499     [self writeInt:fp val:sdd.MS.D->P->S4.suicchiFlag];
 500
 501     sdd.MS.D->P->S4.suicchiCnt = 0;
 502     if(sdd.MS.D->P->S4.suicchi)
 503     for(int l = 0;*(sdd.MS.D->P->S4.suicchi + l) > 0;l++) {
 504         sdd.MS.D->P->S4.suicchiCnt++;
 505     }[self writeInt:fp val:(int)sdd.MS.D->P->S4.suicchiCnt];
 506
 507     for(int l = 0;l < sdd.MS.D->P->S4.suicchiCnt;l++) {
 508         [self writeInt:fp val:(int)*(sdd.MS.D->P->S4.suicchi + l)];
 509     }
 510
 511     [self writeInt:fp val:sdd.MS.D->P->S4.suicchiONOFF];
 512
 513
 514     [self writeInt:fp val:sdd.MS.D->P->S4.hensuFlag];
 515     [self writeInt:fp val:sdd.MS.D->P->S4.hensu1];
 516     [self writeInt:fp val:sdd.MS.D->P->S4.teisuFlag];
 517     [self writeInt:fp val:sdd.MS.D->P->S4.teisuValue];
 518     [self writeInt:fp val:sdd.MS.D->P->S4.hensu2flag];
 519     [self writeInt:fp val:sdd.MS.D->P->S4.hensu2];
 520     [self writeInt:fp val:sdd.MS.D->P->S4.hensuType];
 521
 522     [self writeInt:fp val:sdd.MS.D->P->S4.timerFlag];
 523     [self writeInt:fp val:sdd.MS.D->P->S4.timerMin];
 524     [self writeInt:fp val:sdd.MS.D->P->S4.timerSec];
 525     [self writeInt:fp val:sdd.MS.D->P->S4.timerType];
 526
 527     [self writeInt:fp val:sdd.MS.D->P->S4.unitNumFlag];
 528     [self writeInt:fp val:sdd.MS.D->P->S4.team];
 529     [self writeInt:fp val:sdd.MS.D->P->S4.unitNum];
 530     [self writeInt:fp val:sdd.MS.D->P->S4.unitType];
 531     [self writeInt:fp val:sdd.MS.D->P->S4.unitTypeFlag];
 532
 533
 534     UNIT2 *subjTop = sdd.MS.D->P->S4.subj;
 535
 536     sdd.MS.D->P->S4.subjCnt = 0;
 537     while (sdd.MS.D->P->S4.subj) {
 538         sdd.MS.D->P->S4.subjCnt++;
 539         sdd.MS.D->P->S4.subj = sdd.MS.D->P->S4.subj->next;
 540     }sdd.MS.D->P->S4.subj = subjTop;
 541     [self writeInt:fp val:sdd.MS.D->P->S4.subjCnt];
 542
 543     for (int k = 0;k < sdd.MS.D->P->S4.subjCnt;k++) {
 544         [self writeMapScript4subj:fp];
 545         sdd.MS.D->P->S4.subj = sdd.MS.D->P->S4.subj->next;
 546     }sdd.MS.D->P->S4.subj = subjTop;
 547
 548
 549
 550
 551     [self writeInt:fp val:sdd.MS.D->P->S4.placeFlag];
 552     PLACEMENT *waypTop = sdd.MS.D->P->S4.wayp;
 553
 554     sdd.MS.D->P->S4.waypCnt = 0;
 555     while (sdd.MS.D->P->S4.wayp) {
 556         sdd.MS.D->P->S4.waypCnt++;
 557         sdd.MS.D->P->S4.wayp = sdd.MS.D->P->S4.wayp->next;
 558     }sdd.MS.D->P->S4.wayp = waypTop;
 559     [self writeInt:fp val:sdd.MS.D->P->S4.waypCnt];
 560
 561     for (int k = 0;k < sdd.MS.D->P->S4.waypCnt;k++) {
 562         [self writeMapScript4wayp:fp];
 563         sdd.MS.D->P->S4.wayp = sdd.MS.D->P->S4.wayp->next;
 564     }sdd.MS.D->P->S4.wayp = waypTop;
 565
 566     [self writeInt:fp val:sdd.MS.D->P->S4.unitCMDflag];
 567     [self writeInt:fp val:sdd.MS.D->P->S4.unitCMD];
 568
 569
 570     [self writeInt:fp val:sdd.MS.D->P->S4.objeFlag];
 571     UNIT2 *objeTop = sdd.MS.D->P->S4.obje;
 572
 573     sdd.MS.D->P->S4.objeCnt = 0;
 574     while (sdd.MS.D->P->S4.obje) {
 575         sdd.MS.D->P->S4.objeCnt++;
 576         sdd.MS.D->P->S4.obje = sdd.MS.D->P->S4.obje->next;
 577     }sdd.MS.D->P->S4.obje = objeTop;
 578     [self writeInt:fp val:sdd.MS.D->P->S4.objeCnt];
 579
 580     for (int k = 0;k < sdd.MS.D->P->S4.objeCnt;k++) {
 581         [self writeMapScript4obje:fp];
 582         sdd.MS.D->P->S4.obje = sdd.MS.D->P->S4.obje->next;
 583     }sdd.MS.D->P->S4.obje = objeTop;
 584
 585     [self writeInt:fp val:sdd.MS.D->P->S4.objeRange];
 586
 587
 588
 589     [self writeInt:fp val:sdd.MS.D->P->S4.buildFlag];
 590     BUILD2 *buildTop = sdd.MS.D->P->S4.build;
 591
 592     sdd.MS.D->P->S4.buildCnt = 0;
 593     while (sdd.MS.D->P->S4.build) {
 594         sdd.MS.D->P->S4.buildCnt++;
 595         sdd.MS.D->P->S4.build = sdd.MS.D->P->S4.build->next;
 596     }sdd.MS.D->P->S4.build = buildTop;
 597     [self writeInt:fp val:sdd.MS.D->P->S4.buildCnt];
 598
 599     for (int k = 0;k < sdd.MS.D->P->S4.buildCnt;k++) {
 600         [self writeMapScript4build:fp];
 601         sdd.MS.D->P->S4.build = sdd.MS.D->P->S4.build->next;
 602     }sdd.MS.D->P->S4.build = buildTop;
 603
 604
 605 }
 606
 607 -(void)writeMapScript4subj:(FILE*)fp{
 608
 609     [self writeInt:fp val:sdd.MS.D->P->S4.subj->team];
 610     [self writeInt:fp val:sdd.MS.D->P->S4.subj->x];
 611     [self writeInt:fp val:sdd.MS.D->P->S4.subj->y];
 612
 613     /*
 614      //struct _UNIT2 *next;
 615      //UNITCHIP C;
 616
 617      int team;
 618      int x;
 619      int y;
 620      */
 621 }
 622
 623 -(void)writeMapScript4wayp:(FILE*)fp{
 624
 625     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->type];
 626     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->x];
 627     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->y];
 628     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->z];
 629     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->x2];
 630     [self writeInt:fp val:sdd.MS.D->P->S4.wayp->y2];
 631
 632     /*
 633      //struct _PLACEMENT *next;
 634
 635      int type;
 636      int x;
 637      int y;
 638      int z;
 639      int x2;
 640      int y2;
 641      */
 642 }
 643
 644 -(void)writeMapScript4obje:(FILE*)fp{
 645
 646     [self writeInt:fp val:sdd.MS.D->P->S4.obje->team];
 647     [self writeInt:fp val:sdd.MS.D->P->S4.obje->x];
 648     [self writeInt:fp val:sdd.MS.D->P->S4.obje->y];
 649
 650     /*
 651      //struct _UNIT2 *next;
 652      //UNITCHIP C;
 653
 654      int team;
 655      int x;
 656      int y;
 657      */
 658 }
 659
 660 -(void)writeMapScript4build:(FILE*)fp{
 661
 662     [self writeInt:fp val:sdd.MS.D->P->S4.build->team];
 663     [self writeInt:fp val:sdd.MS.D->P->S4.build->x];
 664     [self writeInt:fp val:sdd.MS.D->P->S4.build->y];
 665
 666     /*
 667      //struct _BUILD2 *next;
 668      //struct _BUILDCHIP *C;
 669
 670      int team;
 671      int x;
 672      int y;
 673      */
 674 }
 675
 676 -(void)writeMapScript5:(FILE*)fp{
 677
 678     [self writeInt:fp val:sdd.MS.D->P->S5->x];
 679     [self writeInt:fp val:sdd.MS.D->P->S5->y];
 680     [self writeInt:fp val:sdd.MS.D->P->S5->type];
 681     [self writeInt:fp val:sdd.MS.D->P->S5->team];
 682     [self writeInt:fp val:sdd.MS.D->P->S5->unitNum];
 683     [self writeInt:fp val:sdd.MS.D->P->S5->saveInt];
 684
 685     /*
 686      //struct _MAPSCRIPT5 *next;
 687
 688      int x;
 689      int y;
 690
 691      int type;
 692      int team;
 693
 694      //UNITCHIP U;
 695      int unitNum;
 696
 697      int saveInt;
 698      */
 699 }
 700
 701
 702 -(void)writeMapScript6:(FILE*)fp{
 703
 704     [self writeInt:fp val:sdd.MS.D->P->S6.team];
 705
 706     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupply];
 707     [self writeInt:fp val:sdd.MS.D->P->S6.RCfood];
 708     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoney];
 709
 710     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyAdd];
 711     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodAdd];
 712     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyAdd];
 713
 714     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyValue];
 715     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodValue];
 716     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyValue];
 717
 718     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplySelect];
 719     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodSelect];
 720     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneySelect];
 721
 722     [self writeInt:fp val:sdd.MS.D->P->S6.RCsupplyS];
 723     [self writeInt:fp val:sdd.MS.D->P->S6.RCfoodS];
 724     [self writeInt:fp val:sdd.MS.D->P->S6.RCmoneyS];
 725
 726 }
 727
 728 -(void)writeMapScript7:(FILE*)fp{
 729
 730     [self writeInt:fp val:sdd.MS.D->P->S7.type];
 731
 732     [self writeInt:fp val:sdd.MS.D->P->S7.maxFlag];
 733     [self writeInt:fp val:sdd.MS.D->P->S7.percentFlag];
 734     [self writeInt:fp val:sdd.MS.D->P->S7.extendFlag];
 735
 736     [self writeInt:fp val:sdd.MS.D->P->S7.fluctuate];
 737     [self writeInt:fp val:sdd.MS.D->P->S7.valueType];
 738
 739     [self writeNSString:fp str:sdd.MS.D->P->S7.value];
 740
 741     [self writeInt:fp val:sdd.MS.D->P->S7.rdm];
 742
 743
 744     [self writeInt:fp val:sdd.MS.D->P->S7.teamFlag];
 745     [self writeInt:fp val:sdd.MS.D->P->S7.team];
 746
 747     [self writeInt:fp val:sdd.MS.D->P->S7.unitFlag];
 748     [self writeInt:fp val:sdd.MS.D->P->S7.valueFlag];
 749
 750     MS7Atop = sdd.MS.D->P->S7.A;
 751     while (sdd.MS.D->P->S7.A) {
 752         sdd.MS.D->P->S7.S7Acnt++;
 753         sdd.MS.D->P->S7.A = sdd.MS.D->P->S7.A->next;
 754     }sdd.MS.D->P->S7.A = MS7Atop;
 755
 756     MS7Btop = sdd.MS.D->P->S7.B;
 757     while (sdd.MS.D->P->S7.B) {
 758         sdd.MS.D->P->S7.S7Bcnt++;
 759         sdd.MS.D->P->S7.B = sdd.MS.D->P->S7.B->next;
 760     }sdd.MS.D->P->S7.B = MS7Btop;
 761
 762     [self writeInt:fp val:sdd.MS.D->P->S7.S7Acnt];
 763     [self writeInt:fp val:sdd.MS.D->P->S7.S7Bcnt];
 764
 765
 766     MS7Atop = sdd.MS.D->P->S7.A;
 767     for(int i = 0;i < sdd.MS.D->P->S7.S7Acnt;i++){
 768
 769         [self writeInt:fp val:sdd.MS.D->P->S7.A->x];
 770         [self writeInt:fp val:sdd.MS.D->P->S7.A->y];
 771         [self writeInt:fp val:sdd.MS.D->P->S7.A->team];
 772         [self writeInt:fp val:sdd.MS.D->P->S7.A->unitNum];
 773
 774         sdd.MS.D->P->S7.A = sdd.MS.D->P->S7.A->next;
 775     }sdd.MS.D->P->S7.A = MS7Atop;
 776
 777     MS7Btop = sdd.MS.D->P->S7.B;
 778     for(int i = 0;i < sdd.MS.D->P->S7.S7Bcnt;i++){
 779
 780         [self writeInt:fp val:sdd.MS.D->P->S7.B->x];
 781         [self writeInt:fp val:sdd.MS.D->P->S7.B->y];
 782         [self writeInt:fp val:sdd.MS.D->P->S7.B->team];
 783         [self writeInt:fp val:sdd.MS.D->P->S7.B->unitNum];
 784         [self writeInt:fp val:sdd.MS.D->P->S7.B->saveInt];
 785
 786         sdd.MS.D->P->S7.B = sdd.MS.D->P->S7.B->next;
 787     }sdd.MS.D->P->S7.B = MS7Btop;
 788
 789 }
 790
 791 -(void)writeMapScriptBGM:(FILE*)fp{
 792
 793     [self writeNSString:fp str:sdd.MS.D->P->BGM.name];
 794     [self writeNSString:fp str:sdd.MS.D->P->BGM.fName];
 795
 796     /*
 797     NSString *name;
 798     NSString *fName;
 799     //NSSound *snd;
 800      */
 801 }
 802
 803 -(void)writeMapScriptSE:(FILE*)fp{
 804
 805     [self writeNSString:fp str:sdd.MS.D->P->SE.name];
 806     [self writeNSString:fp str:sdd.MS.D->P->SE.fName];
 807
 808     /*
 809      NSString *name;
 810      NSString *fName;
 811      //NSSound *snd;
 812      */
 813 }
 814
 815 -(void)writeMapScriptSC:(FILE*)fp{
 816
 817     [self writeInt:fp val:sdd.MS.D->P->sc.scFlag];
 818     [self writeInt:fp val:sdd.MS.D->P->sc.edcdFlag];
 819
 820     /*
 821      bool scFlag;
 822      bool edcdFlag;
 823      */
 824 }
 825
 826 -(void)writeMapScriptGAOV:(FILE*)fp{
 827
 828     [self writeNSString:fp str:sdd.MS.D->P->gaov.fNname];
 829     [self writeInt:fp val:sdd.MS.D->P->gaov.gaovFlag];
 830     [self writeInt:fp val:sdd.MS.D->P->gaov.edcdFlag];
 831
 832     /*
 833      NSString *fNname;
 834      //NSImage *img;
 835      bool gaovFlag;
 836      bool edcdFlag;
 837      */
 838 }
 839
 840 -(int)readInt:(FILE*)fp{
 841     int counter;
 842     int result = 0;
 843     int shiftLen = 0;
 844
 845     for(counter= INT_MAX;counter > 0;counter >>= 8){
 846         unsigned char nowData = 0;
 847         fread(&nowData, sizeof(unsigned char), 1, fp);
 848         result |= (int)nowData << shiftLen;
 849         shiftLen += 8;
 850     }
 851
 852     return result;
 853 }
 854
 855 -(NSString*)readNSString:(FILE*)fp strOut:(NSString*)strOut{
 856     int length = [self readInt:fp];
 857     char strOutcc[1024];
 858     fread(strOutcc, sizeof(strOut), length, fp);
 859     strOut = [[NSString stringWithUTF8String:strOutcc] retain];
 860
 861     return strOut;
 862 }
 863
 864 -(NSImage*)readNSImage:(FILE*)fp imgOut:(NSImage*)imgOut dcnt:(int)dcnt dfix:(int)dfix{
 865     unsigned char idat[1024];
 866     int size = 0;
 867
 868     NSMutableData *binaryData = [NSMutableData dataWithCapacity:sizeof(idat)];
 869
 870     fpos_t fpt = 0;
 871     for(int i = 0;i < dcnt;i++){
 872         size += fread(idat, 1, 1024, fp);
 873
 874         if(dcnt-1 == i){
 875             fpt += dfix;
 876             fsetpos(fp, &fpt);
 877         }
 878
 879         fgetpos(fp, &fpt);
 880
 881         NSMutableData* data = [NSMutableData dataWithBytes:idat length:sizeof(unsigned char)*1024];
 882         [binaryData appendData:data];
 883     }
 884
 885
 886     imgOut = [[[NSImage alloc] initWithData:binaryData] retain];
 887
 888     return imgOut;
 889 }
 890
 891 -(void)readBiuldD:(FILE*)fp row:(int)r{
 892
 893     sdd2[datRow].dB[r].number = (int)[self readInt:fp];
 894     sdd2[datRow].dB[r].team = (int)[self readInt:fp];
 895     sdd2[datRow].dB[r].chipNumber = (int)[self readInt:fp];
 896     sdd2[datRow].dB[r].makeLv = (int)[self readInt:fp];
 897
 898     sdd2[datRow].dB[r].x = (int)[self readInt:fp];
 899     sdd2[datRow].dB[r].y = (int)[self readInt:fp];
 900     sdd2[datRow].dB[r].z = (int)[self readInt:fp];
 901
 902     sdd2[datRow].dB[r].dead = (int)[self readInt:fp];
 903     /*
 904     sdd2[datRow].dB[r].imgAdCnt = (int)[self readInt:fp];
 905     sdd2[datRow].dB[r].imgAdFix = (int)[self readInt:fp];
 906     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];
 907     */
 908     [self readBuildChipD:fp val:&sdd2[datRow].dB[r].C];
 909 }
 910
 911 -(void)readBuildChipD:(FILE*)fp val:(BUILDCHIPD*)val{
 912
 913     val->chipNumb = (int)[self readInt:fp];
 914     val->name = [[self readNSString:fp strOut:val->name] retain];
 915     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 916
 917     fread(&val->S_C, sizeof(BSTATUS), 1, fp);
 918
 919     //NSLog(@"awww man...");
 920 }
 921
 922
 923
 924 -(void)readUnitD:(FILE*)fp row:(int)r{
 925
 926     sdd2[datRow].dU[r].CPU = (int)[self readInt:fp];
 927     sdd2[datRow].dU[r].number = (int)[self readInt:fp];
 928     sdd2[datRow].dU[r].team = (int)[self readInt:fp];
 929     sdd2[datRow].dU[r].chipNumber = (int)[self readInt:fp];
 930     sdd2[datRow].dU[r].chipNumberL = (int)[self readInt:fp];
 931
 932     sdd2[datRow].dU[r].x = (int)[self readInt:fp];
 933     sdd2[datRow].dU[r].y = (int)[self readInt:fp];
 934     sdd2[datRow].dU[r].z = (int)[self readInt:fp];
 935
 936     sdd2[datRow].dU[r].ix = (int)[self readInt:fp];
 937     sdd2[datRow].dU[r].iy = (int)[self readInt:fp];
 938     sdd2[datRow].dU[r].iz = (int)[self readInt:fp];
 939
 940     sdd2[datRow].dU[r].dead = (int)[self readInt:fp];
 941
 942     sdd2[datRow].dU[r].loadChipFlag = (int)[self readInt:fp];
 943
 944     sdd2[datRow].dU[r].unControlable = (int)[self readInt:fp];
 945     sdd2[datRow].dU[r].joinArmyFromNext = (int)[self readInt:fp];
 946     sdd2[datRow].dU[r].persuasion = (int)[self readInt:fp];
 947
 948     sdd2[datRow].dU[r].targType1L = (int)[self readInt:fp];
 949     sdd2[datRow].dU[r].targType2L = (int)[self readInt:fp];
 950     sdd2[datRow].dU[r].targType1D = (int)[self readInt:fp];
 951     sdd2[datRow].dU[r].targType2D = (int)[self readInt:fp];
 952
 953     sdd2[datRow].dU[r].army = [[self readNSString:fp strOut:sdd2[datRow].dU[r].army] retain];
 954
 955     /*
 956     sdd2[datRow].dU[r].imgAdCnt = (int)[self readInt:fp];
 957     sdd2[datRow].dU[r].imgAdFix = (int)[self readInt:fp];
 958     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];
 959     */
 960
 961     [self readUnitChipD:fp val:&sdd2[datRow].dU[r].C];
 962     [self readUnitChipLD:fp val:&sdd2[datRow].dU[r].CL];
 963
 964 }
 965
 966 -(void)readUnitChipD:(FILE*)fp val:(UNITCHIPD*)val{
 967
 968     val->chipNumb = (int)[self readInt:fp];
 969     val->name = [[self readNSString:fp strOut:val->name] retain];
 970     val->nameNick = [[self readNSString:fp strOut:val->nameNick] retain];
 971     val->nameClass = [[self readNSString:fp strOut:val->nameClass] retain];
 972     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 973
 974
 975
 976     fread(&val->R_C, sizeof(RESIST), 1, fp);
 977     fread(&val->S_C, sizeof(STATUS), 1, fp);
 978
 979     //NSLog(@"creepy jude...");
 980 }
 981
 982 -(void)readUnitChipLD:(FILE*)fp val:(LOADCHIPD*)val{
 983
 984     val->chipNumb = (int)[self readInt:fp];
 985     val->name = [[self readNSString:fp strOut:val->name] retain];
 986     val->nameID = [[self readNSString:fp strOut:val->nameID] retain];
 987
 988
 989
 990     fread(&val->R_C, sizeof(RESIST), 1, fp);
 991     fread(&val->S_C, sizeof(STATUS2), 1, fp);
 992
 993     //NSLog(@"creepy jude...2");
 994 }
 995
 996 -(void)readMapScript:(FILE*)fp{
 997
 998     sdd2[datRow].MS.EGClight.endType1 = (int)[self readInt:fp];
 999     sdd2[datRow].MS.EGClight.endType2 = (int)[self readInt:fp];
1000     for(int i = 0;i < 64;i++)
1001         sdd2[datRow].MS.EGClight.etValue1[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGClight.etValue1[i]] retain];
1002     for(int i = 0;i < 64;i++)
1003         sdd2[datRow].MS.EGClight.etValue2[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGClight.etValue2[i]] retain];
1004
1005     sdd2[datRow].MS.EGCdark.endType1 = (int)[self readInt:fp];
1006     sdd2[datRow].MS.EGCdark.endType2 = (int)[self readInt:fp];
1007     for(int i = 0;i < 64;i++)
1008         sdd2[datRow].MS.EGCdark.etValue1[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGCdark.etValue1[i]] retain];
1009     for(int i = 0;i < 64;i++)
1010         sdd2[datRow].MS.EGCdark.etValue2[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.EGCdark.etValue2[i]] retain];
1011
1012     sdd2[datRow].MS.playerSet1 = (int)[self readInt:fp];
1013     sdd2[datRow].MS.playerSet2 = (int)[self readInt:fp];
1014     sdd2[datRow].MS.battleSetMode = (int)[self readInt:fp];
1015     sdd2[datRow].MS.employAllowedFlag = (int)[self readInt:fp];
1016     sdd2[datRow].MS.buildAllowedFlag = (int)[self readInt:fp];
1017     sdd2[datRow].MS.summonAllowedFlag = (int)[self readInt:fp];
1018
1019     sdd2[datRow].MS.scenarioSetMode = (int)[self readInt:fp];
1020     sdd2[datRow].MS.scenarioNumbCrnt = (int)[self readInt:fp];
1021     sdd2[datRow].MS.scenarioNumbNext = (int)[self readInt:fp];
1022
1023     for(int i = 0;i < 4096;i++)
1024         sdd2[datRow].MS.guildListRegist[i] = (int)[self readInt:fp];
1025     sdd2[datRow].MS.guildListRegistNum11 = (int)[self readInt:fp];
1026     sdd2[datRow].MS.guildListRegistNum12 = (int)[self readInt:fp];
1027
1028     for(int i = 0;i < 4096;i++)
1029         sdd2[datRow].MS.guildListRegist2[i] = (int)[self readInt:fp];
1030     sdd2[datRow].MS.guildListRegistNum21 = (int)[self readInt:fp];
1031     sdd2[datRow].MS.guildListRegistNum22 = (int)[self readInt:fp];
1032
1033
1034     sdd2[datRow].MS.SCRPTnameCnt = (int)[self readInt:fp];
1035     sdd2[datRow].MS.SCRPTname = [NSMutableArray new];
1036     for(int j = 0;j < sdd2[datRow].MS.SCRPTnameCnt;j++)
1037         [sdd2[datRow].MS.SCRPTname addObject:@""];
1038     for(int i = 0;i < sdd2[datRow].MS.SCRPTnameCnt;i++)
1039         sdd2[datRow].MS.SCRPTname[i] = [[self readNSString:fp strOut:sdd2[datRow].MS.SCRPTname[i]] retain];
1040
1041
1042     MAPSCRIPTD *SMSDtop = sdd2[datRow].MS.D;
1043
1044     sdd2[datRow].MS.Dcnt = (int)[self readInt:fp];
1045
1046     for (int i = 0;i < sdd2[datRow].MS.Dcnt;i++) {
1047
1048         if(i == 0){
1049             sdd2[datRow].MS.D = calloc(1, sizeof(MAPSCRIPTD));
1050             if(i + 1 < sdd2[datRow].MS.Dcnt)
1051                 sdd2[datRow].MS.D->next = calloc(1, sizeof(MAPSCRIPTD));
1052             SMSDtop = sdd2[datRow].MS.D;
1053
1054         }else if(i + 1 < sdd2[datRow].MS.Dcnt)
1055             sdd2[datRow].MS.D->next = calloc(1, sizeof(MAPSCRIPTD));
1056
1057         sdd2[datRow].MS.D->SCRPTcnt = (int)[self readInt:fp];
1058         sdd2[datRow].MS.D->SCRPT = [NSMutableArray new];
1059         for(int j = 0;j < sdd2[datRow].MS.D->SCRPTcnt;j++)
1060             [sdd2[datRow].MS.D->SCRPT addObject:@""];
1061         for(int j = 0;j < sdd2[datRow].MS.D->SCRPTcnt;j++)
1062             sdd2[datRow].MS.D->SCRPT[j] = [[self readNSString:fp strOut:sdd2[datRow].MS.D->SCRPT[j]] retain];
1063
1064
1065         sdd2[datRow].MS.D->endFlag = (int)[self readInt:fp];
1066         sdd2[datRow].MS.D->index = (int)[self readInt:fp];
1067         sdd2[datRow].MS.D->x = (int)[self readInt:fp];
1068         sdd2[datRow].MS.D->y = (int)[self readInt:fp];
1069         sdd2[datRow].MS.D->type = (int)[self readInt:fp];
1070         sdd2[datRow].MS.D->ET1 = (int)[self readInt:fp];
1071         sdd2[datRow].MS.D->ET2 = (int)[self readInt:fp];
1072         sdd2[datRow].MS.D->ET3 = (int)[self readInt:fp];
1073         sdd2[datRow].MS.D->ET4 = (int)[self readInt:fp];
1074         sdd2[datRow].MS.D->ETtype = (int)[self readInt:fp];
1075         sdd2[datRow].MS.D->onlyInitialDeley = (int)[self readInt:fp];
1076         sdd2[datRow].MS.D->initialDeleyedFlag = (int)[self readInt:fp];
1077         sdd2[datRow].MS.D->switch1f = (int)[self readInt:fp];
1078         sdd2[datRow].MS.D->switch2f = (int)[self readInt:fp];
1079
1080         sdd2[datRow].MS.D->switch1cnt = (int)[self readInt:fp];
1081         sdd2[datRow].MS.D->switch2cnt = (int)[self readInt:fp];
1082
1083         if(sdd2[datRow].MS.D->switch1cnt > 0)
1084             sdd2[datRow].MS.D->switch1 = calloc(sdd2[datRow].MS.D->switch1cnt, sizeof(int));
1085         for(int j = 0;j < sdd2[datRow].MS.D->switch1cnt;j++) {
1086             *(sdd2[datRow].MS.D->switch1 + j) = (int)[self readInt:fp];
1087         }
1088         if(sdd2[datRow].MS.D->switch2cnt > 0)
1089             sdd2[datRow].MS.D->switch2 = calloc(sdd2[datRow].MS.D->switch2cnt, sizeof(int));
1090         for(int j = 0;j < sdd2[datRow].MS.D->switch2cnt;j++) {
1091             *(sdd2[datRow].MS.D->switch2 + j) = (int)[self readInt:fp];
1092         }
1093
1094
1095         MAPSCRIPT0 *SMSPtop = sdd2[datRow].MS.D->P;
1096
1097         sdd2[datRow].MS.D->Pcnt = (int)[self readInt:fp];
1098
1099         for (int j = 0;j < sdd2[datRow].MS.D->Pcnt;j++) {
1100
1101             if(j == 0){
1102                 sdd2[datRow].MS.D->P = calloc(1, sizeof(MAPSCRIPT0));
1103                 if(j + 1 < sdd2[datRow].MS.D->Pcnt)
1104                     sdd2[datRow].MS.D->P->next = calloc(1, sizeof(MAPSCRIPT0));
1105                 SMSPtop = sdd2[datRow].MS.D->P;
1106             }else if(j + 1 < sdd2[datRow].MS.D->Pcnt)
1107                 sdd2[datRow].MS.D->P->next = calloc(1, sizeof(MAPSCRIPT0));
1108
1109             sdd2[datRow].MS.D->P->endFlag = (int)[self readInt:fp];
1110             sdd2[datRow].MS.D->P->succeessfulFlag = (int)[self readInt:fp];
1111             sdd2[datRow].MS.D->P->indent = (int)[self readInt:fp];
1112             sdd2[datRow].MS.D->P->val = (int)[self readInt:fp];
1113             sdd2[datRow].MS.D->P->valCnt = (int)[self readInt:fp];
1114             sdd2[datRow].MS.D->P->timerMin = (int)[self readInt:fp];
1115             sdd2[datRow].MS.D->P->timerSec = (int)[self readInt:fp];
1116             sdd2[datRow].MS.D->P->timerEntire = (int)[self readInt:fp];
1117
1118             sdd2[datRow].MS.D->P->timerFlag = (int)[self readInt:fp];
1119             sdd2[datRow].MS.D->P->timerVisible = (int)[self readInt:fp];
1120             sdd2[datRow].MS.D->P->timerRun = (int)[self readInt:fp];
1121             sdd2[datRow].MS.D->P->timerMode = (int)[self readInt:fp];
1122             sdd2[datRow].MS.D->P->wait = (int)[self readInt:fp];
1123             sdd2[datRow].MS.D->P->titleBack = (int)[self readInt:fp];
1124
1125             sdd2[datRow].MS.D->P->label = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->label] retain];
1126             sdd2[datRow].MS.D->P->labelJump = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->labelJump] retain];
1127             sdd2[datRow].MS.D->P->memo = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->memo] retain];
1128
1129             sdd2[datRow].MS.D->P->switch1cnt = (int)[self readInt:fp];
1130             sdd2[datRow].MS.D->P->switch2cnt = (int)[self readInt:fp];
1131
1132             if(sdd2[datRow].MS.D->P->switch1cnt > 0)
1133                 sdd2[datRow].MS.D->P->switch1 = calloc(sdd2[datRow].MS.D->P->switch1cnt, sizeof(int));
1134             for(int k = 0;k < sdd2[datRow].MS.D->P->switch1cnt;k++) {
1135                 *(sdd2[datRow].MS.D->P->switch1 + k) = (int)[self readInt:fp];
1136             }
1137
1138             if(sdd2[datRow].MS.D->P->switch2cnt > 0)
1139                 sdd2[datRow].MS.D->P->switch2 = calloc(sdd2[datRow].MS.D->P->switch2cnt, sizeof(int));
1140             for(int k = 0;k < sdd2[datRow].MS.D->P->switch2cnt;k++) {
1141                 *(sdd2[datRow].MS.D->P->switch2 + k) = (int)[self readInt:fp];
1142             }
1143
1144             [self readMapScriptBGM:fp];
1145             [self readMapScriptSE:fp];
1146             [self readMapScriptSC:fp];
1147             [self readMapScriptGAOV:fp];
1148
1149             sdd2[datRow].MS.D->P->type = (int)[self readInt:fp];
1150
1151             //なぜかゴミ文字列が入ったから処置
1152             if(sdd2[datRow].MS.D->P->type != 7)
1153                 sdd2[datRow].MS.D->P->label = NULL;
1154             if(sdd2[datRow].MS.D->P->type != 8)
1155                 sdd2[datRow].MS.D->P->labelJump = NULL;
1156             if(sdd2[datRow].MS.D->P->type != 9)
1157                 sdd2[datRow].MS.D->P->memo = NULL;
1158
1159             if(sdd2[datRow].MS.D->P->type == 0)
1160                 [self readMapScript1:fp];
1161
1162             if(sdd2[datRow].MS.D->P->type == 1){
1163             MAPSCRIPT2 *SMSP2top = sdd2[datRow].MS.D->P->S2;
1164
1165             sdd2[datRow].MS.D->P->S2cnt = (int)[self readInt:fp];
1166
1167             for (int k = 0;k < sdd2[datRow].MS.D->P->S2cnt;k++) {
1168                 if(k == 0){
1169                     sdd2[datRow].MS.D->P->S2 = calloc(1, sizeof(MAPSCRIPT2));
1170                     if(k + 1 < sdd2[datRow].MS.D->P->S2cnt)
1171                         sdd2[datRow].MS.D->P->S2->next = calloc(1, sizeof(MAPSCRIPT2));
1172                     SMSP2top = sdd2[datRow].MS.D->P->S2;
1173                 }else if(k + 1 < sdd2[datRow].MS.D->P->S2cnt)
1174                     sdd2[datRow].MS.D->P->S2->next = calloc(1, sizeof(MAPSCRIPT2));
1175                 [self readMapScript2:fp];
1176                 sdd2[datRow].MS.D->P->S2 = sdd2[datRow].MS.D->P->S2->next;
1177             }
1178             if(sdd2[datRow].MS.D->P->S2)
1179                 sdd2[datRow].MS.D->P->S2->next = NULL;
1180             sdd2[datRow].MS.D->P->S2 = SMSP2top;
1181             }
1182
1183
1184             if(sdd2[datRow].MS.D->P->type == 22){
1185             MAPSCRIPT3 *SMSP3top = sdd2[datRow].MS.D->P->S3;
1186
1187             sdd2[datRow].MS.D->P->S3cnt = (int)[self readInt:fp];
1188
1189             for (int k = 0;k < sdd2[datRow].MS.D->P->S3cnt;k++) {
1190                 if(k == 0){
1191                     sdd2[datRow].MS.D->P->S3 = calloc(1, sizeof(MAPSCRIPT3));
1192                     if(k + 1 < sdd2[datRow].MS.D->P->S3cnt)
1193                         sdd2[datRow].MS.D->P->S3->next = calloc(1, sizeof(MAPSCRIPT3));
1194                     SMSP3top = sdd2[datRow].MS.D->P->S3;
1195                 }else if(k + 1 < sdd2[datRow].MS.D->P->S3cnt)
1196                     sdd2[datRow].MS.D->P->S3->next = calloc(1, sizeof(MAPSCRIPT3));
1197                 [self readMapScript3:fp];
1198                 sdd2[datRow].MS.D->P->S3 = sdd2[datRow].MS.D->P->S3->next;
1199             }sdd2[datRow].MS.D->P->S3 = SMSP3top;
1200             }
1201             if(sdd2[datRow].MS.D->P->type == 6)
1202                 [self readMapScript4:fp];
1203
1204             if(sdd2[datRow].MS.D->P->type == 23){
1205             MAPSCRIPT5 *SMSP5top = sdd2[datRow].MS.D->P->S5;
1206
1207             sdd2[datRow].MS.D->P->S5cnt = (int)[self readInt:fp];
1208
1209             for (int k = 0;k < sdd2[datRow].MS.D->P->S5cnt;k++) {
1210                 if(k == 0){
1211                     sdd2[datRow].MS.D->P->S5 = calloc(1, sizeof(MAPSCRIPT5));
1212                     if(k + 1 < sdd2[datRow].MS.D->P->S5cnt)
1213                         sdd2[datRow].MS.D->P->S5->next = calloc(1, sizeof(MAPSCRIPT5));
1214                     SMSP5top = sdd2[datRow].MS.D->P->S5;
1215                 }else if(k + 1 < sdd2[datRow].MS.D->P->S5cnt)
1216                     sdd2[datRow].MS.D->P->S5->next = calloc(1, sizeof(MAPSCRIPT5));
1217                 [self readMapScript5:fp];
1218                 sdd2[datRow].MS.D->P->S5 = sdd2[datRow].MS.D->P->S5->next;
1219             }sdd2[datRow].MS.D->P->S5 = SMSP5top;
1220             }
1221
1222             if(sdd2[datRow].MS.D->P->type == 10)
1223                 [self readMapScript6:fp];
1224
1225
1226
1227             sdd2[datRow].MS.D->P = sdd2[datRow].MS.D->P->next;
1228         }
1229         if(sdd2[datRow].MS.D->P)
1230             sdd2[datRow].MS.D->P->next = NULL;
1231
1232         sdd2[datRow].MS.D->P = SMSPtop;
1233
1234
1235         sdd2[datRow].MS.D = sdd2[datRow].MS.D->next;
1236     }
1237     if(sdd2[datRow].MS.D)
1238         sdd2[datRow].MS.D->next = NULL;
1239
1240     sdd2[datRow].MS.D = SMSDtop;
1241
1242
1243
1244
1245 }
1246
1247 -(void)readMapScript1:(FILE*)fp{
1248
1249     sdd2[datRow].MS.D->P->S1.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.name] retain];
1250     sdd2[datRow].MS.D->P->S1.str = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.str] retain];
1251     sdd2[datRow].MS.D->P->S1.iName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.iName] retain];
1252     sdd2[datRow].MS.D->P->S1.nameID = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S1.nameID] retain];
1253
1254     for(int k = 0; k < UCN;k++){
1255         if(sdd2[datRow].MS.D->P->S1.nameID)
1256             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:UC[k].nameID]){
1257                 sdd2[datRow].MS.D->P->S1.img = [UC[k].imgb retain];
1258                 break;
1259             }
1260     }
1261     for(int k = 0; k < LCN;k++){
1262         if(sdd2[datRow].MS.D->P->S1.nameID)
1263             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:LC[k].nameID]){
1264                 sdd2[datRow].MS.D->P->S1.img = [LC[k].imgb retain];
1265                 break;
1266             }
1267     }
1268     EIMG = EIMGtop;
1269     while (EIMG) {
1270         if(sdd2[datRow].MS.D->P->S1.nameID)
1271             if([sdd2[datRow].MS.D->P->S1.nameID isEqualToString:EIMG->name]){
1272                 sdd2[datRow].MS.D->P->S1.img = [EIMG->img retain];
1273                 break;
1274             }
1275         EIMG = EIMG->next;
1276     }EIMG = EIMGtop;
1277
1278     /*
1279      NSString *name;
1280      NSString *str;
1281      //NSImage *img;
1282      NSString *iName;
1283      NSString *nameID;
1284      */
1285 }
1286
1287 -(void)readMapScript2:(FILE*)fp{
1288
1289     sdd2[datRow].MS.D->P->S2->selection = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S2->selection] retain];
1290     sdd2[datRow].MS.D->P->S2->labelJump = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S2->labelJump] retain];
1291
1292     /*
1293      //struct _MAPSCRIPT2 *next;
1294
1295      NSString *selection;
1296      NSString *labelJump;
1297      */
1298 }
1299
1300 -(void)readMapScript3:(FILE*)fp{
1301
1302     sdd2[datRow].MS.D->P->S3->x = (int)[self readInt:fp];
1303     sdd2[datRow].MS.D->P->S3->y = (int)[self readInt:fp];
1304     sdd2[datRow].MS.D->P->S3->flag = (int)[self readInt:fp];
1305
1306     sdd2[datRow].MS.D->P->S3->type = (int)[self readInt:fp];
1307     sdd2[datRow].MS.D->P->S3->team = (int)[self readInt:fp];
1308
1309     sdd2[datRow].MS.D->P->S3->unitNum = (int)[self readInt:fp];
1310     sdd2[datRow].MS.D->P->S3->loadInt = (int)[self readInt:fp];
1311
1312     sdd2[datRow].MS.D->P->S3->U = UC[sdd2[datRow].MS.D->P->S3->unitNum];
1313
1314     /*
1315      //struct _MAPSCRIPT3 *next;
1316
1317      int x;
1318      int y;
1319      bool flag;
1320
1321      int type;
1322      int team;
1323
1324      //UNITCHIP U;
1325      int unitNum;
1326
1327      int loadInt;
1328      */
1329 }
1330
1331 -(void)readMapScript4:(FILE*)fp{
1332
1333     sdd2[datRow].MS.D->P->S4.lagFixFlag = (int)[self readInt:fp];
1334     sdd2[datRow].MS.D->P->S4.COMPrabel = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S4.COMPrabel] retain];
1335     sdd2[datRow].MS.D->P->S4.FAILrabel = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S4.FAILrabel] retain];
1336
1337     sdd2[datRow].MS.D->P->S4.suicchiFlag = (int)[self readInt:fp];
1338
1339     sdd2[datRow].MS.D->P->S4.suicchiCnt = (int)[self readInt:fp];
1340
1341     if(sdd2[datRow].MS.D->P->S4.suicchiCnt > 0)
1342         sdd2[datRow].MS.D->P->S4.suicchi = calloc(sdd2[datRow].MS.D->P->S4.suicchiCnt, sizeof(int));
1343     for(int l = 0;l < sdd2[datRow].MS.D->P->S4.suicchiCnt;l++) {
1344         *(sdd2[datRow].MS.D->P->S4.suicchi + l) = (int)[self readInt:fp];
1345     }
1346
1347     sdd2[datRow].MS.D->P->S4.suicchiONOFF = (int)[self readInt:fp];
1348
1349     sdd2[datRow].MS.D->P->S4.hensuFlag = (int)[self readInt:fp];
1350     sdd2[datRow].MS.D->P->S4.hensu1 = (int)[self readInt:fp];
1351     sdd2[datRow].MS.D->P->S4.teisuFlag = (int)[self readInt:fp];
1352     sdd2[datRow].MS.D->P->S4.teisuValue = (int)[self readInt:fp];
1353     sdd2[datRow].MS.D->P->S4.hensu2flag = (int)[self readInt:fp];
1354     sdd2[datRow].MS.D->P->S4.hensu2 = (int)[self readInt:fp];
1355     sdd2[datRow].MS.D->P->S4.hensuType = (int)[self readInt:fp];
1356
1357     sdd2[datRow].MS.D->P->S4.timerFlag = (int)[self readInt:fp];
1358     sdd2[datRow].MS.D->P->S4.timerMin = (int)[self readInt:fp];
1359     sdd2[datRow].MS.D->P->S4.timerSec = (int)[self readInt:fp];
1360     sdd2[datRow].MS.D->P->S4.timerType = (int)[self readInt:fp];
1361
1362     sdd2[datRow].MS.D->P->S4.unitNumFlag = (int)[self readInt:fp];
1363     sdd2[datRow].MS.D->P->S4.team = (int)[self readInt:fp];
1364     sdd2[datRow].MS.D->P->S4.unitNum = (int)[self readInt:fp];
1365     sdd2[datRow].MS.D->P->S4.unitType = (int)[self readInt:fp];
1366     sdd2[datRow].MS.D->P->S4.unitTypeFlag = (int)[self readInt:fp];
1367
1368
1369
1370     UNIT2 *subjTop = sdd2[datRow].MS.D->P->S4.subj;
1371
1372     sdd2[datRow].MS.D->P->S4.subjCnt = (int)[self readInt:fp];
1373
1374     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.subjCnt;k++) {
1375         if(k == 0){
1376             sdd2[datRow].MS.D->P->S4.subj = calloc(1, sizeof(UNIT2));
1377             if(k + 1 < sdd2[datRow].MS.D->P->S4.subjCnt)
1378                 sdd2[datRow].MS.D->P->S4.subj->next = calloc(1, sizeof(UNIT2));
1379             subjTop = sdd2[datRow].MS.D->P->S4.subj;
1380         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.subjCnt)
1381             sdd2[datRow].MS.D->P->S4.subj->next = calloc(1, sizeof(UNIT2));
1382         [self readMapScript4subj:fp];
1383         sdd2[datRow].MS.D->P->S4.subj = sdd2[datRow].MS.D->P->S4.subj->next;
1384     }sdd2[datRow].MS.D->P->S4.subj = subjTop;
1385
1386
1387
1388     sdd2[datRow].MS.D->P->S4.placeFlag = (int)[self readInt:fp];
1389     PLACEMENT *waypTop = sdd2[datRow].MS.D->P->S4.wayp;
1390
1391     sdd2[datRow].MS.D->P->S4.waypCnt = (int)[self readInt:fp];
1392
1393     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.waypCnt;k++) {
1394         if(k == 0){
1395             sdd2[datRow].MS.D->P->S4.wayp = calloc(1, sizeof(PLACEMENT));
1396             if(k + 1 < sdd2[datRow].MS.D->P->S4.waypCnt)
1397                 sdd2[datRow].MS.D->P->S4.wayp->next = calloc(1, sizeof(PLACEMENT));
1398             waypTop = sdd2[datRow].MS.D->P->S4.wayp;
1399         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.waypCnt)
1400             sdd2[datRow].MS.D->P->S4.wayp->next = calloc(1, sizeof(PLACEMENT));
1401         [self readMapScript4wayp:fp];
1402         sdd2[datRow].MS.D->P->S4.wayp = sdd2[datRow].MS.D->P->S4.wayp->next;
1403     }sdd2[datRow].MS.D->P->S4.wayp = waypTop;
1404
1405     sdd2[datRow].MS.D->P->S4.unitCMDflag = (int)[self readInt:fp];
1406     sdd2[datRow].MS.D->P->S4.unitCMD = (int)[self readInt:fp];
1407
1408
1409     sdd2[datRow].MS.D->P->S4.objeFlag = (int)[self readInt:fp];
1410     UNIT2 *objeTop = sdd2[datRow].MS.D->P->S4.obje;
1411
1412     sdd2[datRow].MS.D->P->S4.objeCnt = (int)[self readInt:fp];
1413
1414     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.objeCnt;k++) {
1415         if(k == 0){
1416             sdd2[datRow].MS.D->P->S4.obje = calloc(1, sizeof(UNIT2));
1417             if(k + 1 < sdd2[datRow].MS.D->P->S4.objeCnt)
1418                 sdd2[datRow].MS.D->P->S4.obje->next = calloc(1, sizeof(UNIT2));
1419             objeTop = sdd2[datRow].MS.D->P->S4.obje;
1420         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.objeCnt)
1421             sdd2[datRow].MS.D->P->S4.obje->next = calloc(1, sizeof(UNIT2));
1422         [self readMapScript4obje:fp];
1423         sdd2[datRow].MS.D->P->S4.obje = sdd2[datRow].MS.D->P->S4.obje->next;
1424     }sdd2[datRow].MS.D->P->S4.obje = objeTop;
1425
1426
1427     sdd2[datRow].MS.D->P->S4.objeRange = (int)[self readInt:fp];
1428
1429
1430     sdd2[datRow].MS.D->P->S4.buildFlag = (int)[self readInt:fp];
1431     BUILD2 *buildTop = sdd2[datRow].MS.D->P->S4.build;
1432
1433     sdd2[datRow].MS.D->P->S4.buildCnt = (int)[self readInt:fp];
1434
1435     for (int k = 0;k < sdd2[datRow].MS.D->P->S4.buildCnt;k++) {
1436         if(k == 0){
1437             sdd2[datRow].MS.D->P->S4.build = calloc(1, sizeof(BUILD2));
1438             if(k + 1 < sdd2[datRow].MS.D->P->S4.buildCnt)
1439                 sdd2[datRow].MS.D->P->S4.build->next = calloc(1, sizeof(BUILD2));
1440             buildTop = sdd2[datRow].MS.D->P->S4.build;
1441         }else if(k + 1 < sdd2[datRow].MS.D->P->S4.buildCnt)
1442             sdd2[datRow].MS.D->P->S4.build->next = calloc(1, sizeof(BUILD2));
1443         [self readMapScript4build:fp];
1444         sdd2[datRow].MS.D->P->S4.build = sdd2[datRow].MS.D->P->S4.build->next;
1445     }sdd2[datRow].MS.D->P->S4.build = buildTop;
1446
1447
1448 }
1449
1450 -(void)readMapScript4subj:(FILE*)fp{
1451
1452
1453     sdd2[datRow].MS.D->P->S4.subj->team = (int)[self readInt:fp];
1454     sdd2[datRow].MS.D->P->S4.subj->x = (int)[self readInt:fp];
1455     sdd2[datRow].MS.D->P->S4.subj->y = (int)[self readInt:fp];
1456
1457     /*
1458      //struct _UNIT2 *next;
1459      //UNITCHIP C;
1460
1461      int team;
1462      int x;
1463      int y;
1464      */
1465 }
1466
1467 -(void)readMapScript4wayp:(FILE*)fp{
1468
1469     sdd2[datRow].MS.D->P->S4.wayp->type = (int)[self readInt:fp];
1470     sdd2[datRow].MS.D->P->S4.wayp->x = (int)[self readInt:fp];
1471     sdd2[datRow].MS.D->P->S4.wayp->y = (int)[self readInt:fp];
1472     sdd2[datRow].MS.D->P->S4.wayp->z = (int)[self readInt:fp];
1473     sdd2[datRow].MS.D->P->S4.wayp->x2 = (int)[self readInt:fp];
1474     sdd2[datRow].MS.D->P->S4.wayp->y2 = (int)[self readInt:fp];
1475
1476     /*
1477      //struct _PLACEMENT *next;
1478
1479      int type;
1480      int x;
1481      int y;
1482      int z;
1483      int x2;
1484      int y2;
1485      */
1486 }
1487
1488 -(void)readMapScript4obje:(FILE*)fp{
1489
1490     sdd2[datRow].MS.D->P->S4.obje->team = (int)[self readInt:fp];
1491     sdd2[datRow].MS.D->P->S4.obje->x = (int)[self readInt:fp];
1492     sdd2[datRow].MS.D->P->S4.obje->y = (int)[self readInt:fp];
1493
1494     /*
1495      //struct _UNIT2 *next;
1496      //UNITCHIP C;
1497
1498      int team;
1499      int x;
1500      int y;
1501      */
1502 }
1503
1504 -(void)readMapScript4build:(FILE*)fp{
1505
1506     sdd2[datRow].MS.D->P->S4.build->team = (int)[self readInt:fp];
1507     sdd2[datRow].MS.D->P->S4.build->x = (int)[self readInt:fp];
1508     sdd2[datRow].MS.D->P->S4.build->y = (int)[self readInt:fp];
1509
1510     /*
1511      //struct _BUILD2 *next;
1512      //struct _BUILDCHIP *C;
1513
1514      int team;
1515      int x;
1516      int y;
1517      */
1518 }
1519
1520 -(void)readMapScript5:(FILE*)fp{
1521
1522     sdd2[datRow].MS.D->P->S5->x = (int)[self readInt:fp];
1523     sdd2[datRow].MS.D->P->S5->y = (int)[self readInt:fp];
1524     sdd2[datRow].MS.D->P->S5->type = (int)[self readInt:fp];
1525     sdd2[datRow].MS.D->P->S5->team = (int)[self readInt:fp];
1526     sdd2[datRow].MS.D->P->S5->unitNum = (int)[self readInt:fp];
1527     sdd2[datRow].MS.D->P->S5->saveInt = (int)[self readInt:fp];
1528
1529     sdd2[datRow].MS.D->P->S5->U = UC[sdd2[datRow].MS.D->P->S5->unitNum];
1530
1531     /*
1532      //struct _MAPSCRIPT5 *next;
1533
1534      int x;
1535      int y;
1536
1537      int type;
1538      int team;
1539
1540      //UNITCHIP U;
1541      int unitNum;
1542
1543      int saveInt;
1544      */
1545 }
1546
1547
1548 -(void)readMapScript6:(FILE*)fp{
1549
1550     sdd2[datRow].MS.D->P->S6.team = (int)[self readInt:fp];
1551
1552     sdd2[datRow].MS.D->P->S6.RCsupply = (int)[self readInt:fp];
1553     sdd2[datRow].MS.D->P->S6.RCfood = (int)[self readInt:fp];
1554     sdd2[datRow].MS.D->P->S6.RCmoney = (int)[self readInt:fp];
1555
1556     sdd2[datRow].MS.D->P->S6.RCsupplyAdd = (int)[self readInt:fp];
1557     sdd2[datRow].MS.D->P->S6.RCfoodAdd = (int)[self readInt:fp];
1558     sdd2[datRow].MS.D->P->S6.RCmoneyAdd = (int)[self readInt:fp];
1559
1560     sdd2[datRow].MS.D->P->S6.RCsupplyValue = (int)[self readInt:fp];
1561     sdd2[datRow].MS.D->P->S6.RCfoodValue = (int)[self readInt:fp];
1562     sdd2[datRow].MS.D->P->S6.RCmoneyValue = (int)[self readInt:fp];
1563
1564     sdd2[datRow].MS.D->P->S6.RCsupplySelect = (int)[self readInt:fp];
1565     sdd2[datRow].MS.D->P->S6.RCfoodSelect = (int)[self readInt:fp];
1566     sdd2[datRow].MS.D->P->S6.RCmoneySelect = (int)[self readInt:fp];
1567
1568     sdd2[datRow].MS.D->P->S6.RCsupplyS = (int)[self readInt:fp];
1569     sdd2[datRow].MS.D->P->S6.RCfoodS = (int)[self readInt:fp];
1570     sdd2[datRow].MS.D->P->S6.RCmoneyS = (int)[self readInt:fp];
1571
1572 }
1573
1574 -(void)readMapScript7:(FILE*)fp{
1575
1576     sdd2[datRow].MS.D->P->S7.type = (int)[self readInt:fp];
1577
1578     sdd2[datRow].MS.D->P->S7.maxFlag = (int)[self readInt:fp];
1579     sdd2[datRow].MS.D->P->S7.percentFlag = (int)[self readInt:fp];
1580     sdd2[datRow].MS.D->P->S7.type = (int)[self readInt:fp];
1581
1582     sdd2[datRow].MS.D->P->S7.fluctuate = (int)[self readInt:fp];
1583     sdd2[datRow].MS.D->P->S7.valueType = (int)[self readInt:fp];
1584
1585     sdd2[datRow].MS.D->P->S7.value = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->S7.value] retain];
1586
1587     sdd2[datRow].MS.D->P->S7.rdm = (int)[self readInt:fp];
1588
1589     sdd2[datRow].MS.D->P->S7.teamFlag = (int)[self readInt:fp];
1590     sdd2[datRow].MS.D->P->S7.team = (int)[self readInt:fp];
1591
1592     sdd2[datRow].MS.D->P->S7.unitFlag = (int)[self readInt:fp];
1593     sdd2[datRow].MS.D->P->S7.valueFlag = (int)[self readInt:fp];
1594
1595
1596     sdd2[datRow].MS.D->P->S7.S7Acnt = (int)[self readInt:fp];
1597     sdd2[datRow].MS.D->P->S7.S7Bcnt = (int)[self readInt:fp];
1598
1599     for (int k = 0;k < sdd2[datRow].MS.D->P->S7.S7Acnt;k++) {
1600         if(k == 0){
1601             sdd2[datRow].MS.D->P->S7.A = calloc(1, sizeof(MAPSCRIPT7A));
1602             if(k + 1 < sdd2[datRow].MS.D->P->S7.S7Acnt)
1603                 sdd2[datRow].MS.D->P->S7.A->next = calloc(1, sizeof(MAPSCRIPT7A));
1604             MS7Atop = sdd2[datRow].MS.D->P->S7.A;
1605         }else if(k + 1 < sdd2[datRow].MS.D->P->S7.S7Acnt)
1606             sdd2[datRow].MS.D->P->S7.A->next = calloc(1, sizeof(MAPSCRIPT7A));
1607
1608         sdd2[datRow].MS.D->P->S7.A->x = (int)[self readInt:fp];
1609         sdd2[datRow].MS.D->P->S7.A->y = (int)[self readInt:fp];
1610         sdd2[datRow].MS.D->P->S7.A->team = (int)[self readInt:fp];
1611         sdd2[datRow].MS.D->P->S7.A->unitNum = (int)[self readInt:fp];
1612
1613         sdd2[datRow].MS.D->P->S7.A = sdd2[datRow].MS.D->P->S7.A->next;
1614     }sdd2[datRow].MS.D->P->S7.A = MS7Atop;
1615
1616
1617     for (int k = 0;k < sdd2[datRow].MS.D->P->S7.S7Bcnt;k++) {
1618         if(k == 0){
1619             sdd2[datRow].MS.D->P->S7.B = calloc(1, sizeof(MAPSCRIPT7B));
1620             if(k + 1 < sdd2[datRow].MS.D->P->S7.S7Bcnt)
1621                 sdd2[datRow].MS.D->P->S7.B->next = calloc(1, sizeof(MAPSCRIPT7B));
1622             MS7Btop = sdd2[datRow].MS.D->P->S7.B;
1623         }else if(k + 1 < sdd2[datRow].MS.D->P->S7.S7Bcnt)
1624             sdd2[datRow].MS.D->P->S7.B->next = calloc(1, sizeof(MAPSCRIPT7B));
1625
1626         sdd2[datRow].MS.D->P->S7.B->x = (int)[self readInt:fp];
1627         sdd2[datRow].MS.D->P->S7.B->y = (int)[self readInt:fp];
1628         sdd2[datRow].MS.D->P->S7.B->team = (int)[self readInt:fp];
1629         sdd2[datRow].MS.D->P->S7.B->unitNum = (int)[self readInt:fp];
1630         sdd2[datRow].MS.D->P->S7.B->saveInt = (int)[self readInt:fp];
1631
1632         sdd2[datRow].MS.D->P->S7.B = sdd2[datRow].MS.D->P->S7.B->next;
1633     }sdd2[datRow].MS.D->P->S7.B = MS7Btop;
1634
1635 }
1636
1637 -(void)readMapScriptBGM:(FILE*)fp{
1638
1639     NSString *directoryPath;
1640
1641     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1642     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1643
1644
1645     NSString* Cpath = @"data/BGM/";
1646     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1647
1648     sdd2[datRow].MS.D->P->BGM.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->BGM.name] retain];
1649     sdd2[datRow].MS.D->P->BGM.fName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->BGM.fName] retain];
1650
1651     sdd2[datRow].MS.D->P->BGM.snd = [[[NSSound alloc] initWithContentsOfURL:
1652                                       [NSURL fileURLWithPath:sdd2[datRow].MS.D->P->BGM.fName] byReference:NO] retain];
1653
1654     /*
1655      //NSString *name;
1656      NSString *fName;
1657      //NSSound *snd;
1658      */
1659 }
1660
1661 -(void)readMapScriptSE:(FILE*)fp{
1662
1663     NSString *directoryPath;
1664
1665     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1666     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1667
1668
1669     NSString* Cpath = @"data/BGM/";
1670     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1671
1672     sdd2[datRow].MS.D->P->SE.name = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->SE.name] retain];
1673     sdd2[datRow].MS.D->P->SE.fName = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->SE.fName] retain];
1674
1675     sdd2[datRow].MS.D->P->SE.snd = [[[NSSound alloc] initWithContentsOfURL:
1676                                       [NSURL fileURLWithPath:sdd2[datRow].MS.D->P->SE.fName] byReference:NO] retain];
1677
1678     /*
1679      NSString *name;
1680      NSString *fName;
1681      //NSSound *snd;
1682      */
1683 }
1684
1685 -(void)readMapScriptSC:(FILE*)fp{
1686
1687     sdd2[datRow].MS.D->P->sc.scFlag = (int)[self readInt:fp];
1688     sdd2[datRow].MS.D->P->sc.edcdFlag = (int)[self readInt:fp];
1689
1690     /*
1691      bool scFlag;
1692      bool edcdFlag;
1693      */
1694 }
1695
1696 -(void)readMapScriptGAOV:(FILE*)fp{
1697
1698
1699     sdd2[datRow].MS.D->P->gaov.fNname = [[self readNSString:fp strOut:sdd2[datRow].MS.D->P->gaov.fNname] retain];
1700     sdd2[datRow].MS.D->P->gaov.gaovFlag = (int)[self readInt:fp];
1701     sdd2[datRow].MS.D->P->gaov.edcdFlag = (int)[self readInt:fp];
1702
1703     /*
1704      NSString *fNname;
1705      //NSImage *img;
1706      bool gaovFlag;
1707      bool edcdFlag;
1708      */
1709 }
1710
1711 -(void)inputFileData{
1712
1713     [self saveStruct];
1714     [self loadStruct];
1715 }
1716
1717 -(void)saveStruct{
1718
1719     //まんこ
1720     NSString *directoryPath;
1721
1722     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1723     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1724
1725
1726     NSString* Cpath = @"SaveData/";
1727     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1728
1729     NSString *path = [[NSString alloc] initWithUTF8String:datFilePath];
1730
1731     if(0 && [[NSFileManager defaultManager] fileExistsAtPath:path]){
1732         [self loadStruct];
1733             if(datRow < 0)
1734                 return;
1735
1736
1737         if(1){
1738
1739             sdd.name = [sdd2[datRow].name retain];
1740             sdd.imgAdressCnt = sdd2[datRow].imgAdressCnt;
1741             sdd.imgAdressFix = sdd2[datRow].imgAdressFix;
1742             sdd.img = sdd2[datRow].img;
1743
1744             sdd.MFselectedRow = sdd2[datRow].MFselectedRow;
1745             sdd.storyNumb = sdd2[datRow].storyNumb;
1746             sdd.scenarioNumb = sdd2[datRow].scenarioNumb;
1747
1748             sdd.mapfileName = [sdd2[datRow].mapfileName retain];
1749             sdd.levelName = [sdd2[datRow].levelName retain];
1750             sdd.levelName = [sdd2[datRow].scenarioName retain];
1751
1752             sdd.chipHeight = sdd2[datRow].chipHeight;
1753             sdd.chipWidth = sdd2[datRow].chipWidth;
1754
1755             sdd.posX = sdd2[datRow].posX;
1756             sdd.posY = sdd2[datRow].posY;
1757
1758             sdd.eSlctX = sdd2[datRow].eSlctX;
1759             sdd.eSlctY = sdd2[datRow].eSlctY;
1760
1761             sdd.registerNum = sdd2[datRow].registerNum;
1762             sdd.registerNumB = sdd2[datRow].registerNumB;
1763
1764             sdd.esSceneProc = sdd2[datRow].esSceneProc;
1765
1766             sdd.endGameCondition = sdd2[datRow].endGameCondition;
1767             sdd.initMapFlag = sdd2[datRow].initMapFlag;
1768             sdd.initStatusFlag = sdd2[datRow].initStatusFlag;
1769             sdd.TeamCountFlag = sdd2[datRow].TeamCountFlag;
1770             sdd.battleBegin = sdd2[datRow].battleBegin;
1771             sdd.startES = sdd2[datRow].startES;
1772
1773             sdd.cpuAImodeflag = sdd2[datRow].cpuAImodeflag;
1774             sdd.cpuModeATTACKflag = sdd2[datRow].cpuModeATTACKflag;
1775             sdd.cpuModeMOVEflag = sdd2[datRow].cpuModeMOVEflag;
1776             sdd.cpuTurnEndFlag = sdd2[datRow].cpuTurnEndFlag;
1777             sdd.waitSwtichFlag = sdd2[datRow].waitSwtichFlag;
1778             sdd.battleReadyUpFlag = sdd2[datRow].battleReadyUpFlag;
1779             sdd.setBattleModeFlag = sdd2[datRow].setBattleModeFlag;
1780
1781             sdd.wtRdy = sdd2[datRow].wtRdy;
1782             sdd.wtRdy2 = sdd2[datRow].wtRdy2;
1783             sdd.wtRdy3 = sdd2[datRow].wtRdy3;
1784
1785             sdd.wtMovedFlag = sdd2[datRow].wtMovedFlag;
1786             sdd.wtAttackedFlag = sdd2[datRow].wtAttackedFlag;
1787             sdd.unitMoveEndFlag = sdd2[datRow].unitMoveEndFlag;
1788             sdd.battleSetUp = sdd2[datRow].battleSetUp;
1789             sdd.pushStanbyFlag = sdd2[datRow].pushStanbyFlag;
1790             sdd.battleEndFlag = sdd2[datRow].battleEndFlag;
1791             sdd.wtUnitNum = sdd2[datRow].wtUnitNum;
1792             sdd.messageDialog = sdd2[datRow].messageDialog;
1793
1794             /*
1795             for(int i = 0;i < 1002;i++)
1796                 for(int j = 0;j < 1002;j++)
1797                     sdd.chipNum[i][j] = sdd2[datRow].chipNum[i][j];
1798             for(int i = 0;i < 1002;i++)
1799                 for(int j = 0;j < 1002;j++)
1800                     sdd.buildNum[i][j] = sdd2[datRow].buildNum[i][j];
1801             for(int i = 0;i < 1002;i++)
1802                 for(int j = 0;j < 1002;j++)
1803                     sdd.unitNum[i][j] = sdd2[datRow].unitNum[i][j];
1804             for(int i = 0;i < 1002;i++)
1805                 for(int j = 0;j < 1002;j++)
1806                     sdd.loadNum[i][j] = sdd2[datRow].loadNum[i][j];
1807             for(int i = 0;i < 1002;i++)
1808                 for(int j = 0;j < 1002;j++)
1809                     sdd.buildTeam[i][j] = sdd2[datRow].buildTeam[i][j];
1810             for(int i = 0;i < 1002;i++)
1811                 for(int j = 0;j < 1002;j++)
1812                     sdd.unitTeam[i][j] = sdd2[datRow].unitTeam[i][j];
1813             */
1814             for(int i = 0;i < sdd.registerNum;i++)
1815                 sdd.dU[i] = sdd2[datRow].dU[i];
1816             for(int i = 0;i < sdd.registerNumB;i++)
1817                 sdd.dB[i] = sdd2[datRow].dB[i];
1818
1819             for(int i = 0;i < 3;i++)
1820                 sdd.P[i] = sdd2[datRow].P[i];
1821
1822             //カレントスイッチなど
1823             for(int i = 0;i < 9999;i++)
1824                 sdd.Suicchi[i] = sdd2[datRow].Suicchi[i];
1825
1826             sdd.HensuuNum = sdd2[datRow].HensuuNum;
1827             for(int i = 0;i < 65000;i++)
1828                 sdd.Hensuu[i] = [sdd2[datRow].Hensuu[i] retain];
1829             for(int i = 0;i < 65000;i++)
1830                 sdd.HensuuName[i] = [sdd2[datRow].HensuuName[i] retain];
1831
1832             sdd.MS = sdd2[datRow].MS;
1833
1834         }
1835
1836         datExistFlag = true;
1837     }else{
1838         datExistFlag = false;
1839     }
1840
1841     if(1){
1842         FILE *fpo;
1843
1844         fpo = fopen(datFilePath, "wb");
1845         if(!fpo)
1846             return;
1847
1848
1849         [self writeNSString:fpo str:sdd.name];
1850         [self writeNSImage:fpo str:sdd.img adCnt:&sdd.imgAdressCnt adFix:&sdd.imgAdressFix];
1851
1852
1853         [self writeInt:fpo val:sdd.MFselectedRow];
1854         [self writeInt:fpo val:sdd.storyNumb];
1855         [self writeInt:fpo val:sdd.scenarioNumb];
1856         [self writeNSString:fpo str:sdd.mapfileName];
1857         [self writeNSString:fpo str:sdd.levelName];
1858         [self writeNSString:fpo str:sdd.scenarioName];
1859
1860         [self writeInt:fpo val:sdd.chipHeight];
1861         [self writeInt:fpo val:sdd.chipWidth];
1862         [self writeInt:fpo val:sdd.posX];
1863         [self writeInt:fpo val:sdd.posY];
1864         [self writeInt:fpo val:sdd.eSlctX];
1865         [self writeInt:fpo val:sdd.eSlctY];
1866         [self writeInt:fpo val:sdd.registerNum];
1867         [self writeInt:fpo val:sdd.registerNumB];
1868         [self writeInt:fpo val:sdd.esSceneProc];
1869         [self writeInt:fpo val:sdd.endGameCondition];
1870
1871         [self writeInt:fpo val:sdd.initMapFlag];
1872         [self writeInt:fpo val:sdd.initStatusFlag];
1873         [self writeInt:fpo val:sdd.TeamCountFlag];
1874         [self writeInt:fpo val:sdd.battleBegin];
1875         [self writeInt:fpo val:sdd.startES];
1876
1877         [self writeInt:fpo val:sdd.cpuAImodeflag];
1878         [self writeInt:fpo val:sdd.cpuModeATTACKflag];
1879         [self writeInt:fpo val:sdd.cpuModeMOVEflag];
1880         [self writeInt:fpo val:sdd.cpuTurnEndFlag];
1881         [self writeInt:fpo val:sdd.waitSwtichFlag];
1882         [self writeInt:fpo val:sdd.battleReadyUpFlag];
1883         [self writeInt:fpo val:sdd.setBattleModeFlag];
1884
1885         [self writeInt:fpo val:sdd.wtRdy];
1886         [self writeInt:fpo val:sdd.wtRdy2];
1887         [self writeInt:fpo val:sdd.wtRdy3];
1888
1889         [self writeInt:fpo val:sdd.wtMovedFlag];
1890         [self writeInt:fpo val:sdd.wtAttackedFlag];
1891         [self writeInt:fpo val:sdd.unitMoveEndFlag];
1892         [self writeInt:fpo val:sdd.battleSetUp];
1893         [self writeInt:fpo val:sdd.pushStanbyFlag];
1894         [self writeInt:fpo val:sdd.battleEndFlag];
1895         [self writeInt:fpo val:sdd.wtUnitNum];
1896         [self writeInt:fpo val:sdd.messageDialog];
1897
1898         /*//これやると容量が重くなる（24MB超えるので保存しない）
1899         for(int i = 0;i < 1002;i++)
1900             for(int j = 0;j < 1002;j++)
1901                 [self writeInt:fpo val:sdd.chipNum[i][j]];
1902         for(int i = 0;i < 1002;i++)
1903             for(int j = 0;j < 1002;j++)
1904                 [self writeInt:fpo val:sdd.buildNum[i][j]];
1905         for(int i = 0;i < 1002;i++)
1906             for(int j = 0;j < 1002;j++)
1907                 [self writeInt:fpo val:sdd.unitNum[i][j]];
1908         for(int i = 0;i < 1002;i++)
1909             for(int j = 0;j < 1002;j++)
1910                 [self writeInt:fpo val:sdd.loadNum[i][j]];
1911         for(int i = 0;i < 1002;i++)
1912             for(int j = 0;j < 1002;j++)
1913                 [self writeInt:fpo val:sdd.buildTeam[i][j]];
1914         for(int i = 0;i < 1002;i++)
1915             for(int j = 0;j < 1002;j++)
1916                 [self writeInt:fpo val:sdd.unitTeam[i][j]];
1917         */
1918
1919         for(int i = 0;i < sdd.registerNum;i++)
1920             [self writeUnitD:fpo row:i];
1921         for(int i = 0;i < sdd.registerNumB;i++)
1922             [self writeBiuldD:fpo row:i];
1923             NSLog(@"\n(保存)%@:IMGADRESS %p\n", sdd.name,sdd.img);
1924
1925         for(int i = 0;i < 3;i++){
1926             fwrite(&sdd.P[i], sizeof(PLAYER), 1, fpo);
1927             [self writeNSString:fpo str:P[i].name];
1928         }
1929         //カレントスイッチなど
1930         for(int i = 0;i < 9999;i++)
1931             [self writeInt:fpo val:sdd.Suicchi[i]];
1932
1933         [self writeInt:fpo val:sdd.HensuuNum];
1934         for(int i = 0;i < 65000;i++)
1935             [self writeNSString:fpo str:sdd.Hensuu[i]];
1936         for(int i = 0;i < 65000;i++)
1937             [self writeNSString:fpo str:sdd.HensuuName[i]];
1938
1939
1940         [self writeMapScript:fpo];
1941
1942         fclose(fpo);
1943
1944         routeCnt = 0;
1945
1946         saveFlag = false;
1947     }
1948     [self loadStruct];
1949 }
1950
1951 -(void)writeBiuldD:(FILE*)fp row:(int)r{
1952
1953     [self writeInt:fp val:sdd.dB[r].number];
1954     [self writeInt:fp val:sdd.dB[r].team];
1955     [self writeInt:fp val:sdd.dB[r].chipNumber];
1956     [self writeInt:fp val:sdd.dB[r].makeLv];
1957
1958     [self writeInt:fp val:sdd.dB[r].x];
1959     [self writeInt:fp val:sdd.dB[r].y];
1960     [self writeInt:fp val:sdd.dB[r].z];
1961
1962     [self writeInt:fp val:sdd.dB[r].dead];
1963
1964     //[self writeBuildDimage:fp row:r];
1965     [self writeBuildChipD:fp val:sdd.dB[r].C];
1966 }
1967
1968 -(void)writeBuildChipD:(FILE*)fp val:(BUILDCHIPD)val{
1969
1970     [self writeInt:fp val:val.chipNumb];
1971     [self writeNSString:fp str:val.name];
1972     [self writeNSString:fp str:val.nameID];
1973
1974     fwrite(&val.S_C, sizeof(BSTATUS), 1, fp);
1975
1976     NSLog(@"gj folks...");
1977 }
1978
1979 -(void)writeBuildDimage:(FILE*)fp row:(int)r{
1980     FILE *fpx;
1981
1982     NSString *directoryPath;
1983
1984     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
1985     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
1986
1987     NSString* Cpath = @"Awars IV.app/Contents/Resources/";
1988     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
1989
1990     NSString *path2 = @INSTANT_IMG;
1991
1992     if(1){
1993         NSData *imgData = [sdd.dB[r].img TIFFRepresentation];
1994         NSBitmapImageRep *brep = [NSBitmapImageRep imageRepWithData:imgData];
1995         imgData = [brep representationUsingType:NSPNGFileType properties:nil];
1996         [imgData writeToFile:path2 atomically:YES];
1997
1998         fpx = fopen(INSTANT_IMG, "rb");
1999
2000         unsigned char in_buf[1024], out_buf[1024];
2001         int rinf;
2002
2003         sdd.dB[r].imgAdCnt = 0;
2004         sdd.dB[r].imgAdFix = 0;
2005
2006         fpos_t fpt = 0;
2007         while (!feof(fpx)) {
2008             fgetpos(fp, &fpt);
2009             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2010             if(rinf < 0){
2011                 break;
2012             }
2013             memcpy((void*)out_buf, (void*)in_buf, 1024);
2014             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2015             if(rinf < 0){
2016                 break;
2017             }
2018             sdd.dB[r].imgAdCnt++;
2019             sdd.dB[r].imgAdFix = rinf;
2020         }
2021
2022         fpt -= (sdd.dB[r].imgAdCnt-1)*1024;
2023         fsetpos(fp, &fpt);
2024         [self writeInt:fp val:(int)sdd.dB[r].imgAdCnt];
2025         [self writeInt:fp val:(int)sdd.dB[r].imgAdFix];
2026
2027         fpt = 0;
2028         fsetpos(fpx, &fpt);
2029         while (!feof(fpx)) {
2030             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2031             if(rinf < 0){
2032                 break;
2033             }
2034             memcpy((void*)out_buf, (void*)in_buf, 1024);
2035             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2036             if(rinf < 0){
2037                 break;
2038             }
2039         }
2040
2041
2042
2043         fclose(fpx);
2044     }
2045 }
2046
2047 -(void)writeUnitD:(FILE*)fp row:(int)r{
2048
2049     [self writeInt:fp val:sdd.dU[r].CPU];
2050     [self writeInt:fp val:sdd.dU[r].number];
2051     [self writeInt:fp val:sdd.dU[r].team];
2052     [self writeInt:fp val:sdd.dU[r].chipNumber];
2053     [self writeInt:fp val:sdd.dU[r].chipNumberL];
2054
2055     [self writeInt:fp val:sdd.dU[r].x];
2056     [self writeInt:fp val:sdd.dU[r].y];
2057     [self writeInt:fp val:sdd.dU[r].z];
2058
2059     [self writeInt:fp val:sdd.dU[r].ix];
2060     [self writeInt:fp val:sdd.dU[r].iy];
2061     [self writeInt:fp val:sdd.dU[r].iz];
2062
2063     [self writeInt:fp val:sdd.dU[r].dead];
2064
2065     [self writeInt:fp val:sdd.dU[r].loadChipFlag];
2066
2067     [self writeInt:fp val:sdd.dU[r].unControlable];
2068     [self writeInt:fp val:sdd.dU[r].joinArmyFromNext];
2069     [self writeInt:fp val:sdd.dU[r].persuasion];
2070
2071     [self writeInt:fp val:sdd.dU[r].targType1L];
2072     [self writeInt:fp val:sdd.dU[r].targType2L];
2073     [self writeInt:fp val:sdd.dU[r].targType1D];
2074     [self writeInt:fp val:sdd.dU[r].targType2D];
2075
2076     [self writeNSString:fp str:sdd.dU[r].army];
2077     //[self writeUnitDimage:fp row:r];
2078
2079
2080     [self writeUnitChipD:fp val:sdd.dU[r].C];
2081     [self writeUnitChipLD:fp val:sdd.dU[r].CL];
2082
2083 }
2084
2085 -(void)writeUnitChipD:(FILE*)fp val:(UNITCHIPD)val{
2086
2087     [self writeInt:fp val:val.chipNumb];
2088     [self writeNSString:fp str:val.name];
2089     [self writeNSString:fp str:val.nameNick];
2090     [self writeNSString:fp str:val.nameClass];
2091     [self writeNSString:fp str:val.nameID];
2092
2093
2094
2095     fwrite(&val.R_C, sizeof(RESIST), 1, fp);
2096     fwrite(&val.S_C, sizeof(STATUS), 1, fp);
2097
2098     NSLog(@"oops is right youre supposed to get...");
2099 }
2100
2101 -(void)writeUnitChipLD:(FILE*)fp val:(LOADCHIPD)val{
2102
2103     [self writeInt:fp val:val.chipNumb];
2104     [self writeNSString:fp str:val.name];
2105     [self writeNSString:fp str:val.nameID];
2106
2107
2108
2109     fwrite(&val.R_C, sizeof(RESIST), 1, fp);
2110     fwrite(&val.S_C, sizeof(STATUS2), 1, fp);
2111
2112     NSLog(@"oops is right youre supposed to get...2");
2113 }
2114
2115 -(void)writeUnitDimage:(FILE*)fp row:(int)r{
2116     FILE *fpx;
2117
2118     NSString *directoryPath;
2119
2120     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2121     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2122
2123     NSString* Cpath = @"Awars IV.app/Contents/Resources/";
2124     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2125
2126     NSString *path2 = @INSTANT_IMG;
2127
2128     if(1){
2129         NSData *imgData = [sdd.dU[r].img TIFFRepresentation];
2130         NSBitmapImageRep *brep = [NSBitmapImageRep imageRepWithData:imgData];
2131         imgData = [brep representationUsingType:NSPNGFileType properties:nil];
2132         [imgData writeToFile:path2 atomically:YES];
2133
2134         fpx = fopen(INSTANT_IMG, "rb");
2135
2136         unsigned char in_buf[1024], out_buf[1024];
2137         int rinf;
2138
2139         sdd.dU[r].imgAdCnt = 0;
2140         sdd.dU[r].imgAdFix = 0;
2141
2142         fpos_t fpt = 0;
2143         while (!feof(fpx)) {
2144             fgetpos(fp, &fpt);
2145             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2146             if(rinf < 0){
2147                 break;
2148             }
2149             memcpy((void*)out_buf, (void*)in_buf, 1024);
2150             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2151             if(rinf < 0){
2152                 break;
2153             }
2154             sdd.dU[r].imgAdCnt++;
2155             sdd.dU[r].imgAdFix = rinf;
2156         }
2157
2158         fpt -= (sdd.dU[r].imgAdCnt-1)*1024;
2159         fsetpos(fp, &fpt);
2160         [self writeInt:fp val:(int)sdd.dU[r].imgAdCnt];
2161         [self writeInt:fp val:(int)sdd.dU[r].imgAdFix];
2162
2163         fpt = 0;
2164         fsetpos(fpx, &fpt);
2165         while (!feof(fpx)) {
2166             rinf = (int)fread((void*)in_buf, 1, 1024, fpx);
2167             if(rinf < 0){
2168                 break;
2169             }
2170             memcpy((void*)out_buf, (void*)in_buf, 1024);
2171             rinf = (int)fwrite((void*)out_buf, 1, rinf, fp);
2172             if(rinf < 0){
2173                 break;
2174             }
2175         }
2176
2177
2178
2179         fclose(fpx);
2180     }
2181 }
2182
2183
2184
2185 -(void)loadStruct{
2186
2187     //まんこ
2188     NSString *directoryPath;
2189
2190     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2191     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2192
2193
2194     NSString* Cpath = @"SaveData/";
2195     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2196
2197     if(datRow < 0)
2198         return;
2199
2200     FILE *fpi;
2201
2202     fpi = fopen(datFilePath, "rb");
2203     if(!fpi)
2204         return;
2205
2206
2207         sdd2[datRow].name = [[self readNSString:fpi strOut:sdd2[datRow].name] retain];
2208
2209         sdd2[datRow].imgAdressCnt = (int)[self readInt:fpi];
2210         sdd2[datRow].imgAdressFix = (int)[self readInt:fpi];
2211         sdd2[datRow].img = [[self readNSImage:fpi imgOut:sdd2[datRow].img dcnt:sdd2[datRow].imgAdressCnt dfix:sdd2[datRow].imgAdressFix] retain];
2212
2213         sdd2[datRow].MFselectedRow = (int)[self readInt:fpi];
2214         sdd2[datRow].storyNumb = (int)[self readInt:fpi];
2215         sdd2[datRow].scenarioNumb = (int)[self readInt:fpi];
2216         sdd2[datRow].mapfileName = [[self readNSString:fpi strOut:sdd2[datRow].mapfileName] retain];
2217         sdd2[datRow].levelName = [[self readNSString:fpi strOut:sdd2[datRow].levelName] retain];
2218         sdd2[datRow].scenarioName = [ [self readNSString:fpi strOut:sdd2[datRow].scenarioName] retain];
2219
2220         sdd2[datRow].chipHeight = (int)[self readInt:fpi];
2221         sdd2[datRow].chipWidth = (int)[self readInt:fpi];
2222         sdd2[datRow].posX = (int)[self readInt:fpi];
2223         sdd2[datRow].posY = (int)[self readInt:fpi];
2224         sdd2[datRow].eSlctX = (int)[self readInt:fpi];
2225         sdd2[datRow].eSlctY = (int)[self readInt:fpi];
2226         sdd2[datRow].registerNum = (int)[self readInt:fpi];
2227         sdd2[datRow].registerNumB = (int)[self readInt:fpi];
2228         sdd2[datRow].esSceneProc = (int)[self readInt:fpi];
2229         sdd2[datRow].endGameCondition = (int)[self readInt:fpi];
2230
2231         sdd2[datRow].initMapFlag = (int)[self readInt:fpi];
2232         sdd2[datRow].initStatusFlag = (int)[self readInt:fpi];
2233         sdd2[datRow].TeamCountFlag = (int)[self readInt:fpi];
2234         sdd2[datRow].battleBegin = (int)[self readInt:fpi];
2235         sdd2[datRow].startES = (int)[self readInt:fpi];
2236
2237         sdd2[datRow].cpuAImodeflag = (int)[self readInt:fpi];
2238         sdd2[datRow].cpuModeATTACKflag = (int)[self readInt:fpi];
2239         sdd2[datRow].cpuModeMOVEflag = (int)[self readInt:fpi];
2240         sdd2[datRow].cpuTurnEndFlag = (int)[self readInt:fpi];
2241         sdd2[datRow].waitSwtichFlag = (int)[self readInt:fpi];
2242         sdd2[datRow].battleReadyUpFlag = (int)[self readInt:fpi];
2243         sdd2[datRow].setBattleModeFlag = (int)[self readInt:fpi];
2244
2245         sdd2[datRow].wtRdy = (int)[self readInt:fpi];
2246         sdd2[datRow].wtRdy2 = (int)[self readInt:fpi];
2247         sdd2[datRow].wtRdy3 = (int)[self readInt:fpi];
2248
2249         sdd2[datRow].wtMovedFlag = (int)[self readInt:fpi];
2250         sdd2[datRow].wtAttackedFlag = (int)[self readInt:fpi];
2251         sdd2[datRow].unitMoveEndFlag = (int)[self readInt:fpi];
2252         sdd2[datRow].battleSetUp = (int)[self readInt:fpi];
2253         sdd2[datRow].pushStanbyFlag = (int)[self readInt:fpi];
2254         sdd2[datRow].battleEndFlag = (int)[self readInt:fpi];
2255         sdd2[datRow].wtUnitNum = (int)[self readInt:fpi];
2256         sdd2[datRow].messageDialog = (int)[self readInt:fpi];
2257
2258     /*//saveStructとワンセット容量の関係で読み込まない
2259     for(int i = 0;i < 1002;i++)
2260         for(int j = 0;j < 1002;j++)
2261             sdd2[datRow].chipNum[i][j] = (int)[self readInt:fpi];
2262     for(int i = 0;i < 1002;i++)
2263         for(int j = 0;j < 1002;j++)
2264             sdd2[datRow].buildNum[i][j] = (int)[self readInt:fpi];
2265     for(int i = 0;i < 1002;i++)
2266         for(int j = 0;j < 1002;j++)
2267             sdd2[datRow].unitNum[i][j] = (int)[self readInt:fpi];
2268     for(int i = 0;i < 1002;i++)
2269         for(int j = 0;j < 1002;j++)
2270             sdd2[datRow].loadNum[i][j] = (int)[self readInt:fpi];
2271     for(int i = 0;i < 1002;i++)
2272         for(int j = 0;j < 1002;j++)
2273             sdd2[datRow].buildTeam[i][j] = (int)[self readInt:fpi];
2274     for(int i = 0;i < 1002;i++)
2275         for(int j = 0;j < 1002;j++)
2276             sdd2[datRow].unitTeam[i][j] = (int)[self readInt:fpi];
2277     */
2278     for(int i = 0;i < sdd2[datRow].registerNum;i++)
2279         [self readUnitD:fpi row:i];
2280     for(int i = 0;i < sdd2[datRow].registerNumB;i++)
2281         [self readBiuldD:fpi row:i];
2282
2283         NSLog(@"\n(読み込み)%@:IMGADRESS %p\n",sdd2[datRow].name,sdd2[datRow].img);
2284
2285     for(int i = 0;i < 3;i++){
2286         fread(&sdd2[datRow].P[i], sizeof(PLAYER), 1, fpi);
2287         sdd2[datRow].P[i].name = [[self readNSString:fpi strOut:sdd2[datRow].P[i].name] retain];
2288     }
2289
2290     //カレントスイッチなど
2291     for(int i = 0;i < 9999;i++)
2292         sdd2[datRow].Suicchi[i] = (int)[self readInt:fpi];
2293
2294     sdd2[datRow].HensuuNum = (int)[self readInt:fpi];
2295     for(int i = 0;i < 65000;i++)
2296         sdd2[datRow].Hensuu[i] = [[self readNSString:fpi strOut:sdd2[datRow].Hensuu[i]] retain];
2297     for(int i = 0;i < 65000;i++)
2298         sdd2[datRow].HensuuName[i] = [[self readNSString:fpi strOut:sdd2[datRow].HensuuName[i]] retain];
2299
2300     [self readMapScript:fpi];
2301
2302     fclose(fpi);
2303
2304 }
2305
2306
2307 -(void)loadOptionMenu{
2308     NSString *directoryPath;
2309
2310     directoryPath = [[NSBundle mainBundle] bundlePath];
2311     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2312
2313
2314     NSString* Cpath = @"Contents/Resources/";
2315     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2316
2317     FILE *fpi;
2318
2319     fpi = fopen(OPTIONFILE_NAME, "rb");
2320     if(!fpi)
2321         return;
2322
2323     wtfom.nameTitle = [@"" retain];
2324     NSLog(@"%@", wtfom.nameTitle);
2325     wtfom.nameTitle = [[self readNSString:fpi strOut:wtfom.nameTitle] retain];
2326     wtfom.nameVersion = [[self readNSString:fpi strOut:wtfom.nameVersion] retain];
2327     wtfom.nameOpening = [[self readNSString:fpi strOut:wtfom.nameOpening] retain];
2328     wtfom.nameBGM = [[self readNSString:fpi strOut:wtfom.nameBGM] retain];
2329
2330     wtfom.allowMapEditor = (int)[self readInt:fpi];
2331     wtfom.allowScenarioEditor = (int)[self readInt:fpi];
2332     wtfom.onlyOnceOpening = (int)[self readInt:fpi];
2333     wtfom.newOpeningIsShown = (int)[self readInt:fpi];
2334
2335     wtfom.adCntIT = (int)[self readInt:fpi];
2336     wtfom.adFixIT = (int)[self readInt:fpi];
2337     wtfom.imgTitle = [[self readNSImage:fpi imgOut:wtfom.imgTitle dcnt:wtfom.adCntIT dfix:wtfom.adFixIT] retain];
2338
2339
2340     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2341     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2342
2343     Cpath = @"data/Movie";
2344
2345     BOOL isDirectory;
2346
2347     [[NSFileManager defaultManager] fileExistsAtPath:Cpath isDirectory:&isDirectory];
2348
2349     if(!isDirectory)
2350         [[NSFileManager defaultManager] createDirectoryAtPath:Cpath withIntermediateDirectories:YES attributes:nil error:nil];
2351
2352
2353     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2354
2355     if([[NSFileManager defaultManager] fileExistsAtPath:wtfom.nameOpening])
2356         openingAVP = [[AVPlayer playerWithURL:[NSURL fileURLWithPath:wtfom.nameOpening]] retain];
2357     else
2358         openingAVP = NULL;
2359
2360     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
2361     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2362
2363     Cpath = @"data/BGM/";
2364     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2365
2366     /*
2367     char *cwd;
2368     cwd = getcwd(NULL, 0);
2369
2370     NSLog(@"%s", cwd);
2371     */
2372
2373     titleBGM = [[[NSSound alloc] initWithContentsOfURL:[NSURL fileURLWithPath:wtfom.nameBGM] byReference:NO] retain];
2374
2375     fclose(fpi);
2376 }
2377
2378 -(void)openingAVPVfunc{
2379
2380     if(openingAVP && openingAVPVisActive){
2381         openingAVPV.player = openingAVP;
2382         openingAVPV.videoGravity =  AVLayerVideoGravityResize;
2383     }
2384
2385     if(openingAVPVisHidden)
2386         [openingAVPV setHidden:YES];
2387     else
2388         [openingAVPV setHidden:NO];
2389
2390 }
2391
2392 -(void)saveOptionMenu{
2393     NSString *directoryPath;
2394
2395     directoryPath = [[NSBundle mainBundle] bundlePath];
2396     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
2397
2398
2399     NSString* Cpath = @"Contents/Resources/";
2400     [[NSFileManager defaultManager] changeCurrentDirectoryPath:Cpath];
2401
2402     /*
2403     char *cwd;
2404     cwd = getcwd(NULL, 0);
2405
2406     NSLog(@"%s", cwd);
2407     */
2408
2409     FILE *fpo;
2410
2411     fpo = fopen(OPTIONFILE_NAME, "wb");
2412     if(!fpo)
2413         return;
2414
2415     [self writeNSString:fpo str:wtfom.nameTitle];
2416     [self writeNSString:fpo str:wtfom.nameVersion];
2417     [self writeNSString:fpo str:wtfom.nameOpening];
2418     [self writeNSString:fpo str:wtfom.nameBGM];
2419
2420     [self writeInt:fpo val:wtfom.allowMapEditor];
2421     [self writeInt:fpo val:wtfom.allowScenarioEditor];
2422     [self writeInt:fpo val:wtfom.onlyOnceOpening];
2423     [self writeInt:fpo val:wtfom.newOpeningIsShown];
2424
2425     [self writeNSImage:fpo str:wtfom.imgTitle adCnt:&wtfom.adCntIT adFix:&wtfom.adFixIT];
2426
2427
2428
2429
2430     fclose(fpo);
2431 }
2432
2433
2434
2435 -(void)clickSGL:(id)sender{
2436
2437     datRow = (int)[saveGameListTV clickedRow];
2438 }
2439
2440 -(void)clickLFOL:(id)sender{
2441
2442     LFOLrow = (int)[loadFileOutputListTV selectedRow];
2443     SDLrow = -1;
2444
2445     for(int i = 1;i <= saveNumb;i++){
2446
2447         for(int j = 0;j < [loadFileOutputListMA count];j++){
2448
2449             if([SDL[j+1].name isEqualToString:[loadFileOutputListMA[LFOLrow] valueForKey:@"name"]]){
2450                 SDLrow = j;
2451
2452                 [loadFileOutputTF setStringValue:[NSString stringWithFormat:@"%@ まで", SDL[SDLrow+1].levelName]];
2453                 return;
2454             }
2455         }
2456     }
2457
2458     [loadFileOutputTF setStringValue:[NSString stringWithFormat:@""]];
2459
2460 }
2461
2462 -(void)doubleClickBCL:(id)sender{
2463
2464     enum{
2465         MC_ANTEI,
2466         MC_FUANTEI,
2467         MC_CHIKURIN,
2468         MC_MIZUBA,
2469         MC_ASASE,
2470         MC_NAIBU
2471     };
2472
2473     enum{
2474         BC_ANTEI,
2475         BC_CHIKURIN,
2476         BC_ASASE,
2477         BC_SONOTA
2478     };
2479
2480     bclRdy = false;
2481
2482     U = UTop;
2483     for(int i = 0;i < slctedUnitNum;i++){
2484         U = U->next;
2485     }
2486
2487     if (MC[chipNum[possionX][possionY]].type == MC_ANTEI) {
2488
2489         if(BC[U->C.S->list[crBCL]-1].type == BC_ANTEI){
2490             bclRdy = true;
2491         }
2492
2493     }
2494
2495     if (MC[chipNum[possionX][possionY]].type == MC_CHIKURIN) {
2496
2497         if(BC[U->C.S->list[crBCL]-1].type == BC_CHIKURIN){
2498             bclRdy = true;
2499         }
2500
2501     }
2502
2503     if (MC[chipNum[possionX][possionY]].type == MC_ASASE) {
2504
2505         if(BC[U->C.S->list[crBCL]-1].type == BC_ASASE){
2506             bclRdy = true;
2507         }
2508
2509     }
2510
2511     if(BC[U->C.S->list[crBCL]].type == BC_SONOTA){
2512         bclRdy = true;
2513     }
2514
2515     if(bclRdy){
2516         bclRdy = false;
2517         if(buildNum[possionX][possionY] >= 0){
2518             U = UTop;
2519             return;
2520         }
2521
2522         if(U->team == 0)
2523         if(P[0].resource >= BC[U->C.S->list[crBCL]-1].Csupply){
2524             if(P[0].food >= BC[U->C.S->list[crBCL]-1].Cfood){
2525                 if (P[0].money >= BC[U->C.S->list[crBCL]-1].Cmoney) {
2526                     P[0].resource -= BC[U->C.S->list[crBCL]-1].Csupply;
2527                     P[0].food -= BC[U->C.S->list[crBCL]-1].Cfood;
2528                     P[0].money -= BC[U->C.S->list[crBCL]-1].Cmoney;
2529
2530                     buildNum[possionX][possionY] = U->C.S->list[crBCL]-1;
2531
2532                     buildTeam[possionX][possionY] = 0;
2533
2534
2535                     [self addBuildStatus];
2536
2537                     bclRdy = true;
2538                 }
2539             }
2540         }
2541
2542         if(U->team == 2)
2543         if(P[1].resource >= BC[U->C.S->list[crBCL]-1].Csupply){
2544             if(P[1].food >= BC[U->C.S->list[crBCL]-1].Cfood){
2545                 if (P[1].money >= BC[U->C.S->list[crBCL]-1].Cmoney) {
2546                     P[1].resource -= BC[U->C.S->list[crBCL]-1].Csupply;
2547                     P[1].food -= BC[U->C.S->list[crBCL]-1].Cfood;
2548                     P[1].money -= BC[U->C.S->list[crBCL]-1].Cmoney;
2549
2550                     buildNum[possionX][possionY] = U->C.S->list[crBCL]-1;
2551
2552                     buildTeam[possionX][possionY] = 2;
2553
2554                     [self addBuildStatus];
2555
2556                     bclRdy = true;
2557                 }
2558             }
2559         }
2560         [createPanel close];
2561     }
2562
2563     U = UTop;
2564 }
2565
2566 -(void)clickBCL:(id)sender{
2567     crBCL = (int)[BCreateListTV clickedRow];
2568
2569
2570
2571 }
2572
2573
2574 -(void)doubleClickCSL:(id)sender{
2575
2576     U = UTop;
2577     for(int i = 0;i < slctedUnitNum;i++){
2578         U = U->next;
2579     }
2580     CSLU = U;
2581
2582     SKILL *sTop = U->C.S;
2583     while (U->C.S) {
2584         if(U->C.S->type == 2) break;
2585         U->C.S = U->C.S->next;
2586     }
2587     if(!U->C.S){
2588         U->C.S = sTop;
2589         U = UTop;
2590         return;
2591     }
2592
2593     if(U->team == 0)
2594         if(U->C.S->cost[crCSL] <= U->C.S_C.MP){
2595             //U->C.S_C.MP -= U->C.S->cost[crCSL];
2596             CSLUC = UC[U->C.S->list[crCSL]-1];
2597
2598             U->C.S = sTop;
2599             cslRdy = true;
2600             [summonPanel close];
2601             //unitColorInitFlag = true;
2602         }
2603     if(U->team == 2)
2604         if(U->C.S->cost[crCSL] <= U->C.S_C.MP){
2605
2606             //U->C.S_C.MP -= U->C.S->cost[crCSL];
2607             CSLUC = UC[U->C.S->list[crCSL]-1];
2608
2609             U->C.S = sTop;
2610             cslRdy = true;
2611             [summonPanel close];
2612             //unitColorInitFlag = true;
2613         }
2614
2615     U = UTop;
2616
2617 }
2618
2619 -(void)clickCSL:(id)sender{
2620     crCSL = (int)[CSummonListTV clickedRow];
2621
2622
2623 }
2624
2625 -(void)doubleClickCAL:(id)sender{
2626
2627     if([CAttackListTV clickedRow] < 0) return;
2628
2629     if(crCAL < 0)
2630         crCAL = 0;
2631
2632     int postCAL1 = crCAL1;
2633     int postCAL2 = crCAL2;
2634
2635     if(!battleSet1Flag && !battleSet2Flag){
2636     U = UTop;
2637     while (!(AUN[1] == U->number)) {
2638         U = U->next;
2639     }
2640
2641
2642
2643         if(U->chipNumberL < 0){
2644
2645             ATTACK *aTop = U->C.A;
2646
2647             crCAL = (int)[CAttackListTV clickedRow];
2648             crCAL1 = (int)[CAttackListTV clickedRow];
2649             for(int i = 0;i < crCAL;i++){
2650                 U->C.A = U->C.A->next;
2651             }
2652
2653             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2654             costVIG = U->C.A->vigor;
2655
2656             if(costMP <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
2657                 if(U->C.A->extent > 0){
2658                     atkExtentFlag = true;
2659                 }else{
2660                     atkExtentFlag = false;
2661                 }
2662                 dcRdy = true;
2663                 [atkPanel close];
2664             }
2665             U->C.A = aTop;
2666             U = UTop;
2667             crCAL1 = crCAL;
2668             return;
2669         }else{
2670             ATTACK *aTop = U->CL.A;
2671             crCAL = (int)[CAttackListTV clickedRow];
2672             crCAL1 = (int)[CAttackListTV clickedRow];
2673             for(int i = 0;i < crCAL;i++){
2674                 U->CL.A = U->CL.A->next;
2675             }
2676
2677             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2678             costVIG = U->CL.A->vigor;
2679
2680             if(costMP <= U->CL.S_C.EN && costVIG <= U->C.S_C.vigor){
2681                 dcRdy = true;
2682                 if(U->CL.A->extent > 0){
2683                     atkExtentFlag = true;
2684                 }else{
2685                     atkExtentFlag = false;
2686                 }
2687                 [atkPanel close];
2688             }
2689             U->CL.A = aTop;
2690             U = UTop;
2691             crCAL1 = crCAL;
2692             return;
2693         }
2694     }
2695
2696     if(battleSet1Flag && !battleSet2PushedFlag){
2697
2698
2699         U = UTop;
2700         while (!(AUN[1] == U->number)) {
2701             U = U->next;
2702         }
2703
2704         if(U->chipNumberL < 0){
2705             ATTACK *aTop = U->C.A;
2706             crCAL1 = (int)[CAttackListTV clickedRow];
2707             for(int i = 0;i < crCAL1;i++){
2708                 U->C.A = U->C.A->next;
2709             }
2710
2711             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2712             costVIG = U->C.A->vigor;
2713
2714
2715             if(costMP <= U->C.S_C.MP && U->atkRange >= U->C.A->rangeA
2716                && U->atkRange <= U->C.A->rangeB && costVIG >= U->C.S_C.vigor){
2717                 //dcRdy = true;
2718                 [atkPanel close];
2719                 U->C.A = aTop;
2720                 U = UTop;
2721                 return;
2722             }
2723             U->C.A = aTop;
2724             crCAL1 = crCAL;
2725             U = UTop;
2726
2727         }else{
2728             ATTACK *aTop = U->CL.A;
2729             crCAL1 = (int)[CAttackListTV clickedRow];
2730             for(int i = 0;i < crCAL1;i++){
2731                 U->CL.A = U->CL.A->next;
2732             }
2733
2734             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2735             costVIG = U->C.A->vigor;
2736
2737             if(costMP <= U->CL.S_C.EN && U->atkRange >= U->CL.A->rangeA
2738                && U->atkRange <= U->CL.A->rangeB && costVIG >= U->C.S_C.vigor){
2739                 //dcRdy = true;
2740                 [atkPanel close];
2741                 U->CL.A = aTop;
2742                 U = UTop;
2743                 return;
2744             }
2745             U->CL.A = aTop;
2746             crCAL1 = crCAL;
2747             U = UTop;
2748         }
2749
2750     }
2751
2752     if(battleSet2Flag && battleSet2PushedFlag){
2753         U = UTop;
2754         while (!(AUN[1] == U->number)) {
2755             U = U->next;
2756         }
2757
2758         if(U->chipNumberL < 0){
2759             U = UTop;
2760             U = UTop;
2761             while (!(AUN[1] == U->number)) {
2762                 U = U->next;
2763             }
2764
2765             int omgRange = U->atkRange;
2766
2767             U = UTop;
2768             while (!(DUN[1] == U->number)) {
2769                 U = U->next;
2770             }
2771
2772             U->atkRange = omgRange;
2773
2774             ATTACK *aTop = U->C.A;
2775             crCAL2 = (int)[CAttackListTV clickedRow];
2776             for(int i = 0;i < crCAL2;i++){
2777                 U->C.A = U->C.A->next;
2778             }
2779
2780             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
2781             costVIG = U->C.A->vigor;
2782
2783
2784             if(costMP <= U->C.S_C.MP && U->atkRange >= U->C.A->rangeA
2785                 && U->atkRange <= U->C.A->rangeB && U->C.S_C.vigor){
2786                 //dcRdy = true;
2787                 [atkPanel close];
2788                 U->C.A = aTop;
2789                 U = UTop;
2790                 return;
2791             }
2792             U->C.A = aTop;
2793             crCAL1 = crCAL;
2794             U = UTop;
2795         }else{
2796             U = UTop;
2797             U = UTop;
2798             while (!(AUN[1] == U->number)) {
2799                 U = U->next;
2800             }
2801
2802             int omgRange = U->atkRange;
2803
2804             U = UTop;
2805             while (!(DUN[1] == U->number)) {
2806                 U = U->next;
2807             }
2808
2809             U->atkRange = omgRange;
2810
2811             ATTACK *aTop = U->CL.A;
2812             crCAL2 = (int)[CAttackListTV clickedRow];
2813             for(int i = 0;i < crCAL2;i++){
2814                 U->CL.A = U->CL.A->next;
2815             }
2816
2817             costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
2818             costVIG = U->C.A->vigor;
2819
2820             if(costMP <= U->CL.S_C.EN && U->atkRange >= U->CL.A->rangeA
2821                && U->atkRange <= U->CL.A->rangeB && U->C.S_C.vigor){
2822                 //dcRdy = true;
2823                 [atkPanel close];
2824                 U->CL.A = aTop;
2825                 U = UTop;
2826                 return;
2827             }
2828             U->CL.A = aTop;
2829             crCAL1 = crCAL;
2830             U = UTop;
2831
2832         }
2833
2834         U = UTop;
2835
2836     }
2837
2838
2839     crCAL1 = postCAL1;
2840     crCAL2 = postCAL2;
2841 }
2842
2843
2844 -(void)clickCAL:(id)sender{
2845
2846     crCAL = (int)[CAttackListTV clickedRow];
2847
2848     if(!battleSetFlag){crCAL = crCAL1;
2849         crCAL1 = (int)[CAttackListTV clickedRow];
2850         crCAL = crCAL1;
2851         U = UTop;
2852         while (!(AUN[1] == U->number)) {
2853             U = U->next;
2854         }
2855     }else if(battleSetFlag){crCAL = crCAL2;
2856         crCAL2 = (int)[CAttackListTV clickedRow];
2857         crCAL = crCAL2;
2858         U = UTop;
2859         while (!(DUN[1] == U->number)) {
2860             U = U->next;
2861         }
2862
2863     }
2864
2865     if(U->chipNumberL >= 0) {
2866         U = UTop;
2867         [self initCAttackSelect2];
2868     }
2869     else if(U->chipNumber >= 0) {
2870         U = UTop;
2871         [self initCAttackSelect];
2872     }
2873     U = UTop;
2874 }
2875
2876 -(void)initCAttackSelect{
2877
2878     U = UTop;
2879
2880     while (!(AUN[1] == U->number)) {
2881         U = U->next;
2882     }
2883     if(!battleSetFlag){crCAL = crCAL1;
2884         //crCAL1 = (int)[CAttackListTV clickedRow];
2885         crCAL = crCAL1;
2886         U = UTop;
2887         while (!(AUN[1] == U->number)) {
2888             U = U->next;
2889         }
2890     }else if(battleSetFlag){crCAL = crCAL2;
2891         //crCAL2 = (int)[CAttackListTV clickedRow];
2892         crCAL = crCAL2;
2893         U = UTop;
2894         while (!(DUN[1] == U->number)) {
2895             U = U->next;
2896         }
2897
2898     }
2899
2900     //U = Uselected;
2901
2902     [CAttackListAC setSelectionIndex:crCAL];
2903     crCAL = (int)[CAttackListTV clickedRow];
2904     ATTACK *aTop = U->C.A;
2905     for(int i = 0;i < crCAL;i++){
2906         U->C.A = U->C.A->next;
2907     }
2908
2909     if(!U->C.A) {
2910         [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
2911         [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->C.S_C.MP]];
2912         [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
2913         [region setStringValue:[NSString stringWithFormat:@"陸-- 宙-- 海-- 空--"]];
2914         [crytical setStringValue:@""];
2915         [atkProperty setStringValue:@""];
2916         U->C.A = aTop;
2917         return;
2918     }
2919
2920     if(U->C.A->bullet > 0) [bullet setStringValue:[NSString stringWithFormat:@"%d／%d", U->C.A->bulletC, U->C.A->bullet]];
2921     else [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
2922     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]];
2923     else [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->C.S_C.MP]];
2924     if(U->C.A->vigor > 0) [costV setStringValue:[NSString stringWithFormat:@"%d（%d）", U->C.A->vigor, U->C.S_C.vigor]];
2925     else [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
2926
2927     NSString *Riku, *Chu, *Umi, *Sora;
2928
2929     switch (U->C.A->riku) {
2930         case 0:
2931             Riku = [@"A" retain];
2932             break;
2933         case 1:
2934             Riku = [@"B"retain];
2935             break;
2936         case 2:
2937             Riku = [@"C"retain];
2938             break;
2939         case 3:
2940             Riku = [@"D"retain];
2941             break;
2942         case 4:
2943             Riku = [@"E"retain];
2944             break;
2945         case 5:
2946             Riku = [@"S"retain];
2947             break;
2948         case 6:
2949             Riku = [@"SS"retain];
2950             break;
2951     }
2952     switch (U->C.A->chu) {
2953         case 0:
2954             Chu = [@"A" retain];
2955             break;
2956         case 1:
2957             Chu = [@"B" retain];
2958             break;
2959         case 2:
2960             Chu = [@"C" retain];
2961             break;
2962         case 3:
2963             Chu = [@"D" retain];
2964             break;
2965         case 4:
2966             Chu = [@"E" retain];
2967             break;
2968         case 5:
2969             Chu = [@"S" retain];
2970             break;
2971         case 6:
2972             Chu = [@"SS" retain];
2973             break;
2974     }
2975     switch (U->C.A->umi) {
2976         case 0:
2977             Umi = [@"A" retain];
2978             break;
2979         case 1:
2980             Umi = [@"B" retain];
2981             break;
2982         case 2:
2983             Umi = [@"C" retain];
2984             break;
2985         case 3:
2986             Umi = [@"D" retain];
2987             break;
2988         case 4:
2989             Umi = [@"E" retain];
2990             break;
2991         case 5:
2992             Umi = [@"S" retain];
2993             break;
2994         case 6:
2995             Umi = [@"SS" retain];
2996             break;
2997     }
2998     switch (U->C.A->sora) {
2999         case 0:
3000             Sora = [@"A" retain];
3001             break;
3002         case 1:
3003             Sora = [@"B" retain];
3004             break;
3005         case 2:
3006             Sora = [@"C" retain];
3007             break;
3008         case 3:
3009             Sora = [@"D" retain];
3010             break;
3011         case 4:
3012             Sora = [@"E" retain];
3013             break;
3014         case 5:
3015             Sora = [@"S" retain];
3016             break;
3017         case 6:
3018             Sora = [@"SS" retain];
3019             break;
3020     }
3021
3022     if(!U->C.A->name){
3023         Riku = @"--";
3024         Chu = @"--";
3025         Umi = @"--";
3026         Sora = @"--";
3027     }
3028
3029     [region setStringValue:[NSString stringWithFormat:@"陸%@ 宙%@ 海%@ 空%@",  Riku, Chu, Umi, Sora]];
3030     [crytical setStringValue:@""];
3031     [atkProperty setStringValue:@""];
3032
3033     U->C.A = aTop;
3034     U = UTop;
3035 }
3036
3037 -(void)initCAttackSelect2{
3038
3039     U = UTop;
3040
3041     while (!(AUN[1] == U->number)) {
3042         U = U->next;
3043     }
3044     if(battleSet1Flag){
3045         //crCAL1 = (int)[CAttackListTV clickedRow];
3046         U = UTop;
3047         while (!(AUN[1] == U->number)) {
3048             U = U->next;
3049         }
3050     }
3051     if(battleSet2Flag){
3052         //crCAL2 = (int)[CAttackListTV clickedRow];
3053         U = UTop;
3054         while (!(DUN[1] == U->number)) {
3055             U = U->next;
3056         }
3057
3058     }
3059
3060     ATTACK *aTop = U->CL.A;
3061     for(int i = 0;i < crCAL;i++){
3062         U->CL.A = U->CL.A->next;
3063     }
3064
3065     if(!U->CL.A) {
3066
3067         U = UTop;
3068         return;
3069     }
3070     if(U->CL.A->bullet > 0) [bullet setStringValue:[NSString stringWithFormat:@"%d／%d", U->CL.A->bulletC, U->CL.A->bullet]];
3071     else [bullet setStringValue:[NSString stringWithFormat:@"---／---"]];
3072     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]];
3073     else [costP setStringValue:[NSString stringWithFormat:@"---（%g）", U->CL.S_C.EN]];
3074     if(U->CL.A->vigor > 0) [costV setStringValue:[NSString stringWithFormat:@"%d（%d）", U->CL.A->vigor, U->C.S_C.vigor]];
3075     else [costV setStringValue:[NSString stringWithFormat:@"---（%d）",  U->C.S_C.vigor]];
3076
3077     NSString *Riku, *Chu, *Umi, *Sora;
3078
3079     switch (U->CL.A->riku) {
3080         case 0:
3081             Riku = @"A";
3082             break;
3083         case 1:
3084             Riku = @"B";
3085             break;
3086         case 2:
3087             Riku = @"C";
3088             break;
3089         case 3:
3090             Riku = @"D";
3091             break;
3092         case 4:
3093             Riku = @"E";
3094             break;
3095         case 5:
3096             Riku = @"S";
3097             break;
3098         case 6:
3099             Riku = @"SS";
3100             break;
3101     }
3102     switch (U->CL.A->chu) {
3103         case 0:
3104             Chu = @"A";
3105             break;
3106         case 1:
3107             Chu = @"B";
3108             break;
3109         case 2:
3110             Chu = @"C";
3111             break;
3112         case 3:
3113             Chu = @"D";
3114             break;
3115         case 4:
3116             Chu = @"E";
3117             break;
3118         case 5:
3119             Chu = @"S";
3120             break;
3121         case 6:
3122             Chu = @"SS";
3123             break;
3124     }
3125     switch (U->CL.A->umi) {
3126         case 0:
3127             Umi = @"A";
3128             break;
3129         case 1:
3130             Umi = @"B";
3131             break;
3132         case 2:
3133             Umi = @"C";
3134             break;
3135         case 3:
3136             Umi = @"D";
3137             break;
3138         case 4:
3139             Umi = @"E";
3140             break;
3141         case 5:
3142             Umi = @"S";
3143             break;
3144         case 6:
3145             Umi = @"SS";
3146             break;
3147     }
3148     switch (U->CL.A->sora) {
3149         case 0:
3150             Sora = @"A";
3151             break;
3152         case 1:
3153             Sora = @"B";
3154             break;
3155         case 2:
3156             Sora = @"C";
3157             break;
3158         case 3:
3159             Sora = @"D";
3160             break;
3161         case 4:
3162             Sora = @"E";
3163             break;
3164         case 5:
3165             Sora = @"S";
3166             break;
3167         case 6:
3168             Sora = @"SS";
3169             break;
3170     }
3171
3172     if(!U->CL.A->name){
3173         Riku = @"--";
3174         Chu = @"--";
3175         Umi = @"--";
3176         Sora = @"--";
3177     }
3178
3179     [region setStringValue:[NSString stringWithFormat:@"陸%@ 宙%@ 海%@ 空%@",  Riku, Chu, Umi, Sora]];
3180     [crytical setStringValue:@""];
3181     [atkProperty setStringValue:@""];
3182
3183     U->CL.A = aTop;
3184     U = UTop;
3185 }
3186
3187
3188 -(void)doubleClickCRL:(id)sender{
3189
3190     if(crCRL == -1) return;
3191
3192     if(unitBreak->team == 0)
3193     if(P[0].resource >= BRU->S_M.cSupply && P[0].food >= BRU->S_M.cFood && P[0].money >= BRU->S_M.cMoney){
3194
3195         P[0].resource -= BRU->S_M.cSupply;
3196         P[0].food -= BRU->S_M.cFood;
3197         P[0].money -= BRU->S_M.cMoney;
3198
3199         unitNum[possionX][possionY] = BRUindex;
3200         if(researchTeam == 0) unitTeam[possionX][possionY] = 0;
3201         if(researchTeam == 2) unitTeam[possionX][possionY] = 2;
3202
3203         [self addUnitStatus];
3204
3205         unitColorInitFlag = true;
3206
3207         [researchPanel close];
3208     }
3209
3210     if(unitBreak->team == 2)
3211         if(P[1].resource >= BRU->S_M.cSupply && P[1].food >= BRU->S_M.cFood && P[1].money >= BRU->S_M.cMoney){
3212
3213             P[1].resource -= BRU->S_M.cSupply;
3214             P[1].food -= BRU->S_M.cFood;
3215             P[1].money -= BRU->S_M.cMoney;
3216
3217             unitNum[possionX][possionY] = BRUindex;
3218             if(researchTeam == 0) unitTeam[possionX][possionY] = 0;
3219             if(researchTeam == 2) unitTeam[possionX][possionY] = 2;
3220
3221             [self addUnitStatus];
3222
3223             unitColorInitFlag = true;
3224
3225             [researchPanel close];
3226         }
3227
3228 }
3229
3230 -(void)clickCRL:(id)sender{
3231
3232     crCRL = (int)[CResearchListTV clickedRow];
3233     if(crCRL < 0)
3234         return;
3235     BUILDCHIP *B;
3236
3237     B = &BC[buildNum[possionX][possionY]];
3238
3239
3240     RESEARCH *Rtop;
3241     UNITCHIP *BU;
3242
3243     Rtop = B->R;
3244     if(B->R){
3245     BU = B->R->U;
3246     BRU = BU;
3247     for(int i = 0;i <= crCRL;i++){
3248         BU = B->R->U;
3249         BRU = BU;
3250         [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", BU->S_M.ATK]];
3251         [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", BU->S_M.DEF]];
3252         [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", BU->S_M.CAP]];
3253         [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", BU->S_M.ACU]];
3254         [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", BU->S_M.EVA]];
3255         [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", BU->S_M.MOV]];
3256         [researchIMG setImage:BU->imgb];
3257         [researchIMG setImageScaling:NSScaleToFit];
3258
3259         B->R = B->R->next;
3260     }
3261     B->R = Rtop;
3262         BRUindex = 0;
3263     for (int i = 0; BRU->nameID != UC[i].nameID && i < UCN;i++) {
3264         BRUindex++;
3265
3266     }
3267         return;
3268     }
3269
3270     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
3271
3272         int k = 0;
3273         B->R = Rtop;
3274         while (B->R) {
3275             B->R = B->R->next;
3276             k++;
3277         }
3278
3279         for(int i = k;i <= crCRL;i++){
3280
3281             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ATK]];
3282             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.DEF]];
3283             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.CAP]];
3284             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ACU]];
3285             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.EVA]];
3286             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp1 + i - k)-1].S_M.MOV]];
3287             [researchIMG setImage:UC[*(GuildDisp1 + i - k)-1].imgb];
3288             [researchIMG setImageScaling:NSScaleToFit];
3289
3290         }B->R = Rtop;
3291
3292         BRUindex = 0;
3293         for (int i = 0; UC[*(GuildDisp1 + crCRL - k)-1].nameID != UC[i].nameID && i < UCN;i++) {
3294             BRUindex++;
3295         }BRU = &UC[BRUindex];
3296
3297
3298
3299     }else if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
3300
3301         int k = 0;
3302         B->R = Rtop;
3303         while (B->R) {
3304             B->R = B->R->next;
3305             k++;
3306         }
3307
3308         for(int i = k;i <= crCRL;i++){
3309
3310             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ATK]];
3311             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.DEF]];
3312             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.CAP]];
3313             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ACU]];
3314             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.EVA]];
3315             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp2 + i - k)-1].S_M.MOV]];
3316             [researchIMG setImage:UC[*(GuildDisp2 + i - k)-1].imgb];
3317             [researchIMG setImageScaling:NSScaleToFit];
3318
3319         }B->R = Rtop;
3320
3321
3322         BRUindex = 0;
3323         for (int i = 0; UC[*(GuildDisp2 + crCRL - k)-1].nameID != UC[i].nameID && i < UCN;i++) {
3324             BRUindex++;
3325         }BRU = &UC[BRUindex];
3326     }
3327
3328
3329
3330
3331
3332    }
3333
3334 -(void)SetStatusFunc{
3335     double STRfix;
3336     double VITfix;
3337     double AGIfix;
3338     double DEXfix;
3339     double MENfix;
3340     double INTfix;
3341     double LUKfix;
3342
3343     double S, V, A, D, M, I;
3344
3345
3346
3347     U = UTop;
3348
3349     while(U){
3350     STRfix = (
3351               U->C.eHandL.STR +
3352               U->C.eHandR.STR +
3353               U->C.eHead.STR +
3354               U->C.eBody.STR +
3355               U->C.eFoot.STR +
3356               U->C.eArm.STR) +
3357     U->C.S_M.STR *(
3358                          U->C.eHandL.pSTR +
3359                          U->C.eHandR.pSTR +
3360                          U->C.eHead.pSTR +
3361                          U->C.eBody.pSTR +
3362                          U->C.eFoot.pSTR +
3363                          U->C.eArm.pSTR +
3364                          0)/100
3365     ;
3366
3367     VITfix = (
3368               U->C.eHandL.VIT +
3369               U->C.eHandR.VIT +
3370               U->C.eHead.VIT +
3371               U->C.eBody.VIT +
3372               U->C.eFoot.VIT +
3373               U->C.eArm.VIT) +
3374     U->C.S_M.VIT *(
3375                          U->C.eHandL.pVIT +
3376                          U->C.eHandR.pVIT +
3377                          U->C.eHead.pVIT +
3378                          U->C.eBody.pVIT +
3379                          U->C.eFoot.pVIT +
3380                          U->C.eArm.pVIT +
3381                          0)/100
3382     ;
3383     AGIfix = (
3384               U->C.eHandL.AGI +
3385               U->C.eHandR.AGI +
3386               U->C.eHead.AGI +
3387               U->C.eBody.AGI +
3388               U->C.eFoot.AGI +
3389               U->C.eArm.AGI) +
3390     U->C.S_M.AGI *(
3391                          U->C.eHandL.pAGI +
3392                          U->C.eHandR.pAGI +
3393                          U->C.eHead.pAGI +
3394                          U->C.eBody.pAGI +
3395                          U->C.eFoot.pAGI +
3396                          U->C.eArm.pAGI +
3397                          0)/100
3398     ;
3399     DEXfix = (
3400               U->C.eHandL.DEX +
3401               U->C.eHandR.DEX +
3402               U->C.eHead.DEX +
3403               U->C.eBody.DEX +
3404               U->C.eFoot.DEX +
3405               U->C.eArm.DEX) +
3406     U->C.S_M.DEX *(
3407                          U->C.eHandL.pDEX +
3408                          U->C.eHandR.pDEX +
3409                          U->C.eHead.pDEX +
3410                          U->C.eBody.pDEX +
3411                          U->C.eFoot.pDEX +
3412                          U->C.eArm.pDEX +
3413                          0)/100
3414     ;
3415     MENfix = (
3416               U->C.eHandL.MEN +
3417               U->C.eHandR.MEN +
3418               U->C.eHead.MEN +
3419               U->C.eBody.MEN +
3420               U->C.eFoot.MEN +
3421               U->C.eArm.MEN) +
3422     U->C.S_M.MEN *(
3423                          U->C.eHandL.pMEN +
3424                          U->C.eHandR.pMEN +
3425                          U->C.eHead.pMEN +
3426                          U->C.eBody.pMEN +
3427                          U->C.eFoot.pMEN +
3428                          U->C.eArm.pMEN +
3429                          0)/100
3430     ;
3431     INTfix = (
3432               U->C.eHandL.INT +
3433               U->C.eHandR.INT +
3434               U->C.eHead.INT +
3435               U->C.eBody.INT +
3436               U->C.eFoot.INT +
3437               U->C.eArm.INT) +
3438     U->C.S_M.INT *(
3439                          U->C.eHandL.pINT +
3440                          U->C.eHandR.pINT +
3441                          U->C.eHead.pINT +
3442                          U->C.eBody.pINT +
3443                          U->C.eFoot.pINT +
3444                          U->C.eArm.pINT +
3445                          0)/100
3446     ;
3447     LUKfix = (
3448               U->C.eHandL.LUK +
3449               U->C.eHandR.LUK +
3450               U->C.eHead.LUK +
3451               U->C.eBody.LUK +
3452               U->C.eFoot.LUK +
3453               U->C.eArm.LUK) +
3454     U->C.S_M.LUK *(
3455                          U->C.eHandL.pLUK +
3456                          U->C.eHandR.pLUK +
3457                          U->C.eHead.pLUK +
3458                          U->C.eBody.pLUK +
3459                          U->C.eFoot.pLUK +
3460                          U->C.eArm.pLUK +
3461                          0)/100
3462     ;
3463
3464     S = U->C.S_C.STR + STRfix;
3465     V = U->C.S_C.VIT + VITfix;
3466     A = U->C.S_C.AGI + AGIfix;
3467     D = U->C.S_C.DEX + DEXfix;
3468     M = U->C.S_C.MEN + MENfix;
3469     I = U->C.S_C.INT + INTfix;
3470
3471     U->C.S_C.ATK = (S*5 + D*2 + A)/8;
3472     U->C.S_C.DEF = (V*5 + M*2 + S)/8;
3473     U->C.S_C.CAP = (I*4 + D*1 + M*2)/7;
3474     U->C.S_C.ACU = (D*4 + A*1 + M)/6;
3475     U->C.S_C.EVA = (A*4 + A*1 + M)/6;
3476
3477         U->C.S_C.ATK += 0.5;
3478         U->C.S_C.DEF += 0.5;
3479         U->C.S_C.CAP += 0.5;
3480         U->C.S_C.ACU += 0.5;
3481         U->C.S_C.EVA += 0.5;
3482
3483         U->C.S_C.ATK = floor(U->C.S_C.ATK);
3484         U->C.S_C.DEF = floor(U->C.S_C.DEF);
3485         U->C.S_C.CAP = floor(U->C.S_C.CAP);
3486         U->C.S_C.ACU = floor(U->C.S_C.ACU);
3487         U->C.S_C.EVA = floor(U->C.S_C.EVA);
3488
3489         U = U->next;
3490     }U = UTop;
3491
3492 }
3493
3494 -(void)initMapscript{
3495
3496     for(int i = 0;i < 9999;i++){
3497         Suicchi[i] = false;
3498     }
3499
3500     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
3501     MAPSCRIPTD *MSDtop = MS.D;
3502
3503     if(!MS.D) return;
3504     MAPSCRIPT0 *MSDPt = MS.D->P;
3505
3506     while(MS.D){
3507         MS.D->endFlag = false;
3508
3509
3510         double deltaET = floor(MS.D->ET2) - floor(MS.D->ET1);
3511         int deltaR = 0;
3512         if(deltaET < 0) deltaET = 0;
3513
3514         if(MS.D->ET1 <= eventTime && MS.D->ET2 >= eventTime){
3515             if(deltaET > 0) deltaR = rand()%(int)deltaET;
3516         }
3517
3518         MS.D->ET3 = MS.D->ET1 + (double)deltaR;
3519         MS.D->ET4 = MS.D->ET3;
3520
3521         MSDPt = MS.D->P;
3522         while (MS.D->P) {
3523                 MS.D->P->endFlag = false;
3524             MS.D->P = MS.D->P->next;
3525         }MS.D->P = MSDPt;
3526
3527         MS.D = MS.D->next;
3528     }
3529
3530     MS.D = MSDtop;
3531
3532     MSDTO = MSDtop;
3533     MF[MFselectedRow+1].MS = MS;
3534
3535     [self HensuuLoad];
3536 }
3537
3538 -(void)EventLoopFS:(NSTimer*)time{
3539
3540     if(openingAVP && openingAVPVisActive){
3541         if(openingAVP.rate <= 0 || openingAVPisDeactive){
3542             [openingAVP pause];
3543             openingAVPVisHidden = true;
3544             [self openingAVPVfunc];
3545             openingAVPVisActive = false;
3546             openingAVPisDeactive = false;
3547             if(titleBGM) [titleBGM play];
3548         }
3549     }else if(!openingAVP && openingAVPVisActive){
3550         openingAVPVisActive = false;
3551         openingAVPisDeactive = false;
3552         if(titleBGM) [titleBGM play];
3553     }
3554
3555
3556     //NSLog(@"msgCnt %d", msgCnt);
3557
3558     if(stopByFSVmenuFlag){
3559         [FSMenu makeKeyAndOrderFront:nil];
3560         [menuPanel close];
3561         moveFlag = false;
3562         attackFlag = false;
3563         summonFlag = false;
3564         menuDisplayFlag = false;
3565     }
3566
3567     if(saveDataLoadedFlag)
3568         return;
3569
3570     U = UTop;
3571     if(U){
3572     U = UTop;
3573     for(int i = 0;i < DUN[1];i++){
3574
3575         U = U->next;
3576     }
3577
3578     //NSLog(@"%d, %d", MF[0].MS.playerSet1, sdd2[0].MS.playerSet1);
3579
3580     //if(Utarget) NSLog(@"PX %d PY %d UX %d UY %d", possionX, possionY, Utarget->x, Utarget->y);
3581         U = UTop;
3582     }
3583
3584     if(coolTime){
3585
3586         lmao++;
3587
3588         if(lmao > 20){
3589             coolTime = false;
3590             lmao = 0;
3591         }
3592
3593     }
3594
3595     if(!fuckingLoadBugFix){
3596         battleRdy = false;
3597         [battleWindow close];
3598     }
3599
3600     if(extentBattleFlag){
3601         if(!battleSetUp){
3602             battleSetUp = true;
3603             attackingWait = true;
3604             goto ahhh;
3605         }
3606         if(!battleSetUpIgnore){
3607
3608             battleRdy = false;
3609             battleSet1Flag = false;
3610             battleSet2Flag = false;
3611             battleSettingFlag = false;
3612         extentBattleFlag = false;
3613             extentBattleFlag2 = true;
3614         }
3615     }
3616     if(cpuAtkExtendFlag2){
3617         if(!battleSetUp){
3618             battleSetUp = true;
3619             attackingWait = true;
3620             goto ahhh;
3621         }
3622         if(!battleSetUpIgnore){
3623
3624
3625             battleRdy = false;
3626             battleSet1Flag = false;
3627             battleSet2Flag = false;
3628             battleSettingFlag = false;
3629         extentBattleFlag = false;
3630         extentBattleFlag2 = true;
3631         cpuAtkExtendFlag2 = false;
3632         [battlePanel close];
3633         }
3634     }if(extentBattleFlag2){
3635         battleFlag = false;
3636     }
3637
3638 ahhh:{}
3639     if(setBattleModeFlag){
3640         if(!battleReadyUpFlag){battleReadyUpFlag = true;
3641
3642             P[0].resource = 500;
3643             P[0].food = 500;
3644             P[0].money = 500;
3645             P[1].resource = 500;
3646             P[1].food = 500;
3647             P[1].money = 500;
3648             P[2].resource = 500;
3649             P[2].food = 500;
3650             P[2].money = 500;
3651
3652         [battleReadyUpPN1 setStringValue:P[0].name];
3653         [battleReadyUpPN2 setStringValue:P[1].name];
3654
3655         NSString *string = @"";
3656         string = [string stringByAppendingFormat:@"%@の勝利条件\n", P[0].name];
3657         if(MF[MFselectedRow+1].MS.EGClight.endType1 == 1){
3658            string = [string stringByAppendingString:@"敵の壊滅\n"];
3659
3660         }else if(MF[MFselectedRow+1].MS.EGClight.endType1 == 2){
3661             string = [string stringByAppendingString:@"味方の壊滅\n"];
3662
3663         }
3664
3665         string = [string stringByAppendingString:@"\n"];
3666
3667         string = [string stringByAppendingFormat:@"%@の勝利条件\n", P[1].name];
3668         if(MF[MFselectedRow+1].MS.EGCdark.endType1 == 2){
3669             string = [string stringByAppendingString:@"敵の壊滅\n"];
3670         }else if(MF[MFselectedRow+1].MS.EGClight.endType1 == 1){
3671             string = [string stringByAppendingString:@"味方の壊滅\n"];
3672
3673         }
3674
3675
3676         [battleReadyUpSupply1 setIntValue:P[0].resource];
3677         [battleReadyUpFood1 setIntValue:P[0].food];
3678         [battleReadyUpMoney1 setIntValue:P[0].money];
3679
3680         [battleReadyUpSupply2 setIntValue:P[1].resource];
3681         [battleReadyUpFood2 setIntValue:P[1].food];
3682         [battleReadyUpMoney2 setIntValue:P[1].money];
3683
3684         if(MF[MFselectedRow+1].MS.playerSet1 == 1){
3685             [battleReadyUpMAN1A setEnabled:NO];
3686             [battleReadyUpMAN1B setEnabled:NO];
3687             [battleReadyUpMAN1A setState:1];
3688             [battleReadyUpMAN1B setState:0];
3689         }else if(MF[MFselectedRow+1].MS.playerSet1 == 2){
3690             [battleReadyUpMAN1A setEnabled:NO];
3691             [battleReadyUpMAN1B setEnabled:NO];
3692             [battleReadyUpMAN1A setState:0];
3693             [battleReadyUpMAN1B setState:1];
3694         }else{
3695             MF[MFselectedRow+1].MS.playerSet1 = 1;
3696             [battleReadyUpMAN1A setEnabled:YES];
3697             [battleReadyUpMAN1B setEnabled:YES];
3698             [battleReadyUpMAN1A setState:1];
3699             [battleReadyUpMAN1B setState:0];
3700         }
3701
3702         if(MF[MFselectedRow+1].MS.playerSet2 == 1){
3703             [battleReadyUpMAN2A setEnabled:NO];
3704             [battleReadyUpMAN2B setEnabled:NO];
3705             [battleReadyUpMAN2A setState:1];
3706             [battleReadyUpMAN2B setState:0];
3707         }else if(MF[MFselectedRow+1].MS.playerSet2 == 2){
3708             [battleReadyUpMAN2A setEnabled:NO];
3709             [battleReadyUpMAN2B setEnabled:NO];
3710             [battleReadyUpMAN2A setState:0];
3711             [battleReadyUpMAN2B setState:1];
3712         }else{
3713             MF[MFselectedRow+1].MS.playerSet2 = 1;
3714             [battleReadyUpMAN2A setEnabled:YES];
3715             [battleReadyUpMAN2B setEnabled:YES];
3716             [battleReadyUpMAN2A setState:1];
3717             [battleReadyUpMAN2B setState:0];
3718         }
3719
3720         }
3721
3722         if(retardhelp1){
3723             if([battleReadyUpMAN1A state] != 0)
3724                 MF[MFselectedRow+1].MS.playerSet1 = 1;
3725             else
3726                 MF[MFselectedRow+1].MS.playerSet1 = 2;
3727             retardhelp1 = false;
3728         }
3729         if(retardhelp2){
3730             if([battleReadyUpMAN2A state] != 0)
3731                 MF[MFselectedRow+1].MS.playerSet2 = 1;
3732             else
3733                 MF[MFselectedRow+1].MS.playerSet2 = 2;
3734             retardhelp2 = false;
3735         }
3736
3737         return;
3738     }
3739
3740
3741
3742     if(buildNum[possionX][possionY] < 0){
3743         [selectMesh setImage:MC[chipNum[possionX][possionY]].img];
3744         [selectMeshText setStringValue:MC[chipNum[possionX][possionY]].name];
3745         [selectMeshValue setStringValue:[NSString stringWithFormat:@"%d％", MC[chipNum[possionX][possionY]].dmgfix]];
3746     }else{
3747         [selectMesh setImage:BC[buildNum[possionX][possionY]].img];
3748         [selectMeshText setStringValue:BC[buildNum[possionX][possionY]].name];
3749         [selectMeshValue setStringValue:[NSString stringWithFormat:@"%d％", BC[buildNum[possionX][possionY]].dmgfix]];
3750     }
3751     [self SetStatusFunc];
3752
3753
3754     if(initStatusFlag){
3755
3756
3757         if(1){
3758
3759
3760
3761
3762             if(Uselected){
3763             if(Uselected->chipNumberL < 0){
3764             if(!Uselected->dead){
3765
3766                 if(Uselected->team == 0){
3767                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[0].name]];
3768                 }
3769                 if(Uselected->team == 2){
3770                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[1].name]];
3771                 }
3772                 if(Uselected->team == 1){
3773                     [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[2].name]];
3774                 }
3775
3776                 [tfName setStringValue:[NSString stringWithFormat:@"%@", Uselected->C.name]];
3777                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP %g/%g", Uselected->C.S_C.HP, Uselected->C.S_M.HP]];
3778                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"%g", Uselected->C.S_C.HP/Uselected->C.S_M.HP*100 + 0.5] intValue]];
3779                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP %g/%g", Uselected->C.S_C.MP, Uselected->C.S_M.MP]];
3780                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 %g", Uselected->C.S_C.ATK]];
3781                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 %g", Uselected->C.S_C.DEF]];
3782                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 %g", Uselected->C.S_C.CAP]];
3783                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 %g", Uselected->C.S_C.ACU]];
3784                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 %g", Uselected->C.S_C.EVA]];
3785                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 %d", Uselected->C.S_C.MOV]];
3786                 [tfWait setStringValue:[NSString stringWithFormat:@"WT %g", Uselected->C.S_C.WT]];
3787                 [selectChara setImage:Uselected->C.imgb];
3788                 [selectChara setImageScaling:NSScaleToFit];
3789
3790
3791
3792             }else{
3793                 [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3794                 [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3795                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3796                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3797                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3798                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3799                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3800                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3801                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3802                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3803                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3804                 [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3805                 [selectChara setImage:NULL];
3806
3807
3808             }
3809             }else{
3810                 if(!Uselected->dead){
3811
3812                     if(Uselected->team == 0){
3813                         [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[0].name]];
3814                     }
3815                     if(Uselected->team == 2){
3816                         [tfArmy setStringValue:[NSString stringWithFormat:@"%@", P[1].name]];
3817                     }
3818
3819                     [tfName setStringValue:[NSString stringWithFormat:@"%@", Uselected->CL.name]];
3820                     [HPbarTF setStringValue:[NSString stringWithFormat:@"HP %g/%g", Uselected->CL.S_C.HP, Uselected->CL.S_M.HP]];
3821                     [HPbarLI setIntValue:[[NSString stringWithFormat:@"%g", Uselected->CL.S_C.HP/Uselected->CL.S_M.HP*100 + 0.5] intValue]];
3822                     [MPbarTF setStringValue:[NSString stringWithFormat:@"EN %g/%g", Uselected->CL.S_C.EN, Uselected->CL.S_M.EN]];
3823                     [tfAttack setStringValue:[NSString stringWithFormat:@"移動力 %d", Uselected->CL.S_C.MOV]];
3824                     [tfDefence setStringValue:[NSString stringWithFormat:@"運動性 %g", Uselected->CL.S_C.MOB]];
3825                     [tfCalc setStringValue:[NSString stringWithFormat:@"装甲 %g", Uselected->CL.S_C.ARM]];
3826                     [tfHit setStringValue:[NSString stringWithFormat:@"限界 %g", Uselected->CL.S_C.LIM]];
3827                     [tfDodge setStringValue:[NSString stringWithFormat:@""]];
3828                     [tfMove setStringValue:[NSString stringWithFormat:@""]];
3829                     [tfWait setStringValue:[NSString stringWithFormat:@"WT %g", Uselected->CL.S_C.WT]];
3830                     [selectChara setImage:Uselected->CL.imgb];
3831                     [selectChara setImageScaling:NSScaleToFit];
3832
3833
3834                 }else{
3835                     [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3836                     [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3837                     [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3838                     [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3839                     [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3840                     [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3841                     [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3842                     [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3843                     [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3844                     [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3845                     [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3846                     [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3847                     [selectChara setImage:NULL];
3848
3849                 }
3850
3851
3852
3853             }
3854             }else{
3855                 [tfName setStringValue:[NSString stringWithFormat:@"----"]];
3856                 [tfArmy setStringValue:[NSString stringWithFormat:@"----"]];
3857                 [HPbarTF setStringValue:[NSString stringWithFormat:@"HP ----"]];
3858                 [HPbarLI setIntValue:[[NSString stringWithFormat:@"0"] intValue]];
3859                 [MPbarTF setStringValue:[NSString stringWithFormat:@"MP ----"]];
3860                 [tfAttack setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
3861                 [tfDefence setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
3862                 [tfCalc setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
3863                 [tfHit setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
3864                 [tfDodge setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
3865                 [tfMove setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
3866                 [tfWait setStringValue:[NSString stringWithFormat:@"WT ----"]];
3867                 [selectChara setImage:NULL];
3868
3869             }
3870         }
3871
3872     }
3873
3874     if(unitBreak){
3875     if(unitBreak->team == 0){
3876         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[0].resource]];
3877         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[0].food]];
3878         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[0].money]];
3879     }else if(unitBreak->team == 2){
3880         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[1].resource]];
3881         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[1].food]];
3882         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[1].money]];
3883     }else if(unitBreak->team == 1){
3884         [tfResource setStringValue:[NSString stringWithFormat:@"資源 %d", P[2].resource]];
3885         [tfFood setStringValue:[NSString stringWithFormat:@"食料 %d", P[2].food]];
3886         [tfMoney setStringValue:[NSString stringWithFormat:@"資金 %d", P[2].money]];
3887     }
3888     }
3889
3890     if(menuDisplayFlag){
3891         [self SetMenu];
3892         [self initBCreateList];
3893         [self initCSummonList];
3894     }
3895
3896     if(initMapFlag && datFileLoadCompFromTitle && !saveDataLoadedFlag){
3897
3898         mouseDoubleClickedCnt = 0;
3899         mouseDoubleClickedFlag = false;
3900         mouseClicked = false;
3901         messageDialog = false;
3902
3903         for(int i = 0;i<=1000;i++){
3904             for(int j = 0;j<= 1000;j++){
3905                 buildNum[i][j] = -1;
3906                 unitNum[i][j] = -1;
3907                 loadNum[i][j] = -1;
3908                 buildTeam[i][j] = -1;
3909                 unitTeam[i][j] = -1;
3910             }
3911         }
3912
3913         [self initUnitStatusDat];
3914         //NSLog(@"%d, %d", unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3915         [self initBuildStatusDat];
3916         msgCnt = 0;
3917         msgLvl = 0;
3918         msgLvlMax = 0;
3919         initImgFlag = false;
3920         initStringNum = false;
3921         bugFixFlag1 = false;
3922         bugFixFlag2 = false;
3923         bugFixFlag3 = false;
3924
3925         eventTime = 0;
3926         coolTime = true;
3927
3928         wtRdy = false;
3929         wtRdy2 = false;
3930         wtRdy3 = false;
3931
3932         //ここに進行したマップスクリプト値関数
3933         //NSLog(@"%d, %d", unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3934         [self setTargetListDat];
3935         [self initGuildList];
3936
3937         for(int i = 0;i < 255;i++){
3938             AUN[i] = 0;
3939             DUN[i] = 0;
3940         }
3941         cpuTurnEndFlag = false;
3942         mapChipDataLoadProc = 0;
3943
3944         U = UTop;
3945         unitBreak = U;
3946
3947         battleEndFlag = false;
3948         initStatusFlag = true;
3949         TeamCountFlag = true;
3950         cpuTurnEndFlag = false;
3951         unitColorInitFlag = true;
3952         initMapEventFlag = true;
3953         fieldViewBattleInitFlag = true;
3954         MF[MFselectedRow+1].MS = sdd2[datRow].MS;
3955         MF[MFselectedRow+1].MS.D = sdd2[datRow].MS.D;
3956         MSDTOPP = sdd2[datRow].MS.D;
3957         MSDTOP = sdd2[datRow].MS.D;
3958         msdtop = sdd2[datRow].MS.D;
3959         MSDTO = sdd2[datRow].MS.D;
3960
3961         //if(UTop) NSLog(@"%d, %d, %d", UTop->CPU, unitNum[0][0], MF[MFselectedRow].MS.playerSet1);
3962         datFileLoadCompFromTitle = false;
3963
3964         BGMsub = NULL;
3965         SEsub = NULL;
3966     }else if (initMapFlag && !initStatusFlag) {
3967         registerNum = 0;
3968         registerNumB = 0;
3969         mouseDoubleClickedCnt = 0;
3970         mouseDoubleClickedFlag = false;
3971         mouseClicked = false;
3972
3973         wtRdy = false;
3974         wtRdy2 = false;
3975         wtRdy3 = false;
3976         battleEndFlag = false;
3977
3978
3979         [self initUnitStatus];
3980         [self initBuildStatus];
3981
3982         //NSLog(@"%d", unitNum[1][1]);
3983         U = UTop;
3984
3985         while (U != NULL) {
3986             U->C.S_C.HP = U->C.S_M.HP;
3987
3988             U = U->next;
3989         }
3990         U = UTop;
3991
3992         initStatusFlag = true;
3993         unitBreak = U;
3994         TeamCountFlag = true;
3995
3996         unitColorInitFlag = true;
3997
3998         MFselectedRow = 0;
3999         for (int i = 1;i < 512;i++) {
4000             if([[SC[storyNumb].nameMAP objectAtIndex:scenarioNumb] isEqualToString:[NSString stringWithFormat:@"%@", MF[i].fileName]])
4001                 break;
4002             MFselectedRow++;
4003         }if(MFselectedRow > 510){
4004             MFselectedRow = 0;
4005             mapChipDataLoadFail = true;
4006         }
4007
4008         [self initMapscript];
4009         msgLvl = 0;
4010         msgLvlMax = 0;
4011         initImgFlag = false;
4012         initStringNum = false;
4013         bugFixFlag1 = false;
4014         bugFixFlag2 = false;
4015         bugFixFlag3 = false;
4016
4017         eventTime = 0;
4018         coolTime = true;
4019
4020         [self setTargetList];
4021
4022
4023         initMapEventFlag = true;
4024         fieldViewBattleInitFlag = true;
4025
4026
4027         for(int i = 0;i < 255;i++){
4028             AUN[i] = 0;
4029             DUN[i] = 0;
4030         }
4031
4032         [self initGuildList];
4033         cpuTurnEndFlag = false;
4034         mapChipDataLoadProc = 0;
4035     }
4036
4037     if(mapChipDataLoadFail){
4038         [endGamePanel close];
4039
4040         endGameCondition = false;
4041         initMapFlag = false;
4042         TeamCountFlag = false;
4043         initStatusFlag = false;
4044         battleBegin = false;
4045         startES = true;
4046
4047         redWinFlag = false;
4048         blueWinFlag = false;
4049         battleFlag = false;
4050         battleRdy = false;
4051
4052         mapChipDataLoadFail = false;
4053
4054         [fsWindow close];
4055
4056         esSceneProc = 0;
4057
4058         [BGMsub stop];
4059         BGMsub = NULL;
4060
4061         endGameCondition = false;
4062         initMapFlag = false;
4063         TeamCountFlag = false;
4064         initStatusFlag = false;
4065         battleBegin = false;
4066         startES = true;
4067
4068         cpuModeMOVEflag = false;
4069         cpuModeATTACKflag = false;
4070
4071         redWinFlag = false;
4072         blueWinFlag = false;
4073         cpuAImodeflag = false;
4074         cpuTurnEndFlag = true;
4075         stageClearFlag = false;
4076         waitSwtichFlag = false;
4077         battleReadyUpFlag = false;
4078         setBattleModeFlag = false;
4079
4080         wtRdy = false;
4081         wtRdy2 = false;
4082
4083
4084         Uselected = NULL;
4085         return;
4086     }else if(initMapFlag){
4087         mapChipDataLoadProc++;
4088     }
4089
4090     if(mapChipDataLoadProc > 2)
4091         mapChipDataLoadProc = 2;
4092
4093     if(mapChipDataLoadProc == 1){
4094         [fsWindow makeKeyAndOrderFront:nil];
4095         [esWindow close];
4096         [titleWindow close];
4097         mapChipDataLoadProc++;
4098     }
4099
4100     if(unitBreak){
4101         if(unitBreak->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2){
4102             unitBreak->CPU = true;
4103             cpuAImodeflag = true;
4104             //NSLog(@"OMFG");
4105         }else if(unitBreak->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2){
4106             unitBreak->CPU = true;
4107             cpuAImodeflag = true;
4108             //NSLog(@"OMFG");
4109         }else if(unitBreak->team == 1){
4110             unitBreak->CPU = true;
4111             cpuAImodeflag = true;
4112             //NSLog(@"OMFG");
4113         }
4114         else{
4115             unitBreak->CPU = false;
4116             cpuAImodeflag = false;
4117         }
4118     }
4119
4120
4121     if(cpuAImodeflag){
4122         if(!cpuTurnEndFlag && unitBreak->C.S_C.WT == 0){
4123             [fieldView modeCPUturn];
4124             CPUturn = true;
4125             //NSLog(@"%d", U->x);
4126         }else{
4127             CPUturn = false;
4128         }
4129
4130     }else{
4131         CPUturn = false;
4132     }
4133
4134
4135     //NSLog(@"%p", UTop);
4136     if(battleWindowFlag){battleFlag = true; battleWindowFlag = false;
4137
4138     }
4139
4140     if(extentBattleFlag || cpuAtkExtendFlag2){
4141         if(!attackExtentFlag && !cpuAtkExtendFlag2)
4142             attackingWait = true;
4143         else
4144             attackingWait = false;
4145         if(battleRdy)
4146             attackingWait = true;
4147      }
4148
4149     while(1){
4150         if(battleFlag && !battleSetUp){
4151
4152             if(Utarget && !battleRdy)
4153                 if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4154                     (unitBreak->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4155                     (unitBreak->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4156                     (unitBreak->team == 1)
4157                    ){
4158
4159                     //おまんこかわいい
4160
4161                     vaginaCnt++;
4162                     if(vaginaCnt > 50){
4163                         [self battleStartCPU];//攻撃目標ウェイト
4164                         attackingWait = true;
4165                         vaginaCnt = 0;
4166                         oopsCnt = 80;
4167
4168                         if(attackExtentFlag || cpuAtkExtendFlag){
4169                             attackingWait = false;
4170                         }
4171                     }else
4172                         return;
4173                 }
4174
4175         }
4176
4177         break;
4178     }
4179
4180     if(initMapFlag && battleFlag)
4181         if((!attackExtentFlag && !cpuAtkExtendFlag))
4182             if(!battleSettingFlag && attackingWait){
4183                 windowPoint.x = [mapWindow frame].origin.x;
4184                 windowPoint.y = [mapWindow frame].origin.y;
4185                 [battlePanel setFrameOrigin:windowPoint];
4186                 [battlePanel makeKeyAndOrderFront:nil];
4187                 [self setBattlePanel];
4188             }
4189
4190     if(Utarget && attackingWait){
4191
4192         if(battleSetUp && ((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4193             (unitBreak->team == 2 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet2 == 2) || (unitBreak->team == 1 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4194             (unitBreak->team == 0 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet1 == 2) || (unitBreak->team == 1 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4195             (unitBreak->team == 1 && Utarget->team == 1) ||
4196             (unitBreak->team == 2 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4197             (unitBreak->team == 0 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2)
4198             )
4199            ){
4200             if(!animationFlag1 && !animationFlag2)
4201                 oopsCnt--;
4202             if(oopsCnt > 0)
4203                 return;
4204             else{
4205                 oopsCnt = 30;//cpu攻撃設定
4206             }
4207
4208             //battleFlag = false;
4209             battleRdy = false;
4210             battleSet1Flag = false;
4211             battleSet2Flag = false;
4212             battleSettingFlag = false;
4213             attackingWait = false;
4214
4215         }
4216     }
4217
4218
4219     if(Utarget){
4220         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) ||
4221             (unitBreak->team == 0 && Utarget->team == 1 && MF[MFselectedRow+1].MS.playerSet1 == 2) || (unitBreak->team == 1 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2) ||
4222             (unitBreak->team == 1 && Utarget->team == 1) ||
4223             (unitBreak->team == 2 && Utarget->team == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
4224             (unitBreak->team == 0 && Utarget->team == 0 && MF[MFselectedRow+1].MS.playerSet1 == 2)
4225             )
4226            ){
4227
4228
4229             if(!(AVpreview.rate > 0) && !animationFlag1 && !animationFlag2)
4230                 oopsCnt--;
4231             if(oopsCnt > 0)
4232                 return;
4233             else{
4234                 //cpu攻撃ナビ
4235             }
4236
4237             bLoopFlag = false;
4238         }
4239     }
4240     damnitFixFlag = true;
4241     if(!datFileLoadCompFromTitle && initMapFlag && !battleIsProcFlag){
4242         [self EventFunc:true];
4243         if(crapBugFixFlag){
4244             crapBugFixFlag = false;
4245             return;
4246         }
4247     }
4248
4249     if(damnitFixFlag)
4250     if(battleSetUp && fuckingLoadBugFix && Uselected && !attackingWait){
4251         if(!battleSetUpIgnore && fuckingLoadBugFix){
4252             [self AttackDisplay];
4253
4254             windowPoint.x = [mapWindow frame].origin.x;
4255             windowPoint.y = [mapWindow frame].origin.y;
4256             [battleWindow setFrameOrigin:windowPoint];
4257             [battleWindow makeKeyAndOrderFront:nil];
4258         }else if(battleSetUpIgnore){
4259             [mapWindow makeKeyAndOrderFront:nil];
4260         }else{
4261             /*
4262             windowPoint.x = [mapWindow frame].origin.x;
4263             windowPoint.y = [mapWindow frame].origin.y;
4264             [battleWindow setFrameOrigin:windowPoint];
4265             [battleWindow makeKeyAndOrderFront:nil];*/
4266
4267         }
4268
4269     }
4270
4271     U = UTop;
4272
4273     if(battleRdy && battleSetUp && fuckingLoadBugFix && !battleSetUpIgnore){
4274         [self DisplayMessage];
4275     }
4276
4277     if(wtRdy3)
4278         return;
4279     U = UTop;
4280     U = unitBreak;
4281     if(battleBegin && !wtRdy2 && !battleFlag)
4282         while (!wtRdy) {
4283             wtPx = 0;
4284             wtPy = 0;
4285             //NSLog(@"eventTime%g", eventTime);
4286
4287             while (U) {
4288                 if(!U->dead && U->C.S_C.WT > 0) U->C.S_C.WT -= 1;
4289                 if(U->dead) {
4290                     U->C.S_C.WT = 999999;
4291                     //goto lolwtfshit;
4292                 }
4293                 if(U->C.S_C.WT <= 0 && !U->dead){//WTターン周り
4294                     battleEndFlag = false;
4295                     U->C.S_C.WT = 0;
4296
4297
4298                     wtUnitNum = U->number;
4299                     wtPx = U->x;
4300                     wtPy = U->y;
4301                     wtRdy = true;
4302                     wtRdy2 = true;
4303                     unitBreak = U;
4304                     Uselected = U;
4305                     possionX = unitBreak->x;
4306                     possionY = unitBreak->y;
4307                     //おまんちん
4308                     stanbyFlag = false;
4309                     wtMovedFlag = false;
4310                     wtAttackedFlag = false;
4311                     guildRE1 = false;
4312                     guildRE2 = false;
4313
4314                     [fieldView scrollPoint:NSMakePoint((wtPx-8)*32, (wtPy-8)*32)];
4315
4316
4317                     if(buildNum[U->x][U->y] >= 0){
4318                         B = BTop;
4319                         while(B){
4320
4321                             if(B->x == U->x && B->y == U->y){
4322                                 break;
4323                             }
4324                             B = B->next;
4325                         }
4326
4327                         if(!B){
4328                             B = BTop;
4329                             goto wtfshit;
4330
4331                         }
4332
4333                         if(B->C.recHP > 0){
4334                             U->C.S_C.HP += floor(U->C.S_M.HP*B->C.recHP/100);
4335                             if(U->C.S_C.HP >= U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
4336                         }
4337
4338                         if(B->C.recMP > 0){
4339                             U->C.S_C.MP += floor(U->C.S_M.MP*B->C.recMP/100);
4340                             if(U->C.S_C.MP >= U->C.S_M.MP) U->C.S_C.MP = U->C.S_M.MP;
4341                         }
4342
4343                         if(B->C.recEN > 0){
4344                             U->CL.S_C.EN += floor(U->CL.S_M.EN*B->C.recEN/100);
4345                             if(U->CL.S_C.EN >= U->CL.S_M.EN) U->CL.S_C.EN = U->CL.S_M.EN;
4346                         }
4347
4348                         if(B->C.recHPL > 0){
4349                             U->CL.S_C.HP += floor(U->CL.S_M.HP*B->C.recHPL/100);
4350                             if(U->CL.S_C.HP >= U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
4351                         }
4352
4353
4354                         B = BTop;
4355                     }
4356
4357
4358                     U = UTop;
4359
4360                     [self EventFunc:false];
4361                     pussyCumsOnlyOnceFlag = false;
4362
4363                     goto lolwtfshit;
4364                 }
4365
4366             wtfshit:{}
4367
4368                 U = U->next;
4369                 if(!U) {
4370                     BTop = B;
4371                     while(B){
4372                         if(!B->dead) B->C.S_C.WTE -= 1;
4373                         if(B->C.S_C.WTE <= 0){
4374
4375                             if(B->team == 0){
4376                                 P[0].resource += B->C.Esupply;
4377                                 P[0].food += B->C.Efood;
4378                                 P[0].money += B->C.Emoney;
4379                             }
4380                             if(B->team == 2){
4381                                 P[1].resource += B->C.Esupply;
4382                                 P[1].food += B->C.Efood;
4383                                 P[1].money += B->C.Emoney;
4384                             }
4385                             if(B->team == 1){
4386                                 P[2].resource += B->C.Esupply;
4387                                 P[2].food += B->C.Efood;
4388                                 P[2].money += B->C.Emoney;
4389                             }
4390
4391                             B->C.S_C.WTE = B->C.S_M.WTE;
4392                         }
4393                         B = B->next;
4394                     }B = BTop;
4395                 }
4396             }
4397             eventTime++;
4398             U = UTop;
4399
4400             //NSLog(@"%g", eventTime);
4401             [self EventFunc:false];
4402
4403             pussyCumsOnlyOnceFlag = false;
4404             wtRdy = false;
4405             //NSLog(@"eventTime%g", eventTime);
4406             if(!U) break;
4407             //if(wtRdy3) break;
4408
4409         }
4410     lolwtfshit:{}
4411     U = UTop;
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421     if(buildSelectedFlag){
4422         windowPoint.x = [mapWindow frame].origin.x;
4423         windowPoint.y = [mapWindow frame].origin.y;
4424         [researchPanel setFrameOrigin:windowPoint];
4425         if([self setBuildList]){
4426             [researchPanel makeKeyAndOrderFront:nil];
4427         };
4428         buildSelectedFlag = false;
4429     }
4430
4431     if(TeamCountFlag && !endGameCondition){
4432         U = UTop;
4433         TeamCount0 = 0;
4434         TeamCount2 = 0;
4435         while(U){
4436             if((U->team == 0 || U->team == 1) && !U->dead){
4437                 TeamCount0++;
4438             }
4439             else if(U->team == 2 && !U->dead){
4440                 TeamCount2++;
4441             }
4442             U = U->next;
4443         }
4444         U = UTop;
4445
4446
4447         if(targType1cnt[1] == 0 || targType2cnt[1] == 0){
4448             endGameCondition = true;
4449             redWinFlag = true;
4450             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4451
4452         }
4453         if(targType1cnt[0] == 0 || targType2cnt[0] == 0){
4454             endGameCondition = true;
4455             blueWinFlag = true;
4456             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4457
4458         }
4459
4460         if(targType2Dflag){
4461             endGameCondition = true;
4462             redWinFlag = true;
4463             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4464
4465         }
4466         if(targType2Lflag){
4467             endGameCondition = true;
4468             blueWinFlag = true;
4469             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4470
4471         }
4472
4473         if(TeamCount0 == 0 && (MF[MFselectedRow+1].MS.EGCdark.endType1 == 2 || MF[MFselectedRow+1].MS.EGCdark.endType2 == 2)){
4474             endGameCondition = true;
4475             redWinFlag = true;
4476             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[1].name]];
4477         }
4478         if(TeamCount2 == 0 && (MF[MFselectedRow+1].MS.EGClight.endType1 == 1 || MF[MFselectedRow+1].MS.EGClight.endType2 == 1)){
4479             endGameCondition = true;
4480             blueWinFlag = true;
4481             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4482
4483         }
4484     }
4485
4486
4487     static int endGamePanelWait = 100;
4488
4489     if(endGameCondition && !battleRdy){
4490
4491         if(redWinFlag && blueWinFlag){
4492
4493
4494         }else{
4495             windowPoint.x = [mapWindow frame].origin.x+30;
4496             windowPoint.y = [mapWindow frame].origin.y+200;
4497             [endGamePanel setFrameOrigin:windowPoint];
4498             [endGamePanel makeKeyAndOrderFront:nil];
4499             endGamePanelWait--;
4500             if(endGamePanelWait > 0) return;
4501         }
4502
4503         [endGamePanel close];
4504
4505         [fsWindow close];
4506
4507         esSceneProc = 0;
4508
4509         [BGMsub stop];
4510         BGMsub = NULL;
4511
4512         endGameCondition = false;
4513         initMapFlag = false;
4514         TeamCountFlag = false;
4515         initStatusFlag = false;
4516         battleBegin = false;
4517         startES = true;
4518
4519         cpuModeMOVEflag = false;
4520         cpuModeATTACKflag = false;
4521
4522         redWinFlag = false;
4523         blueWinFlag = false;
4524         cpuAImodeflag = false;
4525         cpuTurnEndFlag = true;
4526         waitSwtichFlag = false;
4527
4528         wtRdy = false;
4529         wtRdy2 = false;
4530         Uselected = NULL;
4531
4532         endGamePanelWait = 100;
4533         stageClearFlag = false;
4534         stageClearFlag2 = false;
4535         battleReadyUpFlag = false;
4536         setBattleModeFlag = false;
4537     }
4538     if(backTitleFlag){
4539
4540         [titleWindow makeKeyAndOrderFront:nil];
4541         [fsWindow close];
4542
4543         esSceneProc = 0;
4544
4545         [BGMsub stop];
4546         BGMsub = NULL;
4547
4548         endGameCondition = false;
4549         initMapFlag = false;
4550         TeamCountFlag = false;
4551         initStatusFlag = false;
4552         battleBegin = false;
4553         startES = false;
4554
4555         cpuModeMOVEflag = false;
4556         cpuModeATTACKflag = false;
4557
4558         redWinFlag = false;
4559         blueWinFlag = false;
4560         cpuAImodeflag = false;
4561         cpuTurnEndFlag = true;
4562         backTitleFlag = false;
4563         backTitleFlag2 = true;
4564         waitSwtichFlag = false;
4565         battleReadyUpFlag = false;
4566         setBattleModeFlag = false;
4567
4568
4569         wtRdy = false;
4570         wtRdy2 = false;
4571
4572         Uselected = NULL;
4573
4574     }if(stageClearFlag){
4575
4576         if(stageClearFlag2){
4577
4578             endGameCondition = true;
4579             blueWinFlag = true;
4580             [endGameText setStringValue:[NSString stringWithFormat:@"%@の勝利！", P[0].name]];
4581
4582
4583
4584             return;
4585         }
4586
4587         [fsWindow close];
4588
4589         esSceneProc = 0;
4590
4591         [BGMsub stop];
4592         BGMsub = NULL;
4593
4594         endGameCondition = false;
4595         initMapFlag = false;
4596         TeamCountFlag = false;
4597         initStatusFlag = false;
4598         battleBegin = false;
4599         startES = true;
4600
4601         cpuModeMOVEflag = false;
4602         cpuModeATTACKflag = false;
4603
4604         redWinFlag = false;
4605         blueWinFlag = false;
4606         cpuAImodeflag = false;
4607         cpuTurnEndFlag = true;
4608         stageClearFlag = false;
4609         waitSwtichFlag = false;
4610         battleReadyUpFlag = false;
4611         setBattleModeFlag = false;
4612
4613         wtRdy = false;
4614         wtRdy2 = false;
4615
4616
4617         Uselected = NULL;
4618
4619     }
4620
4621     if(gameOverFlag){
4622
4623
4624         [GameOverIV setImage:gaov.img];
4625
4626
4627         [GameOverWindow makeKeyAndOrderFront:nil];
4628         [fsWindow close];
4629
4630         endGameCondition = false;
4631         initMapFlag = false;
4632         TeamCountFlag = false;
4633         initStatusFlag = false;
4634         battleBegin = false;
4635         startES = true;
4636
4637         cpuModeMOVEflag = false;
4638         cpuModeATTACKflag = false;
4639
4640         redWinFlag = false;
4641         blueWinFlag = false;
4642         cpuAImodeflag = false;
4643         cpuTurnEndFlag = true;
4644         backTitleFlag = false;
4645         gameOverFlag = false;
4646         gameOverFlag2 = true;
4647         waitSwtichFlag = false;
4648         battleReadyUpFlag = false;
4649         setBattleModeFlag = false;
4650
4651         wtRdy = false;
4652         wtRdy2 = false;
4653         Uselected = NULL;
4654
4655     }
4656
4657     /*
4658     if(Uselected)
4659         if(!Uselected->dead){
4660
4661             U = UTop;
4662
4663             while (U->number != wtUnitNum) {
4664                 U = U->next;
4665             }
4666
4667             if(!wtMovedFlag && !wtAttackedFlag){
4668                 U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
4669             }else if(wtMovedFlag && wtAttackedFlag){
4670                 U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
4671             }else if(wtMovedFlag){
4672                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4673             }else if(wtAttackedFlag){
4674                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
4675             }
4676
4677             U = UTop;
4678
4679             wtRdy = false;
4680         }
4681     */
4682     if(summonRdyFlag){
4683         U = UTop;
4684
4685
4686         U = UTop;
4687         [self addSummonStatus];
4688
4689         U = CSLU;
4690
4691         if(U->team == 0){
4692
4693             SKILL *sTop = U->C.S;
4694
4695             while (U->C.S) {
4696                 if(U->C.S->type == 2) break;
4697                 U->C.S = U->C.S->next;
4698             }
4699
4700             U->C.S_C.MP -= U->C.S->cost[crCSL];
4701
4702             if(!U->C.S){
4703                 U->C.S = sTop;
4704                 U = UTop;
4705                 return;
4706             }
4707
4708
4709             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4710             unitTeam[possionX][possionY] = 0;
4711
4712             U->C.S = sTop;
4713             unitColorInitFlag = true;
4714         }
4715         if(U->team == 2){
4716
4717             SKILL *sTop = U->C.S;
4718
4719             while (U->C.S) {
4720                 if(U->C.S->type == 2) break;
4721                 U->C.S = U->C.S->next;
4722             }
4723
4724             U->C.S_C.MP -= U->C.S->cost[crCSL];
4725
4726             if(!U->C.S){
4727                 U->C.S = sTop;
4728                 U = UTop;
4729                 return;
4730             }
4731
4732             unitNum[possionX][possionY] = U->C.S->list[crCSL]-1;
4733             unitTeam[possionX][possionY] = 2;
4734
4735             U->C.S = sTop;
4736             unitColorInitFlag = true;
4737         }
4738
4739         summonRdyFlag = false;
4740         cslRdy = false;
4741
4742         U = UTop;
4743     }
4744
4745
4746
4747     if(unitMoveEndFlag){
4748         //pussyLoopFlag = false;
4749     }
4750
4751
4752     w000p:
4753
4754
4755     if(displayBattleCheckPanelFlag == 1){
4756         displayBattleCheckPanelFlag = 2;
4757         battleFlag = true;
4758         windowPoint.x = [mapWindow frame].origin.x;
4759         windowPoint.y = [mapWindow frame].origin.y;
4760         [atkPanel setFrameOrigin:windowPoint];
4761     }
4762
4763
4764
4765     U = UTop;
4766
4767
4768
4769
4770
4771 }
4772
4773 -(void)EventFunc:(bool)eventLoopProcFlag{
4774
4775
4776
4777
4778     if(battleSetUp){
4779         pussyLoopFlag = false;
4780     }
4781
4782
4783     if(attackingWait){
4784         return;
4785     }
4786
4787
4788     if(battleBegin && !pussyLoopFlag){
4789         //wtRdy3 = true;
4790         bool proccessTrue = false;
4791         static bool onlyBigin = false;
4792         MAPSCRIPT MS = MF[MFselectedRow+1].MS;
4793         MAPSCRIPTD *MSDtop;
4794         MSDtop = MSDTO;
4795         if(!MSDtop){
4796             wtRdy3 = false;
4797             return;
4798         }
4799
4800
4801         if(!onlyBigin){
4802             MSDP0top = MS.D->P;
4803             onlyBigin = true;
4804         }
4805
4806
4807
4808         while (MS.D) {
4809             int proccesType = -1;
4810
4811             bool EventFailFlag = false;
4812             static bool PtopFlag = false;
4813
4814
4815             enum{
4816                 ENTIRE_MAP,
4817                 CENTER_POINT
4818             };
4819
4820
4821             while(MS.D){
4822                 if(MS.D->endFlag){
4823                     MS.D = MS.D->next;
4824                 }
4825                 else
4826                     break;
4827             }
4828
4829             if(!MS.D) {
4830                 break;
4831             }
4832
4833             PtopFlag = false;
4834
4835             if(!PtopFlag){
4836                 MSDPtop = MS.D->P;
4837                 PtopFlag = true;
4838             }
4839
4840             if(MS.D)
4841                 while(MS.D->P){
4842                     if(MS.D->P->endFlag)
4843                         MS.D->P = MS.D->P->next;
4844                     else
4845                         break;
4846                 }
4847
4848                 while(MS.D->P){
4849                     if(!eventLoopProcFlag && MS.D->P->type == 0){
4850                         proccessTrue = false;
4851                         MS.D->P = MS.D->P->next;
4852                         continue;
4853                     }
4854                     break;
4855                 }
4856
4857             if(!MS.D->P){
4858                 MS.D->endFlag = true;
4859                 messageDialog = false;
4860                 [self setMessage:NULL];
4861                 MS.D->P = MSDPtop;
4862                 PtopFlag = false;
4863
4864
4865                 MAPSCRIPT0 *MSDPT = MS.D->P;
4866
4867                 if(MS.D->ETtype == 0){
4868
4869                 }else if(MS.D->ETtype == 1){
4870                     bool resultFailFlag = false;
4871                     while(MS.D->P){
4872                         if(!MS.D->P->endFlag)
4873                             resultFailFlag = true;
4874                         MS.D->P = MS.D->P->next;
4875                     }MS.D->P = MSDPT;
4876
4877                     if(resultFailFlag)
4878                         while(MS.D->P){
4879                             MS.D->P->endFlag = false;
4880                             MS.D->P = MS.D->P->next;
4881                         }MS.D->P = MSDPT;
4882
4883                 }else if(MS.D->ETtype == 2){
4884
4885                     bool resultFailFlag = false;
4886                     while(MS.D->P){
4887                         if(!MS.D->P->succeessfulFlag)
4888                             resultFailFlag = true;
4889                         MS.D->P = MS.D->P->next;
4890                     }MS.D->P = MSDPT;
4891
4892                     if(resultFailFlag)
4893                         while(MS.D->P){
4894                             MS.D->P->endFlag = false;
4895                             MS.D->P = MS.D->P->next;
4896                         }MS.D->P = MSDPT;
4897                 }else if(MS.D->ETtype == 3){
4898
4899                     bool resultFailFlag = false;
4900                     while(MS.D->P){
4901                         if(!MS.D->P->succeessfulFlag){
4902                             resultFailFlag = false;
4903                             break;
4904                         }
4905                         MS.D->P = MS.D->P->next;
4906                         resultFailFlag = true;
4907                     }MS.D->P = MSDPT;
4908
4909                     if(resultFailFlag)
4910                         while(MS.D->P){
4911                             MS.D->P->endFlag = false;
4912                             MS.D->P = MS.D->P->next;
4913                         }MS.D->P = MSDPT;
4914                     //NSLog(@"%d", UTop->x);
4915                 }else if(MS.D->ETtype == 4){
4916                     while(MS.D->P){
4917                         MS.D->P->endFlag = false;
4918                         MS.D->P = MS.D->P->next;
4919                     }MS.D->P = MSDPT;
4920                 }
4921
4922             }
4923             if(!MS.D) {
4924
4925                 break;
4926             }
4927
4928             if(!PtopFlag){
4929                 MSDPtop = MS.D->P;
4930                 PtopFlag = true;
4931             }
4932
4933             if(MS.D->switch1)
4934                 for(int i = 0;*(MS.D->switch1+i)>0;i++){
4935                     if(Suicchi[*(MS.D->switch1+i)])
4936                         continue;
4937
4938                     EventFailFlag = true;
4939                 }
4940
4941             if(MS.D->switch2)
4942                 for(int i = 0;*(MS.D->switch2+i)>0;i++){
4943                     if(!Suicchi[*(MS.D->switch2+i)])
4944                         continue;
4945
4946                     EventFailFlag = true;
4947                 }
4948             //NSLog(@"%g", eventTime);
4949
4950             //if(!MS.D->endFlag)
4951             if(eventTime == MS.D->ET4 || MS.D->ET4 == 0 || MS.D->initialDeleyedFlag){
4952
4953                 if(MS.D->P->type == 6){
4954                 if(eventTime == MS.D->ET4){
4955                     MS.D->P->S4.lagFixFlag = false;
4956                 }
4957                 else if(unitMoveEndFlag){
4958                     MS.D->P->S4.lagFixFlag = false;
4959                 }
4960                 else if(battleSetUp){
4961                     MS.D->P->S4.lagFixFlag = false;
4962                 }
4963                 else if(pushStanbyFlag){
4964                     MS.D->P->S4.lagFixFlag = false;
4965                 }
4966                 else if(battleEndFlag){
4967                     MS.D->P->S4.lagFixFlag = false;
4968                 }
4969                 else if(!MS.D->P->S4.lagFixFlag && MS.D->ET4 == 0){
4970                         MS.D->P->S4.lagFixFlag = true;
4971                     }
4972                 }
4973
4974                 if(MS.D->P->S4.lagFixFlag){
4975                     //NSLog(@"%g", eventTime);
4976                     proccessTrue = false;
4977                     goto jonny;
4978                 }
4979
4980                 proccessTrue = true;
4981                 if(MS.D->ET4 > 0){
4982
4983                     double deltaET = floor(MS.D->ET2) - floor(MS.D->ET1);
4984                     int deltaR = 0;
4985                     if(deltaET < 0) deltaET = 0;
4986
4987                     if(MS.D->ET1 <= eventTime && MS.D->ET2 >= eventTime){
4988                         if(deltaET > 0) deltaR = rand()%(int)deltaET;
4989                     }
4990
4991                     MS.D->ET3 = MS.D->ET1 + (double)deltaR;
4992
4993                     if(!MS.D->onlyInitialDeley) {
4994                         MS.D->ET4 += MS.D->ET3;
4995                     }else{
4996                         MS.D->initialDeleyedFlag = true;
4997                     }
4998                 }
4999
5000                // NSLog(@"%g %d", eventTime, P[0].resource);
5001             }else{
5002
5003                 if(wtRdy3){
5004                     proccessTrue = true;
5005                     goto jonny;
5006                 }
5007
5008                 MS.D = MS.D->next;
5009
5010                 continue;
5011             }
5012
5013         jonny:{}
5014
5015             if(MS.D->type == -1 && !EventFailFlag)
5016                 proccesType = ENTIRE_MAP;
5017             if(MS.D->type == 0 && pushStanbyFlag && (Uselected->x == MS.D->x && Uselected->y == MS.D->y) && !EventFailFlag)
5018                 proccesType = CENTER_POINT;
5019             else if(MS.D->type == 0){
5020                 proccesType = CENTER_POINT;
5021                 proccessTrue = false;
5022                 EventFailFlag = true;
5023             }
5024
5025             if(MS.D->endFlag){
5026                 MS.D = MS.D->next;
5027                 continue;
5028             }
5029
5030             if(MS.D->ET4 != 0 && pussyCumsOnlyOnceFlag){
5031                 EventFailFlag = true;
5032             }
5033
5034             marry:{}
5035             if(EventFailFlag  || !proccessTrue){
5036                 MS.D->P = MSDPtop;
5037                 MS.D = MS.D->next;
5038                 continue;
5039             }
5040
5041             if(!eventLoopProcFlag && MS.D->P->type == 0)
5042                 proccessTrue = false;
5043
5044             if(proccessTrue)
5045                 switch (proccesType) {
5046                     case ENTIRE_MAP:
5047                         MS.D->P = [self setEvent:MS.D->P];
5048
5049                         if(messageDialog){
5050                             MS.D->P = MSDPtop;
5051                             MS.D = MSDtop;
5052                             return;
5053                         }
5054                         if(waitSwtichFlag) {
5055                             MS.D->P = MSDPtop;
5056                             MS.D = MSDtop;
5057                             return;
5058                         }if(backTitleFlag){
5059                             MS.D->P = MSDPtop;
5060                             MS.D = MSDtop;
5061                             return;
5062
5063                         }if(stageClearFlag){
5064                             MS.D->P = MSDPtop;
5065                             MS.D = MSDtop;
5066                             return;
5067
5068                         }if(gameOverFlag){
5069                             MS.D->P = MSDPtop;
5070                             MS.D = MSDtop;
5071                             return;
5072
5073                         }
5074                         MS.D->P = MSDPtop;
5075                         break;
5076                     case CENTER_POINT:
5077                         MS.D->P = [self setEvent:MS.D->P];
5078                         if(messageDialog){
5079                             MS.D->P = MSDPtop;
5080                             MS.D = MSDtop;
5081                             return;
5082                         }
5083                         if(waitSwtichFlag) {
5084                             MS.D->P = MSDPtop;
5085                             MS.D = MSDtop;
5086                             return;
5087                         }if(backTitleFlag){
5088                             MS.D->P = MSDPtop;
5089                             MS.D = MSDtop;
5090                             return;
5091
5092                         }if(stageClearFlag){
5093                             MS.D->P = MSDPtop;
5094                             MS.D = MSDtop;
5095                             return;
5096
5097                         }if(gameOverFlag){
5098                             MS.D->P = MSDPtop;
5099                             MS.D = MSDtop;
5100                             return;
5101
5102                         }
5103                         MS.D->P = MSDPtop;
5104                         break;
5105
5106                     default:
5107                         MS.D->P = MSDPtop;
5108                         break;
5109                 }
5110
5111             MS.D->P = MSDPtop;
5112
5113
5114             bool PnextFlag = false;
5115
5116             MS.D->P = MSDPtop;
5117             while (MS.D->P) {
5118                 if(MS.D->P->endFlag){
5119                     MS.D->P = MS.D->P->next;
5120                 }else{
5121                     break;
5122                 }
5123                 if(!MS.D->P){
5124                     PnextFlag = true;
5125                 }
5126             }
5127
5128             MS.D->P = MSDPtop;
5129             PtopFlag = true;
5130             if(PnextFlag){
5131                 MS.D = MS.D->next;
5132                 PtopFlag = false;
5133             }
5134
5135             continue;
5136         }
5137         MS.D = MSDtop;
5138
5139         while(MS.D){
5140
5141             MAPSCRIPT0 *MSDPT = MS.D->P;
5142             if(MS.D->ETtype == 0){
5143                 while(MS.D->P){
5144                     MS.D->P->succeessfulFlag = true;
5145                     MS.D->endFlag = true;
5146                     MS.D->P = MS.D->P->next;
5147                 }MS.D->P = MSDPT;
5148             }else if(MS.D->ETtype == 1){
5149                 bool resultFailFlag = false;
5150                 while(MS.D->P){
5151                     if(!MS.D->P->endFlag)
5152                         resultFailFlag = true;
5153                     MS.D->P = MS.D->P->next;
5154                 }MS.D->P = MSDPT;
5155
5156                 if(resultFailFlag)
5157                     while(MS.D->P){
5158                         MS.D->P->succeessfulFlag = false;
5159                         MS.D->endFlag = false;
5160                         MS.D->P->endFlag = false;
5161                         MS.D->P = MS.D->P->next;
5162                     }MS.D->P = MSDPT;
5163
5164             }else if(MS.D->ETtype == 2){
5165
5166                 bool resultFailFlag = false;
5167                 while(MS.D->P){
5168                     if(!MS.D->P->succeessfulFlag)
5169                         resultFailFlag = true;
5170                     MS.D->P = MS.D->P->next;
5171                 }MS.D->P = MSDPT;
5172
5173                 if(resultFailFlag)
5174                     while(MS.D->P){
5175                         MS.D->P->succeessfulFlag = false;
5176                         MS.D->endFlag = false;
5177                         MS.D->P->endFlag = false;
5178                         MS.D->P = MS.D->P->next;
5179                     }MS.D->P = MSDPT;
5180             }else if(MS.D->ETtype == 3){
5181
5182                 bool resultFailFlag = false;
5183                 while(MS.D->P){
5184                     if(!MS.D->P->succeessfulFlag){
5185                         resultFailFlag = false;
5186                         break;
5187                     }
5188                     resultFailFlag = true;
5189                     MS.D->P = MS.D->P->next;
5190                 }MS.D->P = MSDPT;
5191
5192                 if(resultFailFlag)
5193                     while(MS.D->P){
5194                         MS.D->P->succeessfulFlag = false;
5195                         MS.D->endFlag = false;
5196                         MS.D->P->endFlag = false;
5197                         MS.D->P = MS.D->P->next;
5198                     }MS.D->P = MSDPtop;
5199             }else if(MS.D->ETtype == 4){
5200                 while(MS.D->P){
5201                     MS.D->P->succeessfulFlag = false;
5202                     MS.D->P->endFlag = false;
5203                     MS.D->endFlag = false;
5204                     MS.D->P = MS.D->P->next;
5205                 }MS.D->P = MSDPT;
5206             }
5207
5208             MS.D->P = MSDPT;
5209             MS.D = MS.D->next;
5210         }
5211
5212         MS.D = MSDtop;
5213
5214
5215
5216         MF[MFselectedRow+1].MS.D = MS.D;
5217
5218         cpuTurnEndFlag = false;
5219         battleSetUpIgnore = false;
5220         if(!eventLoopProcFlag){
5221             pussyCumsOnlyOnceFlag = true;
5222
5223         }else
5224             fuckingLoadBugFix = true;
5225         //wtRdy3 = false;
5226     }
5227
5228
5229 }
5230
5231 -(MAPSCRIPT0*)setEvent:(MAPSCRIPT0*)MS0{
5232
5233     enum{
5234         MESSAGE_FLAG,
5235         SELECTION_FLAG,
5236         INPUTNUMBER_FLAG,
5237         SWITCH_FLAG,
5238         VALUE_FLAG,
5239         TIMER_FLAG,
5240         BRANCH_FLAG,
5241         LABEL_FLAG,
5242         LABELJUMP_FLAG,
5243         COMMENT_FLAG,
5244         RESOURCE_FLAG,
5245         STATUS_FLAG = 15,
5246         APPEARANCE_FLAG = 22,
5247         DISSAPPEARANCE_FLAG = 23,
5248         WAIT_FLAG = 25,
5249         BGM_FLAG =28,
5250         SE_FLAG =30,
5251         GAMEOVER_FLAG = 35,
5252         STAGECLEAR_FLAG = 36,
5253         TITLE_FLAG = 37,
5254     };
5255
5256     int Proc = -1;
5257
5258     if(MS0->type == 0)
5259         Proc = MESSAGE_FLAG;
5260     if(MS0->type == 1)
5261         Proc = SELECTION_FLAG;
5262     if(MS0->type == 2)
5263         Proc = INPUTNUMBER_FLAG;
5264     if(MS0->type == 3)
5265         Proc = SWITCH_FLAG;
5266     if(MS0->type == 4)
5267         Proc = VALUE_FLAG;
5268     if(MS0->type == 5)
5269         Proc = TIMER_FLAG;
5270     if(MS0->type == 6)
5271         Proc = BRANCH_FLAG;
5272     if(MS0->type == 7)
5273         Proc = LABEL_FLAG;
5274     if(MS0->type == 8)
5275         Proc = LABELJUMP_FLAG;
5276     if(MS0->type == 9)
5277         Proc = COMMENT_FLAG;
5278     if(MS0->type == 10)
5279         Proc = RESOURCE_FLAG;
5280     if(MS0->type == 15)
5281         Proc = STATUS_FLAG;
5282     if(MS0->type == 22)
5283         Proc = APPEARANCE_FLAG;
5284     if(MS0->type == 23)
5285         Proc = DISSAPPEARANCE_FLAG;
5286     if(MS0->type == 25)
5287         Proc = WAIT_FLAG;
5288     if(MS0->type == 28)
5289         Proc = BGM_FLAG;
5290     if(MS0->type == 30)
5291         Proc = SE_FLAG;
5292     if(MS0->type == 35)
5293         Proc = GAMEOVER_FLAG;
5294     if(MS0->type == 36)
5295         Proc = STAGECLEAR_FLAG;
5296     if(MS0->type == 37)
5297         Proc = TITLE_FLAG;
5298
5299
5300
5301
5302     switch(Proc){
5303
5304         case MESSAGE_FLAG:
5305             messageDialog = true;
5306             [self setMessage:MS0];
5307             coolTime = true;
5308             fuckingLoadBugFix = false;
5309             break;
5310         case SELECTION_FLAG:
5311
5312             MS0 = [self setSelection:MS0];
5313             coolTime = true;
5314             break;
5315         case INPUTNUMBER_FLAG:
5316             MS0 = [self setDefault:MS0];
5317             coolTime = true;
5318             break;
5319
5320         case SWITCH_FLAG:
5321             MS0 = [self setSwitch:MS0];
5322             break;
5323         case VALUE_FLAG:
5324             MS0 = [self setDefault:MS0];
5325             break;
5326         case TIMER_FLAG:
5327             MS0 = [self setDefault:MS0];
5328             break;
5329         case BRANCH_FLAG:
5330             MS0 = [self setBranch:MS0];
5331             break;
5332         case LABEL_FLAG:
5333             MS0 = [self setLabel:MS0];
5334             break;
5335         case LABELJUMP_FLAG:
5336             MS0 = [self setLabelJump:MS0];
5337             break;
5338         case COMMENT_FLAG:
5339             MS0 = [self setComment:MS0];
5340             break;
5341         case RESOURCE_FLAG:
5342             MS0 = [self setResource:MS0];
5343             break;
5344         case STATUS_FLAG:
5345             MS0 = [self setStatus:MS0];
5346             break;
5347         case APPEARANCE_FLAG:
5348             MS0 = [self setAppearance:MS0];
5349             break;
5350         case DISSAPPEARANCE_FLAG:
5351             MS0 = [self setDissappearance:MS0];
5352             break;
5353         case WAIT_FLAG:
5354             MS0 = [self setWait:MS0];
5355             break;
5356         case BGM_FLAG:
5357             MS0 = [self setBGM:MS0];
5358             break;
5359         case SE_FLAG:
5360             MS0 = [self setSE:MS0];
5361             break;
5362         case GAMEOVER_FLAG:
5363             MS0 = [self setGameOver:MS0];
5364             coolTime = true;
5365             break;
5366         case STAGECLEAR_FLAG:
5367             MS0 = [self setStageClear:MS0];
5368             break;
5369         case TITLE_FLAG:
5370             MS0 = [self setTitleBack:MS0];
5371             break;
5372
5373     }
5374
5375
5376     return MS0;
5377 }
5378 -(void)setTargetListDat{
5379     targType1cnt[0] = -1;
5380     targType1cnt[1] = -1;
5381     targType2cnt[0] = -1;
5382     targType2cnt[1] = -1;
5383     targType2Lflag = false;
5384     targType2Dflag = false;
5385
5386     /*
5387     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5388
5389     while(1) {
5390
5391         for (int i = 0;i < 64;i++) {
5392             if(!MS.EGClight.etValue1[i]) break;
5393             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5394             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5395
5396             int Tx = [[array2 objectAtIndex:0] intValue];
5397             int Ty = [[array2 objectAtIndex:1] intValue];
5398             if(MS.EGClight.endType1 == 3){
5399                 U = UTop;
5400                 while (U) {
5401                     if(U->x == Tx && U->y == Ty){
5402                         U->targType1L = true;
5403                         if(targType1cnt[0] < 0)
5404                             targType1cnt[0] = 0;
5405                         targType1cnt[0]++;
5406                         break;
5407                     }
5408                     U = U->next;
5409                 }U = UTop;
5410             }
5411             if(MS.EGClight.endType1 == 4){
5412                 U = UTop;
5413                 while (U) {
5414                     if(U->x == Tx && U->y == Ty){
5415                         U->targType2L = true;
5416                         if(targType2cnt[0] < 0)
5417                             targType2cnt[0] = 0;
5418                         targType2cnt[0]++;
5419                         break;
5420                     }
5421                     U = U->next;
5422                 }U = UTop;
5423             }
5424         }
5425         for (int i = 0;i < 64;i++) {
5426             if(!MS.EGClight.etValue2[i]) break;
5427             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5428             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5429
5430             int Tx = [[array2 objectAtIndex:0] intValue];
5431             int Ty = [[array2 objectAtIndex:1] intValue];
5432
5433             if(MS.EGClight.endType2 == 3){
5434                 U = UTop;
5435                 while (U) {
5436                     if(U->x == Tx && U->y == Ty){
5437                         U->targType1L = true;
5438                         if(targType1cnt[0] < 0)
5439                             targType1cnt[0] = 0;
5440                         targType1cnt[0]++;
5441                         break;
5442                     }
5443                     U = U->next;
5444                 }U = UTop;
5445             }
5446             if(MS.EGClight.endType2 == 4){
5447                 U = UTop;
5448                 while (U) {
5449                     if(U->x == Tx && U->y == Ty){
5450                         U->targType2L = true;
5451                         if(targType2cnt[0] < 0)
5452                             targType2cnt[0] = 0;
5453                         targType2cnt[0]++;
5454                         break;
5455                     }
5456                     U = U->next;
5457                 }U = UTop;
5458             }
5459         }
5460         for (int i = 0;i < 64;i++) {
5461             if(!MS.EGCdark.etValue1[i]) break;
5462             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5463             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5464
5465             int Tx = [[array2 objectAtIndex:0] intValue];
5466             int Ty = [[array2 objectAtIndex:1] intValue];
5467
5468             if(MS.EGCdark.endType1 == 3){
5469                 U = UTop;
5470                 while (U) {
5471                     if(U->x == Tx && U->y == Ty){
5472                         U->targType1D = true;
5473                         if(targType1cnt[1] < 0)
5474                             targType1cnt[1] = 0;
5475                         targType1cnt[1]++;
5476                         break;
5477                     }
5478                     U = U->next;
5479                 }U = UTop;
5480             }
5481             if(MS.EGCdark.endType1 == 4){
5482                 U = UTop;
5483                 while (U) {
5484                     if(U->x == Tx && U->y == Ty){
5485                         U->targType2D = true;
5486                         if(targType2cnt[1] < 0)
5487                             targType2cnt[1] = 0;
5488                         targType2cnt[1]++;
5489                         break;
5490                     }
5491                     U = U->next;
5492                 }U = UTop;
5493             }
5494         }
5495         for (int i = 0;i < 64;i++) {
5496             if(!MS.EGCdark.etValue2[i]) break;
5497             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5498             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5499
5500             int Tx = [[array2 objectAtIndex:0] intValue];
5501             int Ty = [[array2 objectAtIndex:1] intValue];
5502
5503             if(MS.EGCdark.endType2 == 3){
5504                 U = UTop;
5505                 while (U) {
5506                     if(U->x == Tx && U->y == Ty){
5507                         U->targType1D = true;
5508                         if(targType1cnt[1] < 0)
5509                             targType1cnt[1] = 0;
5510                         targType1cnt[1]++;
5511                         break;
5512                     }
5513                     U = U->next;
5514                 }U = UTop;
5515             }
5516             if(MS.EGCdark.endType2 == 4){
5517                 U = UTop;
5518                 while (U) {
5519                     if(U->x == Tx && U->y == Ty){
5520                         U->targType2D = true;
5521                         if(targType2cnt[1] < 0)
5522                             targType2cnt[1] = 0;
5523                         targType2cnt[1]++;
5524                         break;
5525                     }
5526                     U = U->next;
5527                 }U = UTop;
5528             }
5529         }
5530         break;
5531     }
5532 */
5533
5534
5535 }
5536
5537 -(void)setTargetList{
5538
5539     targType1cnt[0] = -1;
5540     targType1cnt[1] = -1;
5541     targType2cnt[0] = -1;
5542     targType2cnt[1] = -1;
5543     targType2Lflag = false;
5544     targType2Dflag = false;
5545
5546
5547     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5548
5549     while(1) {
5550
5551         for (int i = 0;i < 64;i++) {
5552             if(!MS.EGClight.etValue1[i] || [MS.EGClight.etValue1[i] isEqualToString:@""]) break;
5553             NSArray *array1 = [MS.EGClight.etValue1[i] componentsSeparatedByString:@"["];
5554             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5555
5556             int Tx = [[array2 objectAtIndex:0] intValue];
5557             int Ty = [[array2 objectAtIndex:1] intValue];
5558             if(MS.EGClight.endType1 == 3){
5559                 U = UTop;
5560                 while (U) {
5561                     if(U->x == Tx && U->y == Ty){
5562                         U->targType1L = true;
5563                         if(targType1cnt[0] < 0)
5564                             targType1cnt[0] = 0;
5565                         targType1cnt[0]++;
5566                         break;
5567                     }
5568                     U = U->next;
5569                 }U = UTop;
5570             }
5571             if(MS.EGClight.endType1 == 4){
5572                 U = UTop;
5573                 while (U) {
5574                     if(U->x == Tx && U->y == Ty){
5575                         U->targType2L = true;
5576                         if(targType2cnt[0] < 0)
5577                             targType2cnt[0] = 0;
5578                         targType2cnt[0]++;
5579                         break;
5580                     }
5581                     U = U->next;
5582                 }U = UTop;
5583             }
5584         }
5585         for (int i = 0;i < 64;i++) {
5586             if(!MS.EGClight.etValue2[i] || [MS.EGClight.etValue2[i] isEqualToString:@""]) break;
5587             NSArray *array1 = [MS.EGClight.etValue2[i] componentsSeparatedByString:@"["];
5588             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5589
5590             int Tx = [[array2 objectAtIndex:0] intValue];
5591             int Ty = [[array2 objectAtIndex:1] intValue];
5592
5593             if(MS.EGClight.endType2 == 3){
5594             U = UTop;
5595                 while (U) {
5596                     if(U->x == Tx && U->y == Ty){
5597                         U->targType1L = true;
5598                         if(targType1cnt[0] < 0)
5599                             targType1cnt[0] = 0;
5600                         targType1cnt[0]++;
5601                         break;
5602                     }
5603                     U = U->next;
5604                 }U = UTop;
5605             }
5606             if(MS.EGClight.endType2 == 4){
5607                 U = UTop;
5608                 while (U) {
5609                     if(U->x == Tx && U->y == Ty){
5610                         U->targType2L = true;
5611                         if(targType2cnt[0] < 0)
5612                             targType2cnt[0] = 0;
5613                         targType2cnt[0]++;
5614                         break;
5615                     }
5616                     U = U->next;
5617                 }U = UTop;
5618             }
5619         }
5620         for (int i = 0;i < 64;i++) {
5621             if(!MS.EGCdark.etValue1[i] || [MS.EGCdark.etValue1[i] isEqualToString:@""]) break;
5622             NSArray *array1 = [MS.EGCdark.etValue1[i] componentsSeparatedByString:@"["];
5623             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5624
5625             int Tx = [[array2 objectAtIndex:0] intValue];
5626             int Ty = [[array2 objectAtIndex:1] intValue];
5627
5628             if(MS.EGCdark.endType1 == 3){
5629                     U = UTop;
5630                 while (U) {
5631                     if(U->x == Tx && U->y == Ty){
5632                         U->targType1D = true;
5633                         if(targType1cnt[1] < 0)
5634                             targType1cnt[1] = 0;
5635                         targType1cnt[1]++;
5636                         break;
5637                     }
5638                     U = U->next;
5639                 }U = UTop;
5640             }
5641             if(MS.EGCdark.endType1 == 4){
5642                 U = UTop;
5643                 while (U) {
5644                     if(U->x == Tx && U->y == Ty){
5645                         U->targType2D = true;
5646                         if(targType2cnt[1] < 0)
5647                             targType2cnt[1] = 0;
5648                         targType2cnt[1]++;
5649                         break;
5650                     }
5651                     U = U->next;
5652                 }U = UTop;
5653             }
5654         }
5655         for (int i = 0;i < 64;i++) {
5656             if(!MS.EGCdark.etValue2[i] || [MS.EGCdark.etValue2[i] isEqualToString:@""]) break;
5657             NSArray *array1 = [MS.EGCdark.etValue2[i] componentsSeparatedByString:@"["];
5658             NSArray *array2 = [[array1 objectAtIndex:1] componentsSeparatedByString:@","];
5659
5660             int Tx = [[array2 objectAtIndex:0] intValue];
5661             int Ty = [[array2 objectAtIndex:1] intValue];
5662
5663             if(MS.EGCdark.endType2 == 3){
5664                 U = UTop;
5665                 while (U) {
5666                     if(U->x == Tx && U->y == Ty){
5667                         U->targType1D = true;
5668                         if(targType1cnt[1] < 0)
5669                             targType1cnt[1] = 0;
5670                         targType1cnt[1]++;
5671                         break;
5672                     }
5673                     U = U->next;
5674                 }U = UTop;
5675             }
5676             if(MS.EGCdark.endType2 == 4){
5677                 U = UTop;
5678                 while (U) {
5679                     if(U->x == Tx && U->y == Ty){
5680                         U->targType2D = true;
5681                         if(targType2cnt[1] < 0)
5682                             targType2cnt[1] = 0;
5683                         targType2cnt[1]++;
5684                         break;
5685                     }
5686                     U = U->next;
5687                 }U = UTop;
5688             }
5689         }
5690         break;
5691     }
5692
5693
5694
5695
5696 }
5697
5698 -(bool)setBuildList{
5699
5700     crCRL = 0;
5701
5702     [self willChangeValueForKey:@"CResearchListMA"];
5703     [CResearchListMA removeAllObjects];
5704     [self didChangeValueForKey:@"CResearchListMA"];
5705
5706     [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 ----"]];
5707     [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 ----"]];
5708     [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 ----"]];
5709     [researchACU setStringValue:[NSString stringWithFormat:@"命中値 ----"]];
5710     [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 ----"]];
5711     [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 ----"]];
5712     [researchIMG setImage:NULL];
5713
5714     BUILDCHIP *B0;
5715
5716     B = BTop;
5717
5718     while (B && B->x != possionX && B->y != possionY) {
5719         B = B->next;
5720     }
5721     B0 = &BC[buildNum[possionX][possionY]];
5722
5723     RESEARCH *Rtop;
5724     UNITCHIP *BU;
5725
5726     Rtop = B0->R;
5727
5728
5729     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
5730
5731
5732         if(GCnum1 < 0)
5733         if(!B0->R){
5734
5735         return false;
5736
5737         }
5738     }
5739     else if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
5740
5741
5742         if(GCnum2 < 0)
5743         if(!B0->R){
5744
5745             return false;
5746
5747         }
5748     }
5749
5750     while(B0->R){
5751         BU = B0->R->U;
5752
5753         if(B->makeLv >= B0->R->Lv){
5754         NSMutableDictionary* dict = [NSMutableDictionary new];
5755         [dict setValue:[NSString stringWithFormat:@"%@", BU->nameClass] forKey:@"name"];
5756         [dict setValue:[NSString stringWithFormat:@"%g", BU->S_M.HP] forKey:@"HP"];
5757         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d", BU->S_M.cSupply, BU->S_M.cFood, BU->S_M.cMoney] forKey:@"cost"];
5758         [dict setValue:BU->img forKey:@"img"];
5759
5760
5761         [self willChangeValueForKey:@"CResearchListMA"];
5762         [CResearchListMA addObject:dict];
5763         [self didChangeValueForKey:@"CResearchListMA"];
5764         }
5765         B0->R = B0->R->next;
5766     }
5767     B0->R = Rtop;
5768
5769     B = BTop;
5770
5771     BUILDCHIP *B;
5772
5773     B = &BC[buildNum[possionX][possionY]];
5774
5775
5776     if(B0->R){
5777     Rtop = B->R;
5778
5779     BU = B->R->U;
5780     BRU = BU;
5781
5782     for(int i = 0;i <= crCRL && B->R;i++){
5783         BU = B->R->U;
5784         BRU = BU;
5785         [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", BU->S_M.ATK]];
5786         [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", BU->S_M.DEF]];
5787         [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", BU->S_M.CAP]];
5788         [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", BU->S_M.ACU]];
5789         [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", BU->S_M.EVA]];
5790         [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", BU->S_M.MOV]];
5791         [researchIMG setImage:BU->imgb];
5792         [researchIMG setImageScaling:NSScaleToFit];
5793
5794         B->R = B->R->next;
5795     }
5796     B->R = Rtop;
5797     }
5798
5799     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5800
5801     if(B->GuildFlag &&( buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1)){
5802
5803         int a = MS.guildListRegistNum12 - MS.guildListRegistNum11;
5804
5805         if(!guildRE1){
5806         Gnum1 = 0;
5807         if(a > 0)
5808             Gnum1 = MS.guildListRegistNum11 + arc4random()%(MS.guildListRegistNum12 - MS.guildListRegistNum11+1);
5809         else
5810             Gnum1 = MS.guildListRegistNum12;
5811
5812         if(Gnum1 > GCnum1+1)
5813             Gnum1 = GCnum1;
5814         }
5815         int n = 0;
5816         guildc = 0;
5817         saveGuildList = calloc((GCnum1+1), sizeof(int));
5818         if(!guildRE1) GuildDisp1 = calloc(Gnum1, sizeof(int));
5819         for(int i = 0;i < Gnum1;i++){
5820
5821             if(!guildRE1){
5822                 n = [self chooseGuildList:GuildChosen1 gcnum:GCnum1];
5823             if(n == -1)
5824                 break;
5825                 *(GuildDisp1 + i) = *(GuildChosen1 + n);
5826             }
5827
5828             if(*(GuildDisp1 + i) <= 0)
5829                 break;
5830
5831             NSMutableDictionary* dict = [NSMutableDictionary new];
5832             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp1 + i)-1].name] forKey:@"name"];
5833             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp1 + i)-1].S_M.HP] forKey:@"HP"];
5834             [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"];
5835             [dict setValue:UC[*(GuildDisp1 + i)-1].img forKey:@"img"];
5836
5837
5838             [self willChangeValueForKey:@"CResearchListMA"];
5839             [CResearchListMA addObject:dict];
5840             [self didChangeValueForKey:@"CResearchListMA"];
5841
5842         }
5843
5844
5845
5846         int k = 0;
5847         B->R = Rtop;
5848
5849         while (B->R) {
5850             B->R = B->R->next;
5851             k++;
5852         }
5853
5854         for(int i = k;i <= crCRL;i++){
5855             if(*(GuildDisp1 + i - k) <= 0)
5856                 continue;
5857
5858             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ATK]];
5859             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.DEF]];
5860             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp1 + i - k)-1].S_M.CAP]];
5861             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.ACU]];
5862             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp1 + i - k)-1].S_M.EVA]];
5863             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp1 + i - k)-1].S_M.MOV]];
5864             [researchIMG setImage:UC[*(GuildDisp1 + i - k)-1].imgb];
5865             [researchIMG setImageScaling:NSScaleToFit];
5866
5867         }B->R = Rtop;
5868
5869         guildRE1 = true;
5870     }else if(B->GuildFlag && (buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3)){
5871
5872         int a = MS.guildListRegistNum22 - MS.guildListRegistNum21;
5873
5874         if(!guildRE2){
5875         Gnum2 = 0;
5876         if(a > 0)
5877             Gnum2 = MS.guildListRegistNum21 + arc4random()%(MS.guildListRegistNum22 - MS.guildListRegistNum21+1);
5878         else
5879             Gnum2 = MS.guildListRegistNum22;
5880
5881         if(Gnum2 > GCnum2+1)
5882             Gnum2 = GCnum2;
5883         }
5884         int n = 0;
5885
5886         guildc = 0;
5887         saveGuildList = calloc((GCnum2+1), sizeof(int));
5888         if(!guildRE2) GuildDisp2 = calloc(Gnum2, sizeof(int));
5889         for(int i = 0;i < Gnum2;i++){
5890             if(!guildRE2){
5891                 n = [self chooseGuildList:GuildChosen2 gcnum:GCnum2];
5892                 if(n == -1)
5893                     break;
5894                 *(GuildDisp2 + i) = *(GuildChosen2 + n);
5895             }
5896
5897             if(*(GuildDisp2 + i) <= 0)
5898                 break;
5899
5900             NSMutableDictionary* dict = [NSMutableDictionary new];
5901             [dict setValue:[NSString stringWithFormat:@"%@", UC[*(GuildDisp2 + i)-1].name] forKey:@"name"];
5902             [dict setValue:[NSString stringWithFormat:@"%g", UC[*(GuildDisp2 + i)-1].S_M.HP] forKey:@"HP"];
5903             [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"];
5904             [dict setValue:UC[*(GuildDisp2 + i)-1].img forKey:@"img"];
5905
5906
5907             [self willChangeValueForKey:@"CResearchListMA"];
5908             [CResearchListMA addObject:dict];
5909             [self didChangeValueForKey:@"CResearchListMA"];
5910         }
5911
5912         int k = 0;
5913         B->R = Rtop;
5914         while (B->R) {
5915             B->R = B->R->next;
5916             k++;
5917         }
5918
5919         for(int i = k;i <= crCRL;i++){
5920             if(*(GuildDisp2 + i - k) <= 0)
5921                 continue;
5922
5923
5924             [researchATK setStringValue:[NSString stringWithFormat:@"攻撃力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ATK]];
5925             [researchDEF setStringValue:[NSString stringWithFormat:@"防御力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.DEF]];
5926             [researchCAP setStringValue:[NSString stringWithFormat:@"演算力 %g", UC[*(GuildDisp2 + i - k)-1].S_M.CAP]];
5927             [researchACU setStringValue:[NSString stringWithFormat:@"命中値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.ACU]];
5928             [researchEVA setStringValue:[NSString stringWithFormat:@"回避値 %g", UC[*(GuildDisp2 + i - k)-1].S_M.EVA]];
5929             [researchMOV setStringValue:[NSString stringWithFormat:@"移動力 %d", UC[*(GuildDisp2 + i - k)-1].S_M.MOV]];
5930             [researchIMG setImage:UC[*(GuildDisp2 + i - k)-1].imgb];
5931             [researchIMG setImageScaling:NSScaleToFit];
5932
5933         }B->R = Rtop;
5934
5935
5936         guildRE2 = true;
5937     }
5938
5939
5940
5941
5942
5943
5944
5945
5946     return true;
5947 }
5948 -(int)chooseGuildList:(int*)value gcnum:(int)gcnum{
5949
5950     int a = 0;
5951     while(1){
5952         bool sameFlag = false;
5953         bool sameFlag2 = false;
5954
5955         if(guildc >= gcnum+1){
5956             a = -1;
5957             break;
5958         }
5959
5960         a = arc4random()%(gcnum+1);
5961
5962         for(int i = 0;i < guildc;i++){
5963             if(*(saveGuildList+i) == a){
5964                 sameFlag2 = true;
5965                 break;
5966             }
5967         }
5968
5969         if(sameFlag2)
5970             continue;
5971
5972         *(saveGuildList+guildc) = a;
5973
5974         guildc++;
5975
5976         U = UTop;
5977         while(U){
5978             if([UC[*(value + a)-1].nameID isEqualToString:U->C.nameID]){
5979                 sameFlag = true;
5980                 break;
5981             }
5982             U = U->next;
5983         }U = UTop;
5984
5985         if(!sameFlag)
5986             break;
5987     }
5988
5989
5990     return a;
5991 }
5992
5993 -(void)initGuildList{
5994
5995     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
5996
5997     GuildChosen1 = calloc(UCN, sizeof(int));
5998     GuildChosen2 = calloc(UCN, sizeof(int));
5999
6000     GCnum1 = -1;
6001     for (int i = 0;i < UCN;i++) {
6002         if(MS.guildListRegist[i]){
6003             GCnum1++;
6004             *(GuildChosen1 + GCnum1) = i+1;
6005         }
6006     }
6007     GCnum2 = -1;
6008     for (int i = 0;i < UCN;i++) {
6009         if(MS.guildListRegist2[i]){
6010             GCnum2++;
6011             *(GuildChosen2 + GCnum2) = i+1;
6012         }
6013     }
6014
6015 }
6016
6017
6018 -(void)SetMenu{
6019
6020     [self setCommandPanel];
6021     [menuPanel makeKeyAndOrderFront:nil];
6022 }
6023
6024 -(IBAction)pushMove:(id)sender{menuDisplayFlag = false;
6025     [menuPanel close];
6026     moveFlag = true;
6027     attackFlag = false;
6028     createFlag = false;
6029     summonFlag = false;
6030 }
6031 -(IBAction)pushAttack:(id)sender{menuDisplayFlag = false;
6032     [menuPanel close];
6033     attackFlag = true;
6034     moveFlag = false;
6035     windowPoint.x = [mapWindow frame].origin.x;
6036     windowPoint.y = [mapWindow frame].origin.y;
6037     [atkPanel setFrameOrigin:windowPoint];
6038
6039     U = UTop;
6040     while (!(AUN[1] == U->number)) {
6041         U = U->next;
6042     }
6043
6044     if(U->chipNumberL >= 0){
6045         U = UTop;
6046         [self initCAttackList2];
6047         [self initCAttackSelect2];
6048     }
6049     else if(U->chipNumber >= 0) {
6050         U = UTop;
6051         [self initCAttackList];
6052         [self initCAttackSelect];
6053     }
6054     U = UTop;
6055     [atkPanel makeKeyAndOrderFront:nil];
6056 }
6057 -(IBAction)pushStandby:(id)sender{menuDisplayFlag = false;
6058
6059     U = UTop;
6060
6061     while (U->number != wtUnitNum) {
6062         U = U->next;
6063     }
6064
6065     if(!wtMovedFlag && !wtAttackedFlag){
6066         U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
6067     }else if(wtMovedFlag && wtAttackedFlag){
6068         U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
6069     }else if(wtMovedFlag){
6070         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
6071     }else if(wtAttackedFlag){
6072         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
6073     }
6074
6075     BTop = B;
6076     while (B) {
6077         if(B->x == possionX && B->y == possionY && B->C.capture){
6078             buildCaptureFlag = true;
6079             unitMoveEndFlag = true;
6080         }
6081         B = B->next;
6082     }B = BTop;
6083
6084     U = UTop;
6085
6086     wtRdy = false;
6087     wtRdy2 = false;
6088     wtRdy3 = false;
6089     pushStanbyFlag = true;
6090     pussyLoopFlag = false;
6091     [menuPanel close];
6092 }
6093 -(IBAction)pushCreate:(id)sender{menuDisplayFlag = false;
6094     [menuPanel close];
6095     createFlag = true;
6096     moveFlag = false;
6097
6098     windowPoint.x = [mapWindow frame].origin.x;
6099     windowPoint.y = [mapWindow frame].origin.y;
6100     [createPanel setFrameOrigin:windowPoint];
6101
6102     [self initBCreateList];
6103     [createPanel makeKeyAndOrderFront:nil];
6104 }
6105
6106 -(IBAction)pushSummon:(id)sender{menuDisplayFlag = false;
6107     [menuPanel close];
6108     summonFlag = true;
6109     moveFlag = false;
6110
6111     windowPoint.x = [mapWindow frame].origin.x;
6112     windowPoint.y = [mapWindow frame].origin.y;
6113     [summonPanel setFrameOrigin:windowPoint];
6114
6115     [self initCSummonList];
6116     [summonPanel makeKeyAndOrderFront:nil];
6117 }
6118
6119
6120
6121 -(void)initStatusWindow{
6122
6123     U = UTop;
6124
6125     [STIV setImage:Uselected->C.imgb];
6126     [STnameTF setStringValue:Uselected->C.name];
6127     [STclassTF setStringValue:Uselected->C.nameClass];
6128     [SThpTF setStringValue:[NSString stringWithFormat:@"HP　%g/%g", Uselected->C.S_C.HP, Uselected->C.S_M.HP]];
6129     [STmpTF setStringValue:[NSString stringWithFormat:@"MP　%g/%g", Uselected->C.S_C.MP, Uselected->C.S_M.MP]];
6130     [STatkTF setStringValue:[NSString stringWithFormat:@"ATK %g", Uselected->C.S_C.ATK]];
6131     [STdefTF setStringValue:[NSString stringWithFormat:@"DEF %g", Uselected->C.S_C.DEF]];
6132     [STcapTF setStringValue:[NSString stringWithFormat:@"CAP %g", Uselected->C.S_C.CAP]];
6133     [STacuTF setStringValue:[NSString stringWithFormat:@"ACU %g", Uselected->C.S_C.ACU]];
6134     [STevaTF setStringValue:[NSString stringWithFormat:@"EVA %g", Uselected->C.S_C.EVA]];
6135     [STstrTF setStringValue:[NSString stringWithFormat:@"STR %g", Uselected->C.S_C.STR]];
6136     [STvitTF setStringValue:[NSString stringWithFormat:@"VIT %g", Uselected->C.S_C.VIT]];
6137     [STagiTF setStringValue:[NSString stringWithFormat:@"AGI %g", Uselected->C.S_C.AGI]];
6138     [STdexTF setStringValue:[NSString stringWithFormat:@"DEX %g", Uselected->C.S_C.DEX]];
6139     [STmenTF setStringValue:[NSString stringWithFormat:@"MEN %g", Uselected->C.S_C.MEN]];
6140     [STintTF setStringValue:[NSString stringWithFormat:@"INT %g", Uselected->C.S_C.INT]];
6141     [STmelTF setStringValue:[NSString stringWithFormat:@"MEL %g", Uselected->C.S_C.MEL]];
6142     [STmisTF setStringValue:[NSString stringWithFormat:@"MIS %g", Uselected->C.S_C.MIS]];
6143     [SThitTF setStringValue:[NSString stringWithFormat:@"HIT %g", Uselected->C.S_C.HIT]];
6144     [STdodTF setStringValue:[NSString stringWithFormat:@"DOD %g", Uselected->C.S_C.DOD]];
6145     [STreaTF setStringValue:[NSString stringWithFormat:@"REA %g", Uselected->C.S_C.REA]];
6146     [STskiTF setStringValue:[NSString stringWithFormat:@"SKI %g", Uselected->C.S_C.SKI]];
6147     [STvigTF setStringValue:[NSString stringWithFormat:@"VIG %d", Uselected->C.S_C.vigor]];
6148
6149
6150
6151
6152
6153
6154
6155     U = UTop;
6156 }
6157
6158 -(IBAction)pushStatus:(id)sender{menuDisplayFlag = false;
6159
6160     [self initStatusWindow];
6161
6162     windowPoint.x = [mapWindow frame].origin.x;
6163     windowPoint.y = [mapWindow frame].origin.y;
6164     [STwindow setFrameOrigin:windowPoint];
6165     [STwindow makeKeyAndOrderFront:nil];
6166
6167
6168
6169     [menuPanel close];
6170 }
6171
6172 -(IBAction)STsubmit:(id)sender{
6173
6174     [STwindow close];
6175 }
6176
6177 -(IBAction)pushCancel:(id)sender{menuDisplayFlag = false;
6178     moveFlag = false;
6179     attackFlag = false;
6180     summonFlag = false;
6181     [menuPanel close];
6182 }
6183 -(IBAction)pushCancelCAL:(id)sender{
6184     attackFlag = false;
6185     [atkPanel close];
6186 }
6187
6188 -(IBAction)pushCancelBCL:(id)sender{
6189     createFlag = false;
6190     [createPanel close];
6191 }
6192
6193 -(IBAction)pushCancelCSL:(id)sender{
6194     summonFlag = false;
6195     [summonPanel close];
6196 }
6197
6198 -(void)addBuildStatus{
6199     //おまんちん
6200
6201     registerNumB++;
6202
6203     if(registerNumB == 1){
6204         B = calloc(1, sizeof(BUILD));
6205         BTop = B;
6206     }
6207
6208     int omgCnt = 0;
6209     B = BTop;
6210     if(B)
6211     while (B->next) {omgCnt++;
6212         B = B->next;
6213     }
6214     if(registerNumB != 1){
6215         B->next = calloc(1, sizeof(BUILD));
6216         if(registerNumB == 2)
6217             BTop = B;
6218         B = B->next;
6219     }
6220         B->next = NULL;
6221
6222     B->number = registerNumB;
6223
6224
6225     B->chipNumber = BC[buildNum[possionX][possionY]].chipNumb;
6226     B->x = possionX;
6227     B->y = possionY;
6228     B->C = BC[buildNum[possionX][possionY]];
6229     B->img = [BC[buildNum[possionX][possionY]].img retain];
6230     unitColorInitFlag = true;
6231
6232     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
6233         B->team = 0;
6234         if(unitTeam[possionX][possionY] == 0){
6235             U->joinArmyFromNext = true;
6236             U->persuasion = true;
6237         }
6238     }
6239     if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
6240         B->team = 2;
6241     }
6242     if(buildTeam[possionX][possionY] == 4 || buildTeam[possionX][possionY] == 5){
6243         B->team = 1;
6244     }
6245     if(buildTeam[possionX][possionY] == -1){
6246         B->team = -1;
6247
6248     }
6249
6250     B = BTop;
6251 }
6252
6253
6254 -(void)addUnitStatus{
6255     registerNum++;
6256     int omgCnt = 0;
6257     U = UTop;
6258     while (U->next) {omgCnt++;
6259         U = U->next;
6260     }
6261     U->next = calloc(1, sizeof(UNIT));
6262     U = U->next;
6263     U->next = NULL;
6264     if(omgCnt == 0) U = UTop;
6265     U->number = registerNum;
6266
6267     for(int i = 0;i < UCN;i++){
6268         if([U->C.nameID isEqualToString:UC[i].nameID])
6269             U->chipNumber = i;
6270     }
6271
6272     U->chipNumber = unitNum[possionX][possionY];
6273     U->chipNumberL = loadNum[possionX][possionY];
6274     U->C.chipNumb = unitNum[possionX][possionY];
6275     U->CL.chipNumb = loadNum[possionX][possionY];
6276     U->x = possionX;
6277     U->y = possionY;
6278     U->C = *BRU;
6279                 if(unitTeam[possionX][possionY] == 0 || unitTeam[possionX][possionY] == 1){
6280                     U->team = 0;
6281                     if(unitTeam[possionX][possionY] == 1){
6282                         U->joinArmyFromNext = true;
6283                         U->persuasion = true;
6284                     }
6285
6286                     if(MF[MFselectedRow+1].MS.playerSet1 == 2){
6287                         U->CPU = true;
6288                     }
6289                 }
6290                 if(unitTeam[possionX][possionY] == 2 || unitTeam[possionX][possionY] == 3){
6291                     U->team = 2;
6292                     if(unitTeam[possionX][possionY] == 3){
6293                         U->joinArmyFromNext = true;
6294                         U->persuasion = true;
6295                     }
6296
6297                     if(MF[MFselectedRow+1].MS.playerSet2 == 2){
6298                         U->CPU = true;
6299                     }
6300                 }
6301                 if(unitTeam[possionX][possionY] == 4 || unitTeam[possionX][possionY] == 5){
6302                     U->team = 1;
6303                     if(unitTeam[possionX][possionY] == 5){
6304                         U->joinArmyFromNext = true;
6305                         U->persuasion = true;
6306                     }
6307                     U->CPU = true;
6308                 }
6309                 if(unitTeam[possionX][possionY] == -1){
6310                     U->team = -1;
6311                     if(unitTeam[possionX][possionY] == 0){
6312                         U->joinArmyFromNext = false;
6313                         U->persuasion = true;
6314                     }
6315                     U->CPU = true;
6316                 }
6317
6318
6319                 [self SetUnitStatus:unitNum[possionX][possionY]];
6320     U = UTop;
6321 }
6322
6323 -(void)addSummonStatus{
6324     registerNum++;
6325     int omgCnt = 0;
6326     U = UTop;
6327     while (U->next) {omgCnt++;
6328         U = U->next;
6329     }
6330     U->next = calloc(1, sizeof(UNIT));
6331     U = U->next;
6332     U->next = NULL;
6333     if(omgCnt == 0) U = UTop;
6334
6335
6336     U->x = possionX;
6337     U->y = possionY;
6338
6339     U->C = CSLUC;
6340     if(unitTeam[CSLU->x][CSLU->y] == 0 || unitTeam[CSLU->x][CSLU->y] == 1){
6341         U->team = 0;
6342         if(unitTeam[CSLU->x][CSLU->y] == 1){
6343             U->joinArmyFromNext = true;
6344             U->persuasion = true;
6345         }
6346     }
6347     if(unitTeam[CSLU->x][CSLU->y] == 2 || unitTeam[CSLU->x][CSLU->y] == 3){
6348         U->team = 2;
6349         if(unitTeam[CSLU->x][CSLU->y] == 3){
6350             U->joinArmyFromNext = true;
6351             U->persuasion = true;
6352         }
6353     }
6354     if(unitTeam[CSLU->x][CSLU->y] == 4 || unitTeam[CSLU->x][CSLU->y] == 5){
6355         U->team = 1;
6356         if(unitTeam[CSLU->x][CSLU->y] == 5){
6357             U->joinArmyFromNext = true;
6358             U->persuasion = true;
6359         }
6360     }
6361     if(unitTeam[CSLU->x][CSLU->y] == -1){
6362         U->team = -1;
6363         if(unitTeam[CSLU->x][CSLU->y] == 0){
6364             U->joinArmyFromNext = false;
6365             U->persuasion = true;
6366         }
6367     }
6368
6369     [self SetUnitStatus:unitNum[possionX][possionY]];
6370
6371     for(int i = 0;i < UCN;i++){
6372         if([U->C.nameID isEqualToString:UC[i].nameID])
6373             U->chipNumber = i;
6374     }
6375     for(int i = 0;i < LCN;i++){
6376         if([U->CL.nameID isEqualToString:LC[i].nameID])
6377             U->chipNumberL = i;
6378     }
6379     for(int i = 0;i < UCN;i++){
6380         if([U->C.nameID isEqualToString:UC[i].nameID])
6381             U->C.chipNumb = i;
6382     }
6383     for(int i = 0;i < LCN;i++){
6384         if([U->CL.nameID isEqualToString:LC[i].nameID])
6385             U->CL.chipNumb = i;
6386     }
6387
6388     U = UTop;
6389
6390 }
6391
6392 -(void)initUnitStatusDat{
6393     U = NULL;
6394     UTop = NULL;
6395     for(int i = 0;i < sdd2[datRow].registerNum;i++){
6396         if(i == 0){
6397             U = calloc(1, sizeof(UNIT));
6398             UTop = U;
6399         }
6400         if(i > 0)
6401             U = U->next;
6402
6403         U->x = sdd2[datRow].dU[i].x;
6404         U->y = sdd2[datRow].dU[i].y;
6405         U->number = sdd2[datRow].dU[i].number;;
6406         U->chipNumber = sdd2[datRow].dU[i].chipNumber;
6407         U->chipNumberL = sdd2[datRow].dU[i].chipNumberL;
6408         U->C.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6409         U->CL.chipNumb = sdd2[datRow].dU[i].C.chipNumb;
6410         U->atkRange = 0;
6411         U->dead = sdd2[datRow].dU[i].dead;
6412
6413         U->team = sdd2[datRow].dU[i].team;
6414         U->CPU = sdd2[datRow].dU[i].CPU;
6415         U->joinArmyFromNext = sdd2[datRow].dU[i].joinArmyFromNext;
6416         U->persuasion = sdd2[datRow].dU[i].persuasion;
6417
6418         U->ix = sdd2[datRow].dU[i].ix;
6419         U->iy = sdd2[datRow].dU[i].iy;
6420         U->iz = sdd2[datRow].dU[i].iz;
6421
6422
6423
6424         if(U->chipNumber >= 0) [self SetUnitStatus:U->chipNumber];
6425         if(U->chipNumberL >= 0) [self SetUnitStatus2:U->chipNumberL];
6426
6427         U->C.S_C = sdd2[datRow].dU[i].C.S_C;
6428         U->C.R_C = sdd2[datRow].dU[i].C.R_C;
6429
6430         if(U->chipNumberL >= 0) U->img = [LC[U->chipNumberL].img retain];
6431             else U->img = [UC[U->chipNumber].img retain];
6432
6433
6434         unitTeam[U->x][U->y] = U->team;
6435         unitNum[U->x][U->y] = U->chipNumber;
6436         loadNum[U->x][U->y] = U->chipNumberL;
6437
6438
6439         U->next = calloc(1, sizeof(UNIT));
6440     }
6441
6442     if(U) U->next = NULL;
6443     U = UTop;
6444
6445 }
6446
6447
6448 -(void)initUnitStatus{
6449     registerNum = 0;
6450     U = NULL;
6451     UTop = NULL;
6452     for(int i=1;i <= chipHeight;i++){
6453         for(int j=1;j<= chipWidth;j++){
6454             if(unitNum[j][i] >= 0 || loadNum[j][i] >= 0){
6455                 registerNum++;
6456                 if(registerNum == 1){
6457                     U = calloc(1, sizeof(UNIT));
6458                     UTop = U;
6459                 }
6460                 if(registerNum > 1)
6461                     U = U->next;
6462                 U->x = j;
6463                 U->y = i;
6464                 U->number = registerNum;
6465                 U->chipNumber = unitNum[j][i];
6466                 U->chipNumberL = loadNum[j][i];
6467                 U->C.chipNumb = U->chipNumber;
6468                 U->CL.chipNumb = U->chipNumberL;
6469
6470                 if(unitTeam[j][i] == 0 || unitTeam[j][i] == 1){
6471                     U->team = 0;
6472                     if(unitTeam[j][i] == 1){
6473                         U->joinArmyFromNext = true;
6474                         U->persuasion = true;
6475                     }
6476                     if(MF[MFselectedRow+1].MS.playerSet1 == 2)
6477                         U->CPU = true;
6478                 }
6479                 if(unitTeam[j][i] == 2 || unitTeam[j][i] == 3){
6480                     U->team = 2;
6481                     if(unitTeam[i][j] == 2){
6482                         U->joinArmyFromNext = true;
6483                         U->persuasion = true;
6484                     }
6485                     if(MF[MFselectedRow+1].MS.playerSet2 == 2)
6486                         U->CPU = true;
6487                 }
6488                 if(unitTeam[j][i] == 4 || unitTeam[j][i] == 5){
6489                     U->team = 1;
6490                     if(unitTeam[j][i] == 5){
6491                         U->joinArmyFromNext = true;
6492                         U->persuasion = true;
6493                     }
6494                     U->CPU = true;
6495                 }
6496                 if(unitTeam[j][i] == -1){
6497                     U->team = -1;
6498                     if(unitTeam[j][i] == -1){
6499                         U->joinArmyFromNext = false;
6500                         U->persuasion = true;
6501                     }
6502                     U->CPU = true;
6503                 }
6504                 if(unitNum[j][i] >= 0) [self SetUnitStatus:unitNum[j][i]];
6505                 if(loadNum[j][i] >= 0) [self SetUnitStatus2:loadNum[j][i]];
6506
6507                 U->next = calloc(1, sizeof(UNIT));
6508                 U->atkRange = 0;
6509
6510                 U->ix = U->x;
6511                 U->iy = U->y;
6512                 U->iz = 0;
6513
6514                 UNIT *Ucrnt = U;
6515
6516                 U = UTop;
6517                 while(U){
6518                     if(Ucrnt->x == U->x && Ucrnt->y == U->y){
6519                         Ucrnt->iz++;
6520                     }
6521                     U = U->next;
6522                 }
6523
6524                 U = Ucrnt;
6525             }
6526
6527         }
6528     }
6529
6530     if(U) U->next = NULL;
6531
6532     U = UTop;
6533 }
6534
6535 -(void)initBuildStatusDat{
6536     B = NULL;
6537     BTop = NULL;
6538     for(int i = 0;i < sdd2[datRow].registerNumB;i++){
6539         if(i == 0){
6540             B = calloc(1, sizeof(BUILD));
6541             BTop = B;
6542         }
6543         if(i > 0)
6544             B = B->next;
6545
6546         B->x = sdd2[datRow].dB[i].x;
6547         B->y = sdd2[datRow].dB[i].y;
6548         B->team = sdd2[datRow].dB[i].team;
6549         B->number = sdd2[datRow].dB[i].number;
6550         B->chipNumber = sdd2[datRow].dB[i].chipNumber;
6551         B->makeLv = sdd2[datRow].dB[i].makeLv;
6552         B->dead = sdd2[datRow].dB[i].dead;
6553
6554         B->C = BC[B->chipNumber];
6555         B->C.S_C = sdd2[datRow].dB[i].C.S_C;
6556
6557         B->img = [BC[B->chipNumber].img retain];
6558
6559         buildTeam[B->x][B->y] = B->team;
6560         buildNum[B->x][B->y] = B->chipNumber;
6561
6562         B->next = calloc(1, sizeof(BUILD));
6563     }
6564     if(B) B->next = NULL;
6565     B = BTop;
6566
6567 }
6568
6569
6570 -(void)initBuildStatus{
6571     B = NULL;
6572     BTop = NULL;
6573     for(int i=1;i <= chipHeight;i++){
6574         for(int j=1;j<= chipWidth;j++){
6575             if(buildNum[j][i] >= 0){
6576                 registerNumB++;
6577                 if(registerNumB == 1){
6578                     B = calloc(1, sizeof(BUILD));
6579                     BTop = B;
6580                 }
6581                 if(registerNumB > 1)
6582                     B = B->next;
6583                 B->x = j;
6584                 B->y = i;
6585                 B->number = registerNumB;
6586                 B->chipNumber = buildNum[j][i];
6587                 B->makeLv = 1;
6588                 if(buildTeam[j][i] == 0 || buildTeam[j][i] == 1){
6589                     B->team = 0;
6590
6591                 }
6592                 if(buildTeam[j][i] == 2 || buildTeam[j][i] == 3){
6593                     B->team = 2;
6594
6595                 }
6596                 if(buildTeam[j][i] == 4 || buildTeam[j][i] == 5){
6597                     B->team = 1;
6598
6599                 }
6600                 if(buildTeam[j][i] == -1){
6601                     B->team = -1;
6602
6603                 }
6604                 //[self SetUnitStatus:unitNum[j][i]];
6605
6606                 B->C = BC[buildNum[j][i]];
6607
6608                 B->next = calloc(1, sizeof(BUILD));
6609
6610             }
6611
6612         }
6613     }
6614     if(B) B->next = NULL;
6615     B = BTop;
6616
6617 }
6618
6619 -(void)SetUnitStatus:(int)UN{
6620
6621     U->C = UC[UN];
6622     U->C.S_C.vigor = 100;
6623
6624     ATTACK *Atop;
6625     ATTACK *AtopE1;
6626     ATTACK *AtopE2;
6627     ATTACK *UAtop;
6628     Atop = UC[UN].A;
6629     AtopE1 = UC[UN].eHandL.A;
6630     AtopE2 = UC[UN].eHandR.A;
6631     U->C.A = calloc(1, sizeof(ATTACK));
6632     UAtop = U->C.A;
6633
6634     bool ow1 = false;
6635     bool ow2 = false;
6636
6637     while(UC[UN].eHandR.A != NULL){ow1 = true;
6638         *U->C.A = *UC[UN].eHandR.A;
6639         U->C.A->next = calloc(1, sizeof(ATTACK));
6640         U->C.A->next->next = NULL;
6641         if(UC[UN].eHandR.A->next != NULL) U->C.A = U->C.A->next;
6642         UC[UN].eHandR.A = UC[UN].eHandR.A->next;
6643         U->C.attackListNum++;
6644     }
6645     UC[UN].eHandR.A = AtopE2;
6646
6647
6648     if(ow1) {
6649         U->C.A = U->C.A->next;
6650         ow1 = false;
6651     }
6652     while(UC[UN].eHandL.A != NULL){ow2 = true;
6653         *U->C.A = *UC[UN].eHandL.A;
6654         U->C.A->next = calloc(1, sizeof(ATTACK));
6655         U->C.A->next->next = NULL;
6656         if(UC[UN].eHandL.A->next != NULL) U->C.A = U->C.A->next;
6657         UC[UN].eHandL.A = UC[UN].eHandL.A->next;
6658         U->C.attackListNum++;
6659     }
6660     UC[UN].eHandL.A = AtopE1;
6661
6662     if(ow2) {
6663         U->C.A = U->C.A->next;
6664         ow2 = false;
6665     }
6666     while(UC[UN].A != NULL){
6667         *U->C.A = *UC[UN].A;
6668         U->C.A->next = calloc(1, sizeof(ATTACK));
6669         U->C.A->next->next = NULL;
6670         if(UC[UN].A->next != NULL) U->C.A = U->C.A->next;
6671         UC[UN].A = UC[UN].A->next;
6672     }
6673     U->C.A->next = NULL;
6674     UC[UN].A = Atop;
6675     U->C.A = UAtop;
6676     if(U->C.A) if(!U->C.A->name)
6677         U->C.A = NULL;
6678
6679 }
6680
6681 -(void)SetUnitStatus2:(int)UN{
6682
6683     U->CL = LC[UN];
6684
6685     ATTACK *Atop;
6686     ATTACK *UAtop;
6687     Atop = LC[UN].A;
6688     U->CL.A = calloc(1, sizeof(ATTACK));
6689     UAtop = U->CL.A;
6690     while(LC[UN].A != NULL){
6691         *U->CL.A = *LC[UN].A;
6692         U->CL.A->next = calloc(1, sizeof(ATTACK));
6693         U->CL.A->next->next = NULL;
6694         if(LC[UN].A->next != NULL) U->CL.A = U->CL.A->next;
6695         LC[UN].A = LC[UN].A->next;
6696     }
6697     U->CL.A->next = NULL;
6698     LC[UN].A = Atop;
6699     U->CL.A = UAtop;
6700
6701 }
6702
6703
6704 -(void)initCAttackList2{
6705     crCAL = 0;
6706
6707     CAttackListMA = [NSMutableArray new];
6708
6709     [self willChangeValueForKey:@"CAttackListMA"];
6710     [CAttackListMA removeAllObjects];
6711     [self didChangeValueForKey:@"CAttackListMA"];
6712
6713     U = UTop;
6714     if(!battleSet2PushedFlag){
6715         ATTACK *Atop;
6716         while (!(AUN[1] == U->number)) {
6717             U = U->next;
6718         }
6719         Atop = U->CL.A;
6720         for(int i = 0;i < U->CL.attackListNum;i++){
6721             if(!U->CL.A) break;
6722             NSMutableDictionary* dict = [NSMutableDictionary new];
6723             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6724             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6725             if(U->CL.A->rangeA != U->CL.A->rangeB){
6726                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6727             }else{
6728                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6729             }
6730             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6731             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6732
6733             [self willChangeValueForKey:@"CAttackListMA"];
6734             [CAttackListMA addObject:dict];
6735             [self didChangeValueForKey:@"CAttackListMA"];
6736
6737             U->CL.A = U->CL.A->next;
6738         }
6739
6740         U->CL.A = Atop;
6741     }else{
6742         ATTACK *Atop;
6743         while (!(DUN[1] == U->number)) {
6744             U = U->next;
6745         }
6746         Atop = U->CL.A;
6747         for(int i = 0;i < U->CL.attackListNum;i++){
6748
6749             if(!U->CL.A){
6750                 U->CL.attackListNum = i;
6751                 break;
6752             }
6753             NSMutableDictionary* dict = [NSMutableDictionary new];
6754             [dict setValue:[NSString stringWithFormat:@"%@", U->CL.A->name] forKey:@"name"];
6755             [dict setValue:[NSString stringWithFormat:@"%g", U->CL.A->totalD] forKey:@"atk"];
6756             if(U->CL.A->rangeA != U->CL.A->rangeB){
6757                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->CL.A->rangeA, U->CL.A->rangeB] forKey:@"range"];
6758             }else{
6759                 [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->rangeA] forKey:@"range"];
6760             }
6761             [dict setValue:[NSString stringWithFormat:@"%d", U->CL.A->hitPercent] forKey:@"hit"];
6762             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6763
6764             [self willChangeValueForKey:@"CAttackListMA"];
6765             [CAttackListMA addObject:dict];
6766             [self didChangeValueForKey:@"CAttackListMA"];
6767
6768             U->CL.A = U->CL.A->next;
6769         }
6770
6771         U->CL.A = Atop;
6772
6773     }
6774     U = UTop;
6775
6776     [CAttackListAC setSelectionIndex:crCAL];
6777
6778     [self initCAttackSelect2];
6779
6780
6781
6782
6783 }
6784
6785 -(void)initCAttackList{
6786     crCAL = 0;
6787     CAttackListMA = [NSMutableArray new];
6788
6789     [self willChangeValueForKey:@"CAttackListMA"];
6790     [CAttackListMA removeAllObjects];
6791     [self didChangeValueForKey:@"CAttackListMA"];
6792
6793     U = UTop;
6794     if(!battleSet2PushedFlag){
6795         ATTACK *Atop;
6796     while (!(AUN[1] == U->number)) {
6797         U = U->next;
6798     }
6799     Atop = U->C.A;
6800         for(int i = 0;i < U->C.attackListNum;i++){
6801             if(!U->C.A) {
6802                 U->C.attackListNum = i;
6803                 break;
6804             };
6805         NSMutableDictionary* dict = [NSMutableDictionary new];
6806         [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6807         [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6808         if(U->C.A->rangeA != U->C.A->rangeB){
6809             [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6810         }else{
6811             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6812         }
6813         [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6814         //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6815
6816         [self willChangeValueForKey:@"CAttackListMA"];
6817         [CAttackListMA addObject:dict];
6818         [self didChangeValueForKey:@"CAttackListMA"];
6819
6820         U->C.A = U->C.A->next;
6821     }
6822
6823     U->C.A = Atop;
6824     }else{
6825
6826         ATTACK *Atop;
6827         while (!(DUN[1] == U->number)) {
6828             U = U->next;
6829         }
6830         Atop = U->C.A;
6831         for(int i = 0;i < U->C.attackListNum;i++){
6832             NSMutableDictionary* dict = [NSMutableDictionary new];
6833             [dict setValue:[NSString stringWithFormat:@"%@", U->C.A->name] forKey:@"name"];
6834             [dict setValue:[NSString stringWithFormat:@"%g", U->C.A->totalD] forKey:@"atk"];
6835             if(U->C.A->rangeA != U->C.A->rangeB){
6836                 [dict setValue:[NSString stringWithFormat:@"%d-%d", U->C.A->rangeA, U->C.A->rangeB] forKey:@"range"];
6837             }else{
6838                 [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->rangeA] forKey:@"range"];
6839             }
6840             [dict setValue:[NSString stringWithFormat:@"%d", U->C.A->hitPercent] forKey:@"hit"];
6841             //[dict setValue:[NSString stringWithFormat:@"%d", U->C.A->bulletC] forKey:@"bullet"];
6842
6843             [self willChangeValueForKey:@"CAttackListMA"];
6844             [CAttackListMA addObject:dict];
6845             [self didChangeValueForKey:@"CAttackListMA"];
6846
6847             U->C.A = U->C.A->next;
6848         }
6849
6850         U->C.A = Atop;
6851
6852     }
6853     U = UTop;
6854
6855     [CAttackListAC setSelectionIndex:crCAL];
6856
6857     [self initCAttackSelect];
6858 }
6859
6860 -(void)initBCreateList{
6861     BCreateListMA = [NSMutableArray new];
6862
6863     [self willChangeValueForKey:@"BCreateListMA"];
6864     [BCreateListMA removeAllObjects];
6865     [self didChangeValueForKey:@"BCreateListMA"];
6866     buildSkillFlag = false;
6867
6868     U = UTop;
6869     SKILL *Stop;
6870     while (!(AUN[1] == U->number)) {
6871         U = U->next;
6872     }
6873     Stop = U->C.S;
6874     if(!U->C.S) {
6875         U = UTop;
6876         return;
6877     }
6878     while (U->C.S->type != 1 && U->C.S->next) {
6879         U->C.S = U->C.S->next;
6880     }
6881     if(U->C.S->type != 1) {
6882         U->C.S = Stop;
6883         U = UTop;
6884         return;
6885     }
6886     for(int i = 0;U->C.S->list[i] > 0;i++){
6887         NSMutableDictionary* dict = [NSMutableDictionary new];
6888         [dict setValue:[NSString stringWithFormat:@"%@", BC[U->C.S->list[i]-1].name] forKey:@"name"];
6889         [dict setValue:[NSString stringWithFormat:@"資%d 食%d 金%d",
6890                         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"];
6891         [dict setValue:BC[U->C.S->list[i]-1].img forKey:@"img"];
6892
6893         [self willChangeValueForKey:@"BCreateListMA"];
6894         [BCreateListMA addObject:dict];
6895         [self didChangeValueForKey:@"BCreateListMA"];
6896
6897         buildSkillFlag = true;
6898     }
6899     U->C.S = Stop;
6900     U = UTop;
6901 }
6902
6903 -(void)initCSummonList{
6904     CSummonListMA = [NSMutableArray new];
6905
6906     [self willChangeValueForKey:@"CSummonListMA"];
6907     [CSummonListMA removeAllObjects];
6908     [self didChangeValueForKey:@"CSummonListMA"];
6909
6910     summonSkillFlag = false;
6911
6912     U = UTop;
6913     SKILL *Stop;
6914     while (!(AUN[1] == U->number)) {
6915         U = U->next;
6916     }
6917     Stop = U->C.S;
6918     if(!U->C.S) {
6919         U = UTop;
6920         return;
6921     }
6922     while (U->C.S->type != 2 && U->C.S->next) {
6923         U->C.S = U->C.S->next;
6924     }
6925     if(U->C.S->type != 2) {
6926         U->C.S = Stop;
6927         U = UTop;
6928         return;
6929     }
6930     for(int i = 0;U->C.S->list[i] > 0;i++){
6931         NSMutableDictionary* dict = [NSMutableDictionary new];
6932         [dict setValue:[NSString stringWithFormat:@"%@", UC[U->C.S->list[i]-1].nameClass] forKey:@"name"];
6933         [dict setValue:[NSString stringWithFormat:@"%g", UC[U->C.S->list[i]-1].S_M.HP] forKey:@"HP"];
6934         [dict setValue:[NSString stringWithFormat:@"%g", U->C.S->cost[i]] forKey:@"cost"];
6935         [dict setValue:UC[U->C.S->list[i]-1].img forKey:@"img"];
6936
6937         [self willChangeValueForKey:@"CSummonListMA"];
6938         [CSummonListMA addObject:dict];
6939         [self didChangeValueForKey:@"CSummonListMA"];
6940
6941         summonSkillFlag = true;
6942     }
6943     U->C.S = Stop;
6944     U = UTop;
6945
6946 }
6947
6948
6949 -(void)AttackDisplay{
6950
6951     if(battleRdy) return;
6952     if(!battleSetUp) return;
6953     if(!fuckingLoadBugFix) return;
6954
6955     U = UTop;
6956     while (!(AUN[1] == U->number)) {
6957         U = U->next;
6958     }
6959     [bplayer1 setImage:U->C.imgb];
6960     [bplayer1 setImageScaling:NSScaleToFit];
6961     [nplayer1 setStringValue:U->C.name];
6962     [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6963     [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6964     [iplayer1 setImage:MC[chipNum[U->x][U->y]].img];
6965     [mplayer1 setStringValue:MC[chipNum[U->x][U->y]].name];
6966     [rplayer1 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6967
6968     U = UTop;
6969
6970
6971     U = UTop;
6972     while (!(DUN[1] == U->number)) {
6973         U = U->next;
6974     }
6975     [bplayer2 setImage:U->C.imgb];
6976     [bplayer1 setImageScaling:NSScaleToFit];
6977     [nplayer2 setStringValue:U->C.name];
6978     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
6979     [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
6980     [iplayer2 setImage:MC[chipNum[U->x][U->y]].img];
6981     [mplayer2 setStringValue:MC[chipNum[U->x][U->y]].name];
6982     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U->x][U->y]].dmgfix]];
6983     U = UTop;
6984
6985     [self AttackDisplay2];
6986
6987     messageProcess = 0;
6988     [battleDialog setStringValue:@"攻撃開始!!!!"];
6989
6990     battleRdy = true;
6991
6992 }
6993
6994 -(void)AttackDisplay2{
6995
6996     U = UTop;
6997
6998     while (!(DUN[1] == U->number)) {
6999         U = U->next;
7000     }
7001     U2 = U;
7002     U = UTop;
7003     while (!(AUN[1] == U->number)) {
7004         U = U->next;
7005     }
7006
7007
7008     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){U = UTop;
7009
7010         U = UTop;
7011         while (!(AUN[1] == U->number)) {
7012             U = U->next;
7013         }
7014         [bplayer1 setImage:U->CL.imgb];
7015         [bplayer1 setImageScaling:NSScaleToFit];
7016         [nplayer1 setStringValue:U->CL.name];
7017         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7018         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
7019
7020         U = UTop;
7021
7022
7023         U = UTop;
7024         while (!(DUN[1] == U->number)) {
7025             U = U->next;
7026         }
7027         [bplayer2 setImage:U->CL.imgb];
7028         [bplayer1 setImageScaling:NSScaleToFit];
7029         [nplayer2 setStringValue:U->CL.name];
7030         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7031         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
7032         U = UTop;
7033
7034
7035     }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){U = UTop;
7036         U = UTop;
7037         while (!(AUN[1] == U->number)) {
7038             U = U->next;
7039         }
7040         [bplayer1 setImage:U->CL.imgb];
7041         [bplayer1 setImageScaling:NSScaleToFit];
7042         [nplayer1 setStringValue:U->CL.name];
7043         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7044         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
7045
7046         U = UTop;
7047
7048
7049         U = UTop;
7050         while (!(DUN[1] == U->number)) {
7051             U = U->next;
7052         }
7053         [bplayer2 setImage:U->C.imgb];
7054         [bplayer1 setImageScaling:NSScaleToFit];
7055         [nplayer2 setStringValue:U->C.name];
7056         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7057         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
7058         U = UTop;
7059
7060
7061
7062
7063     }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){U = UTop;
7064         U = UTop;
7065         while (!(AUN[1] == U->number)) {
7066             U = U->next;
7067         }
7068         [bplayer1 setImage:U->C.imgb];
7069         [bplayer1 setImageScaling:NSScaleToFit];
7070         [nplayer1 setStringValue:U->C.name];
7071         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7072         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
7073
7074         U = UTop;
7075
7076
7077         U = UTop;
7078         while (!(DUN[1] == U->number)) {
7079             U = U->next;
7080         }
7081         [bplayer2 setImage:U->CL.imgb];
7082         [bplayer1 setImageScaling:NSScaleToFit];
7083         [nplayer2 setStringValue:U->CL.name];
7084         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7085         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
7086         U = UTop;
7087     }
7088
7089
7090     U = UTop;
7091 }
7092
7093 -(bool)sortEcheck:(ATTACK*)AT opponent:(UNIT*)UT{
7094
7095     if(AT->riku == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_RIKU)
7096         return true;
7097     if(AT->umi == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_UMI)
7098         return true;
7099     if(AT->chu == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_CHU)
7100         return true;
7101     if(AT->sora == FIELD_TYPE_E && UT->C.S_C.typeMOVE == MOVE_TYPE_SORA)
7102         return true;
7103
7104
7105
7106     return false;
7107 }
7108
7109 -(void)setBattlePanel{
7110     //おまんちん
7111     U = UTop;
7112
7113     while (!(DUN[1] == U->number)) {
7114         U = U->next;
7115     }
7116     U2 = U;
7117     U = UTop;
7118     while (!(AUN[1] == U->number)) {
7119         U = U->next;
7120     }
7121
7122     if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
7123         U = UTop;
7124         [self setBattlePanelT2];
7125         return;
7126     }else if(U->chipNumberL >= 0 && U2->chipNumberL <= 0){
7127         U = UTop;
7128         [self setBattlePanelT3];
7129         return;
7130     }else if(U->chipNumberL <= 0 && U2->chipNumberL >= 0){
7131         U = UTop;
7132         [self setBattlePanelT4];
7133         return;
7134     }
7135
7136     U = UTop;
7137     while (!(AUN[1] == U->number)) {
7138         U = U->next;
7139     }
7140
7141     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7142         cpuModeBATTLEflag = false;
7143     int mostDmg = 0;
7144     int mostDmg2 = 0;
7145     int mostHit = 0;
7146     int mostNum = 0;
7147     int num = 0;
7148     ATTACK *aTop2 = U->C.A;
7149     int mpCost = 0;
7150     if(U->C.A)
7151         if(!U->C.A->D){
7152             U->C.A = NULL;
7153             aTop2 = U->C.A;
7154         }
7155
7156
7157
7158     while(U->C.A){
7159
7160         double urSupposedToGet;
7161
7162         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7163
7164         double asItIs;
7165
7166         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7167
7168
7169         double oopsIsRight = 0;
7170
7171         if(U->C.A){
7172             if(U->C.A->melee){
7173                 oopsIsRight = U->C.S_C.MEL;
7174             }else
7175                 oopsIsRight = U->C.S_C.MIS;
7176         }
7177         oopsIsRight = oopsIsRight/100;
7178
7179         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7180
7181         if(!U2->C.aura && U->C.A->D){
7182             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
7183                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7184             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
7185                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7186             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
7187                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7188             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
7189                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7190             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
7191                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7192             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7193         }else if(U->C.A->D){
7194             double val = val = 1/log(3+U2->C.S_C.MP/64);
7195             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
7196                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7197             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
7198                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7199             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
7200                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7201             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
7202                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7203             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
7204                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7205             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7206         }
7207         double val2 = log(3+U2->C.S_C.MP/64);
7208         if(U->C.aura){
7209             mostDmg2 = mostDmg2*val2;
7210         }
7211         if(U->C.A->D){
7212             if(U->C.A->D->fix == 2){
7213                 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;
7214
7215                 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;
7216                 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;
7217                 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;
7218                 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;
7219                 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;
7220
7221
7222             }else if(U->C.A->D->fix == 1){
7223                 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;
7224
7225                 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;
7226                 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;
7227                 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;
7228                 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;
7229                 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;
7230
7231             }else if(U->C.A->D->fix == 0){
7232
7233             }
7234         }
7235
7236
7237         U2A = U->C.A;
7238         costVIG = U->C.A->vigor;
7239         UNIT *oops = U;
7240         U = U2;
7241         mostDmg2 = [self dmgResist:mostDmg2];
7242
7243         //NSLog(@"crCAL1 %d", crCAL1);
7244         if(mostDmg2 < 0) mostDmg2 = 1;
7245         U = oops;
7246         if(U->C.A->D)
7247         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]){
7248
7249             mostDmg = mostDmg2;
7250
7251             //mostDmg = U->C.A->totalD;
7252             mostNum = num;
7253         }
7254         if(U->C.A->D)
7255         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]){
7256             //mostDmg = U->C.A->totalD;
7257             mostHit = U->C.A->hitPercent;
7258             mostNum = num;
7259         }
7260         U->C.A = U->C.A->next;
7261         num++;
7262     }
7263     U->C.A = aTop2;
7264
7265         if(U->C.A->extent == 0 && mostNum >= 0 && !CPUmostDmgChoice){
7266
7267             U->C.A = aTop2;
7268             crCAL1 = 0;
7269             for(int i = 0;i < mostNum;i++){
7270                 U->C.A = U->C.A->next;
7271                 crCAL1++;
7272             }
7273         }
7274         else{
7275         U->C.A = aTop2;
7276             for(int i = 0;i < crCAL1;i++){
7277                 U->C.A = U->C.A->next;
7278             }
7279         }
7280
7281         CPUmostDmgChoice = false;
7282
7283    if(U->C.A){
7284         mostNumSub = mostNum;
7285
7286
7287         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7288        costVIG = U->C.A->vigor;
7289
7290         if(U->C.A->rangeA <= unitBreak->atkRange && U->C.A->rangeB >= unitBreak->atkRange
7291            && mpCost <= U->C.S_C.MP && costVIG <= U->C.S_C.vigor){
7292
7293         }else{
7294
7295         }
7296
7297     }U->C.A = aTop2;
7298     }
7299     U = UTop;
7300
7301     while (!(AUN[1] == U->number)) {
7302         U = U->next;
7303     }
7304     U2 = U;
7305
7306     ATTACK *aTop = U->C.A;
7307     ATTACK *u2A;
7308
7309     for(int i = 0;i < crCAL1;i++){
7310         U->C.A = U->C.A->next;
7311     }
7312
7313     //NSLog(@"%@", U->C.A->name);
7314
7315     if(battleSet1Flag){
7316         U->C.A = aTop;
7317         for (int i = 0;i < crCAL1;i++) {
7318             U->C.A = U->C.A->next;
7319         }
7320
7321     }
7322
7323     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7324     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7325     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7326     //NSLog(@"crCAL1 %d", crCAL1);
7327     if(U->C.A){
7328         [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7329
7330     }
7331     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7332     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7333     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
7334     [combatLHP1 setIntValue:(int)oops];
7335     oops = U->C.S_C.MP/U->C.S_M.MP*100;
7336     [combatLMP1 setIntValue:(int)oops];
7337
7338     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7339     //NSLog(@"mostNumSub %d crCAL1 %d", mostNumSub, crCAL1);
7340     hitFix = U->C.A->hitPercent;
7341
7342     u2A = U->C.A;
7343     U->C.A = aTop;
7344
7345     if(battleDef1Flag){
7346         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7347         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7348         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7349         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7350         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7351         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7352         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7353     }
7354     if(battleDod1Flag){
7355         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7356         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7357         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7358         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7359         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7360         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7361         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7362
7363     }
7364
7365
7366
7367
7368
7369
7370
7371     U = UTop;
7372     while (!(DUN[1] == U->number)) {
7373         U = U->next;
7374     }
7375
7376     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7377
7378     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7379     if(hi < 0) hi = 0;
7380
7381     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7382
7383     if(battleDod2Flag) hit = hit / 2;
7384     hit = floor(hit);
7385
7386     if(hit > 100) hit = 100;
7387     if(hit < 0) hit = 0;
7388
7389     if(u2A->D->sort == 1){
7390         hit = 100;
7391     }
7392
7393     if([self sortEcheck:u2A opponent:U])
7394         hit = 0;
7395     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7396     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7397
7398
7399
7400     int mostDmg = 0;
7401     int mostDmg2 = 0;
7402     int mostHit = 0;
7403     int mostNum = 0;
7404     int num = 0;
7405     ATTACK *aTop2 = U->C.A;
7406     int mpCost = 0;
7407
7408
7409     while(U->C.A){
7410
7411         double urSupposedToGet;
7412
7413         if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
7414
7415         double asItIs;
7416         if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
7417
7418         double oopsIsRight = 0;
7419
7420         if(U->C.A){
7421             if(U->C.A->melee){
7422                 oopsIsRight = U->C.S_C.MEL;
7423             }else
7424                 oopsIsRight = U->C.S_C.MIS;
7425         }
7426         oopsIsRight = oopsIsRight/100;
7427
7428         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7429
7430         if(!U2->C.aura && U->C.A->D){
7431             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
7432                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7433             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
7434                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7435             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
7436                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7437             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
7438                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7439             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
7440                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
7441             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
7442         }else if(U->C.A->D){
7443             double val = val = 1/log(3+U2->C.S_C.MP/64);
7444             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
7445                                                  - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7446             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
7447                                                  - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7448             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
7449                                                  - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7450             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
7451                                                  - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7452             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
7453                                                  - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
7454             if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
7455         }
7456         double val2 = log(3+U2->C.S_C.MP/64);
7457         if(U->C.aura){
7458             mostDmg2 = mostDmg2*val2;
7459         }
7460         if(U->C.A->D){
7461             if(U->C.A->D->fix == 2){
7462                 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;
7463
7464                 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;
7465                 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;
7466                 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;
7467                 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;
7468                 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;
7469
7470
7471             }else if(U->C.A->D->fix == 1){
7472                 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;
7473
7474                 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;
7475                 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;
7476                 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;
7477                 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;
7478                 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;
7479
7480             }else if(U->C.A->D->fix == 0){
7481
7482             }
7483         }
7484
7485         U2A = U->C.A;
7486
7487         UNIT *oops = U;
7488         //U = U2;
7489         mostDmg2 = [self dmgResist:mostDmg2];
7490         U = oops;
7491
7492         costVIG = U->C.A->vigor;
7493
7494         if(U->C.A->D)
7495         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]){
7496
7497             mostDmg = mostDmg2;
7498
7499             //mostDmg = U->C.A->totalD;
7500             mostNum = num;
7501         }
7502         if(U->C.A->D)
7503         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]){
7504             //mostDmg = U->C.A->totalD;
7505             mostHit = U->C.A->hitPercent;
7506             mostNum = num;
7507         }
7508         U->C.A = U->C.A->next;
7509         num++;
7510     }
7511
7512
7513
7514     U->C.A = aTop2;
7515     if(U->C.A){
7516     mostNumSub = mostNum;
7517
7518     for(int i = 0;i < mostNum;i++){
7519         U->C.A = U->C.A->next;
7520     }
7521     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7522
7523
7524         costVIG = U->C.A->vigor;
7525
7526
7527     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){
7528
7529     }else while(U->C.A){
7530         U->C.A = U->C.A->next;
7531     }
7532
7533     }
7534
7535
7536
7537     if(battleSet2Flag){
7538             U->C.A = aTop2;
7539         //NSLog(@"%@", U->C.name);
7540         for (int i = 0;i < crCAL2;i++) {
7541             U->C.A = U->C.A->next;
7542         }
7543     }
7544
7545
7546     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7547     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7548     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7549     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7550     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7551     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
7552     [combatLHP2 setIntValue:(int)oops2];
7553     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
7554     [combatLMP2 setIntValue:(int)oops2];
7555
7556     bool counter;
7557     int mpCost2 = 0;
7558     if(U->C.A){
7559         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
7560         costVIG = U->C.A->vigor;
7561
7562     }
7563     if(U->C.A && U->C.A->D){
7564     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]){
7565         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
7566         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
7567         hitFix = U->C.A->hitPercent;
7568         counter = true;
7569     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U]){
7570         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7571     }
7572     }else{
7573         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7574     }
7575     U2A = U->C.A;
7576     U->C.A = aTop2;
7577
7578     if(battleDef2Flag){
7579         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7580         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7581         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7582         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7583         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7584         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7585         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7586     }
7587
7588     if(battleDod2Flag){
7589         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
7590         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
7591         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
7592         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7593         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7594         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7595         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7596
7597     }
7598     U = UTop;
7599     while (!(DUN[1] == U->number)) {
7600         U = U->next;
7601     }
7602     U2 = U;
7603
7604     U = UTop;
7605     while (!(AUN[1] == U->number)) {
7606         U = U->next;
7607     }
7608
7609     if(counter){
7610
7611         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
7612
7613
7614         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
7615         if(hi < 0) hi = 0;
7616
7617         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
7618         if(battleDod1Flag) hit /= 2;
7619         hit = floor(hit);
7620
7621         if(hit > 100) hit = 100;
7622         if(hit < 0) hit = 0;
7623
7624         if([self sortEcheck:U2A opponent:U])
7625             hit = 0;
7626
7627         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7628         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7629
7630     }else{
7631         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7632     }
7633
7634     U = UTop;
7635
7636     if(CPUAttackSubmitFlag){
7637         if(unitCPUAttackFlag){
7638             [battleCancelBtn setEnabled:NO];
7639             [battleCancelBtn setTransparent:YES];
7640         }else{
7641             [battleCancelBtn setEnabled:YES];
7642             [battleCancelBtn setTransparent:NO];
7643         }
7644         if(displayBattleCheckPanelFlag == 0) displayBattleCheckPanelFlag = 1;
7645     }else{
7646         [battleCancelBtn setEnabled:YES];
7647         [battleCancelBtn setTransparent:NO];
7648     }
7649
7650     U = UTop;
7651     while (!(AUN[1] == U->number)) {
7652         U = U->next;
7653     }
7654
7655     if(U->CPU){
7656         [battleAttackBtn1 setEnabled:NO];
7657         [battleAttackBtn1 setTransparent:YES];
7658         [battleGuardBtn1 setEnabled:NO];
7659         [battleGuardBtn1 setTransparent:YES];
7660         [battleDodgeBtn1 setEnabled:NO];
7661         [battleDodgeBtn1 setTransparent:YES];
7662     }else{
7663         [battleAttackBtn1 setEnabled:YES];
7664         [battleAttackBtn1 setTransparent:NO];
7665         [battleGuardBtn1 setEnabled:YES];
7666         [battleGuardBtn1 setTransparent:NO];
7667         [battleDodgeBtn1 setEnabled:YES];
7668         [battleDodgeBtn1 setTransparent:NO];
7669     }U = UTop;
7670
7671     U = UTop;
7672     while (!(DUN[1] == U->number)) {
7673         U = U->next;
7674     }
7675     if(U->CPU){
7676         [battleAttackBtn2 setEnabled:NO];
7677         [battleAttackBtn2 setTransparent:YES];
7678         [battleGuardBtn2 setEnabled:NO];
7679         [battleGuardBtn2 setTransparent:YES];
7680         [battleDodgeBtn2 setEnabled:NO];
7681         [battleDodgeBtn2 setTransparent:YES];
7682     }else{
7683         [battleAttackBtn2 setEnabled:YES];
7684         [battleAttackBtn2 setTransparent:NO];
7685         [battleGuardBtn2 setEnabled:YES];
7686         [battleGuardBtn2 setTransparent:NO];
7687         [battleDodgeBtn2 setEnabled:YES];
7688         [battleDodgeBtn2 setTransparent:NO];
7689     }U = UTop;
7690
7691
7692
7693     U = UTop;
7694
7695     for (int i = 1; i < DUN[1]; i++) {
7696         U = U->next;
7697
7698     }
7699
7700
7701     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
7702        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
7703        ){
7704
7705  //おまんこかわいい
7706
7707
7708     }else{
7709         [battleStartBtn setEnabled:YES];
7710         [battleStartBtn setTransparent:NO];
7711     }
7712
7713     U = UTop;
7714
7715     avPlayerFlag1 = false;
7716     avPlayerFlag2 = false;
7717 }
7718
7719 -(void)setBattlePanelT2{
7720
7721     U = UTop;
7722     int mpCost = 0;
7723     ATTACK *aTop2 = U->CL.A;
7724     while (!(AUN[1] == U->number)) {
7725         U = U->next;
7726     }
7727
7728     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 || MF[MFselectedRow+1].MS.playerSet2 == 2)){
7729         cpuModeBATTLEflag = false;
7730     int mostDmg = 0;
7731     int mostHit = 0;
7732     int mostNum = -1;
7733     int num = 0;
7734     int mpCost = 0;
7735     while(U->CL.A){
7736         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7737         costVIG = U->C.A->vigor;
7738         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]){
7739             mostDmg = U->CL.A->totalD;
7740             mostNum = num;
7741         }
7742         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]){
7743             //mostDmg = U->C.A->totalD;
7744             mostHit = U->CL.A->hitPercent;
7745             mostNum = num;
7746         }
7747         U->CL.A = U->CL.A->next;
7748         num++;
7749     }
7750         U->CL.A = aTop2;
7751
7752         for(int i = 0;i < crCAL1;i++){
7753             U->CL.A = U->CL.A->next;
7754
7755         }
7756         ATTACK *ua = U->CL.A;
7757
7758         U->CL.A = aTop2;
7759
7760     mostNumSub = mostNum;
7761
7762         U->CL.A = aTop2;
7763
7764         for(int i = 0;i < mostNum;i++){
7765             U->C.A = U->CL.A->next;
7766         }
7767         if(U->CL.A->extent == 0){
7768
7769             U->CL.A = aTop2;
7770             crCAL1 = 0;
7771             for(int i = 0;i < mostNum;i++){
7772                 U->CL.A = U->CL.A->next;
7773                 crCAL1++;
7774             }
7775         }
7776         else{
7777             U->CL.A = aTop2;
7778             for(int i = 0;i < crCAL1;i++){
7779                 U->CL.A = U->CL.A->next;
7780             }
7781         }
7782     }else{
7783
7784         U->CL.A = NULL;
7785     }
7786     if(U->CL.A){
7787         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7788         costVIG = U->C.A->vigor;
7789     }
7790     if(U->CL.A){
7791         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){
7792
7793         }else while(U->CL.A){
7794             U->CL.A = U->CL.A->next;
7795             crCAL1++;
7796         }
7797     }U->CL.A = aTop2;
7798
7799
7800     U = UTop;
7801     while (!(AUN[1] == U->number)) {
7802         U = U->next;
7803     }
7804     U2 = U;
7805
7806     ATTACK *aTop = U->CL.A;
7807     ATTACK *u2A;
7808
7809     if(U->C.A)
7810         crCAL1 = crCAL;
7811
7812     for(int i = 0;i < crCAL1;i++){
7813         U->CL.A = U->CL.A->next;
7814     }
7815
7816
7817     if(battleSet1Flag){
7818
7819         U->CL.A = aTop;
7820         for (int i = 0;i < crCAL1;i++) {
7821             U->CL.A = U->CL.A->next;
7822         }
7823
7824     }
7825
7826     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7827     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7828     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7829     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7830     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7831     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7832     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
7833     [combatLHP1 setIntValue:(int)oops];
7834     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
7835     [combatLMP1 setIntValue:(int)oops];
7836
7837     hit = U->CL.S_C.MOB + U->C.S_C.HIT*U->C.S_C.HP/U->C.S_M.HP;
7838     hitFix = U->CL.A->hitPercent;
7839
7840     u2A = U->CL.A;
7841     U->CL.A = aTop;
7842
7843     if(battleDef1Flag){
7844         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7845         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7846         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7847         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
7848         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7849         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7850         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7851     }
7852     if(battleDod1Flag){
7853         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7854         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7855         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7856         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
7857         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7858         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7859         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7860
7861     }
7862
7863
7864
7865
7866
7867
7868
7869     U = UTop;
7870     while (!(DUN[1] == U->number)) {
7871         U = U->next;
7872     }
7873
7874     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;
7875     if(battleDod2Flag) hit = hit / 2;
7876     hit = floor(hit);
7877
7878     if(hit > 100) hit = 100;
7879     if(hit < 0) hit = 0;
7880
7881     if(u2A->D->sort == 1){
7882         hit = 100;
7883     }
7884
7885     if([self sortEcheck:u2A opponent:U])
7886         hit = 0;
7887     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
7888     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7889
7890
7891
7892     int mostDmg = 0;
7893     int mostHit = 0;
7894     int mostNum = -1;
7895     int num = 0;
7896     costVIG = U->C.A->vigor;
7897     while(U->CL.A){
7898         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7899         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]){
7900             mostDmg = U->CL.A->totalD;
7901             mostNum = num;
7902         }
7903         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]){
7904             //mostDmg = U->C.A->totalD;
7905             mostHit = U->CL.A->hitPercent;
7906             mostNum = num;
7907         }
7908         U->CL.A = U->CL.A->next;
7909         num++;
7910     }
7911
7912     U->CL.A = aTop2;
7913
7914     mostNumSub = mostNum;
7915
7916     if(mostNum >= 0){
7917     for(int i = 0;i < mostNum;i++){
7918         U->CL.A = U->CL.A->next;
7919     }
7920     }else{
7921
7922         U->CL.A = NULL;
7923     }
7924     if(U->CL.A){
7925         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7926         costVIG = U->C.A->vigor;
7927     }
7928     if(U->CL.A){
7929     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){
7930
7931     }else while(U->CL.A){
7932         U->CL.A = U->CL.A->next;
7933     }
7934     }
7935
7936
7937
7938     if(battleSet2Flag){
7939
7940         U->CL.A = aTop2;
7941
7942         for (int i = 0;i < crCAL2;i++) {
7943             U->CL.A = U->CL.A->next;
7944         }
7945
7946     }
7947
7948
7949     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7950     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7951     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7952     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7953     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7954     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
7955     [combatLHP2 setIntValue:(int)oops2];
7956     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
7957     [combatLMP2 setIntValue:(int)oops2];
7958
7959     bool counter;
7960     int mpCost2 = 0;
7961     if(U->CL.A && U->CL.A->D){
7962     if(U->CL.A->name){
7963
7964     if(U->CL.A){
7965         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
7966
7967     }
7968     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]){
7969         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
7970         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
7971         hitFix = U->CL.A->hitPercent;
7972         counter = true;
7973     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
7974         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7975     }
7976
7977     }else{
7978         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7979     }
7980     }else{
7981         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
7982     }
7983     U2A = U->CL.A;
7984     U->CL.A = aTop2;
7985
7986     if(battleDef2Flag){
7987         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7988         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7989         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
7990         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
7991         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
7992         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
7993         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
7994     }
7995
7996     if(battleDod2Flag){
7997         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
7998         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
7999         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8000         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8001         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8002         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8003         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8004
8005     }
8006     U = UTop;
8007     while (!(AUN[1] == U->number)) {
8008         U = U->next;
8009     }
8010
8011     if(counter){
8012         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;
8013         if(battleDod1Flag) hit /= 2;
8014         hit = floor(hit);
8015
8016         if(hit > 100) hit = 100;
8017         if(hit < 0) hit = 0;
8018         if([self sortEcheck:U2A opponent:U])
8019             hit = 0;
8020         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8021         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8022
8023     }else{
8024         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8025     }
8026
8027     U = UTop;
8028     while (!(AUN[1] == U->number)) {
8029         U = U->next;
8030     }
8031
8032     if(U->CPU){
8033         [battleAttackBtn1 setEnabled:NO];
8034         [battleAttackBtn1 setTransparent:YES];
8035         [battleGuardBtn1 setEnabled:NO];
8036         [battleGuardBtn1 setTransparent:YES];
8037         [battleDodgeBtn1 setEnabled:NO];
8038         [battleDodgeBtn1 setTransparent:YES];
8039     }else{
8040         [battleAttackBtn1 setEnabled:YES];
8041         [battleAttackBtn1 setTransparent:NO];
8042         [battleGuardBtn1 setEnabled:YES];
8043         [battleGuardBtn1 setTransparent:NO];
8044         [battleDodgeBtn1 setEnabled:YES];
8045         [battleDodgeBtn1 setTransparent:NO];
8046     }U = UTop;
8047
8048     U = UTop;
8049     while (!(DUN[1] == U->number)) {
8050         U = U->next;
8051     }
8052     if(U->CPU){
8053         [battleAttackBtn2 setEnabled:NO];
8054         [battleAttackBtn2 setTransparent:YES];
8055         [battleGuardBtn2 setEnabled:NO];
8056         [battleGuardBtn2 setTransparent:YES];
8057         [battleDodgeBtn2 setEnabled:NO];
8058         [battleDodgeBtn2 setTransparent:YES];
8059     }else{
8060         [battleAttackBtn2 setEnabled:YES];
8061         [battleAttackBtn2 setTransparent:NO];
8062         [battleGuardBtn2 setEnabled:YES];
8063         [battleGuardBtn2 setTransparent:NO];
8064         [battleDodgeBtn2 setEnabled:YES];
8065         [battleDodgeBtn2 setTransparent:NO];
8066     }U = UTop;
8067
8068     U = UTop;
8069
8070     for (int i = 1; i < DUN[1]; i++) {
8071         U = U->next;
8072     }
8073
8074
8075     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8076        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8077        ){
8078         /*
8079         [battleStartBtn setEnabled:NO];
8080         [battleStartBtn setTransparent:YES];
8081          */
8082     }else{
8083         [battleStartBtn setEnabled:YES];
8084         [battleStartBtn setTransparent:NO];
8085     }
8086
8087     U = UTop;
8088
8089     avPlayerFlag1 = false;
8090     avPlayerFlag2 = false;
8091 }
8092
8093 -(void)setBattlePanelT3{
8094
8095
8096     U = UTop;
8097     while (!(AUN[1] == U->number)) {
8098         U = U->next;
8099     }
8100
8101     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 &&MF[MFselectedRow+1].MS.playerSet2 == 2)){
8102         cpuModeBATTLEflag = false;
8103     int mostDmg = 0;
8104     int mostHit = 0;
8105     int mostNum = 0;
8106     int num = 0;
8107     ATTACK *aTop2 = U->C.A;
8108     int mpCost = 0;
8109     while(U->C.A){
8110         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8111
8112         costVIG = U->C.A->vigor;
8113         if(U->C.A->D)
8114         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]){
8115             mostDmg = U->C.A->totalD;
8116             mostNum = num;
8117         }
8118         if(U->C.A->D)
8119         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]){
8120             //mostDmg = U->C.A->totalD;
8121             mostHit = U->C.A->hitPercent;
8122             mostNum = num;
8123         }
8124         U->C.A = U->C.A->next;
8125         num++;
8126     }
8127         U->C.A = aTop2;
8128
8129         for(int i = 0;i < crCAL1;i++){
8130             U->C.A = U->C.A->next;
8131
8132         }
8133         ATTACK *ua = U->C.A;
8134
8135         U->C.A = aTop2;
8136
8137     mostNumSub = mostNum;
8138         U->C.A = aTop2;
8139
8140         for(int i = 0;i < mostNum;i++){
8141             U->C.A = U->C.A->next;
8142         }
8143         if(U->C.A->extent == 0 && mostNum > 0){
8144
8145             U->C.A = aTop2;
8146             crCAL1 = 0;
8147             for(int i = 0;i < mostNum;i++){
8148                 U->C.A = U->C.A->next;
8149                 crCAL1++;
8150             }
8151         }
8152         else{
8153             U->C.A = aTop2;
8154             for(int i = 0;i < crCAL1;i++){
8155                 U->C.A = U->C.A->next;
8156             }
8157         }
8158     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8159         costVIG = U->C.A->vigor;
8160
8161
8162     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){
8163
8164     }else{
8165
8166     }
8167       U->C.A = aTop2;
8168     }
8169
8170     U = UTop;
8171     while (!(AUN[1] == U->number)) {
8172         U = U->next;
8173     }
8174     U2 = U;
8175
8176
8177     ATTACK *aTop = U->CL.A;
8178     ATTACK *u2A;
8179
8180     if(U->C.A)
8181         crCAL1 = crCAL;
8182
8183     for(int i = 0;i < crCAL1;i++){
8184         U->CL.A = U->CL.A->next;
8185     }
8186
8187     if(battleSet1Flag){
8188
8189         U->CL.A = aTop;
8190         for (int i = 0;i < crCAL1;i++) {
8191             U->CL.A = U->CL.A->next;
8192         }
8193
8194     }
8195
8196     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8197     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8198     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8199     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8200     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8201     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8202     double oops = U->CL.S_C.HP/U->CL.S_M.HP*100;
8203     [combatLHP1 setIntValue:(int)oops];
8204     oops = U->CL.S_C.EN/U->CL.S_M.EN*100;
8205     [combatLMP1 setIntValue:(int)oops];
8206
8207     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8208     hitFix = U->CL.A->hitPercent;
8209
8210     u2A = U->CL.A;
8211     U->CL.A = aTop;
8212
8213     if(battleDef1Flag){
8214         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8215         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8216         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8217         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8218         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8219         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8220         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8221     }
8222     if(battleDod1Flag){
8223         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8224         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8225         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8226         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8227         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8228         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8229         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8230
8231     }
8232
8233
8234
8235
8236
8237     U = UTop;
8238     while (!(AUN[1] == U->number)) {
8239         U = U->next;
8240     }
8241     U2 = U;
8242
8243     U = UTop;
8244     while (!(DUN[1] == U->number)) {
8245         U = U->next;
8246     }
8247
8248     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8249
8250     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8251     if(hi < 0) hi = 0;
8252
8253     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8254     if(battleDod2Flag) hit = hit / 2;
8255     hit = floor(hit);
8256
8257     if(hit > 100) hit = 100;
8258     if(hit < 0) hit = 0;
8259
8260     if(u2A->D->sort == 1){
8261         hit = 100;
8262     }
8263     if([self sortEcheck:u2A opponent:U])
8264         hit = 0;
8265     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8266     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8267
8268
8269
8270     int mostDmg = 0;
8271     int mostHit = 0;
8272     int mostNum = 0;
8273     int num = 0;
8274     ATTACK *aTop2 = U->C.A;
8275     int mpCost = 0;
8276     while(U->C.A){
8277
8278         costVIG = U->C.A->vigor;
8279
8280         mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8281         if(U->C.A->D)
8282         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]){
8283             mostDmg = U->C.A->totalD;
8284             mostNum = num;
8285         }
8286         if(U->C.A->D)
8287         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]){
8288             //mostDmg = U->C.A->totalD;
8289             mostHit = U->C.A->hitPercent;
8290             mostNum = num;
8291         }
8292         U->C.A = U->C.A->next;
8293         num++;
8294     }
8295
8296     U->C.A = aTop2;
8297
8298     mostNumSub = mostNum;
8299
8300     for(int i = 0;i < mostNum;i++){
8301         U->C.A = U->C.A->next;
8302     }
8303     mpCost = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8304     costVIG = U->C.A->vigor;
8305
8306     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){
8307
8308     }else while(U->C.A){
8309         U->C.A = U->C.A->next;
8310     }
8311
8312
8313     if(battleSet2Flag){
8314
8315         U->C.A = aTop2;
8316
8317         for (int i = 0;i < crCAL2;i++) {
8318             U->C.A = U->C.A->next;
8319         }
8320
8321     }
8322
8323
8324     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8325     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8326     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8327     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8328     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8329     double oops2 = U->C.S_C.HP/U->C.S_M.HP*100;
8330     [combatLHP2 setIntValue:(int)oops2];
8331     oops2 = U->C.S_C.MP/U->C.S_M.MP*100;
8332     [combatLMP2 setIntValue:(int)oops2];
8333
8334     bool counter;
8335     int mpCost2 = 0;
8336     if(U->C.A){
8337         mpCost2 = U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5;
8338         costVIG = U->C.A->vigor;
8339
8340     }
8341     if(U->C.A &&U->C.A->D){
8342     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]){
8343         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8344         hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8345         hitFix = U->C.A->hitPercent;
8346         counter = true;
8347     }else if(u2A->D->sort == 1 || !U->C.A || U->C.A->D->sort == 1 || [self sortEcheck:U->C.A opponent:U2]){
8348         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8349     }}else{
8350         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8351     }
8352     U2A = U->C.A;
8353     U->C.A = aTop2;
8354
8355     if(battleDef2Flag){
8356         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8357         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8358         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8359         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8360         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8361         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8362         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8363     }
8364
8365     if(battleDod2Flag){
8366         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8367         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8368         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8369         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8370         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8371         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8372         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8373
8374     }
8375     U = UTop;
8376     while (!(AUN[1] == U->number)) {
8377         U = U->next;
8378     }
8379
8380     if(counter){
8381         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;
8382         if(battleDod1Flag) hit /= 2;
8383         hit = floor(hit);
8384
8385         if(hit > 100) hit = 100;
8386         if(hit < 0) hit = 0;
8387         if([self sortEcheck:U2A opponent:U])
8388             hit = 0;
8389         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8390         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8391
8392     }else{
8393         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8394     }
8395
8396     U = UTop;
8397     while (!(AUN[1] == U->number)) {
8398         U = U->next;
8399     }
8400
8401     if(U->CPU){
8402         [battleAttackBtn1 setEnabled:NO];
8403         [battleAttackBtn1 setTransparent:YES];
8404         [battleGuardBtn1 setEnabled:NO];
8405         [battleGuardBtn1 setTransparent:YES];
8406         [battleDodgeBtn1 setEnabled:NO];
8407         [battleDodgeBtn1 setTransparent:YES];
8408     }else{
8409         [battleAttackBtn1 setEnabled:YES];
8410         [battleAttackBtn1 setTransparent:NO];
8411         [battleGuardBtn1 setEnabled:YES];
8412         [battleGuardBtn1 setTransparent:NO];
8413         [battleDodgeBtn1 setEnabled:YES];
8414         [battleDodgeBtn1 setTransparent:NO];
8415     }U = UTop;
8416
8417     U = UTop;
8418     while (!(DUN[1] == U->number)) {
8419         U = U->next;
8420     }
8421     if(U->CPU){
8422         [battleAttackBtn2 setEnabled:NO];
8423         [battleAttackBtn2 setTransparent:YES];
8424         [battleGuardBtn2 setEnabled:NO];
8425         [battleGuardBtn2 setTransparent:YES];
8426         [battleDodgeBtn2 setEnabled:NO];
8427         [battleDodgeBtn2 setTransparent:YES];
8428     }else{
8429         [battleAttackBtn2 setEnabled:YES];
8430         [battleAttackBtn2 setTransparent:NO];
8431         [battleGuardBtn2 setEnabled:YES];
8432         [battleGuardBtn2 setTransparent:NO];
8433         [battleDodgeBtn2 setEnabled:YES];
8434         [battleDodgeBtn2 setTransparent:NO];
8435     }U = UTop;
8436
8437
8438     U = UTop;
8439
8440     for (int i = 1; i < DUN[1]; i++) {
8441         U = U->next;
8442     }
8443
8444     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8445        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8446        ){
8447         /*
8448         [battleStartBtn setEnabled:NO];
8449         [battleStartBtn setTransparent:YES];
8450          */
8451     }else{
8452         [battleStartBtn setEnabled:YES];
8453         [battleStartBtn setTransparent:NO];
8454     }
8455
8456     U = UTop;
8457
8458     avPlayerFlag1 = false;
8459     avPlayerFlag2 = false;
8460 }
8461
8462 -(void)setBattlePanelT4{
8463
8464     U = UTop;
8465
8466     while (!(AUN[1] == U->number)) {
8467         U = U->next;
8468     }
8469
8470     if(cpuModeBATTLEflag && (MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2)){
8471         cpuModeBATTLEflag = false;
8472     int mostDmg = 0;
8473     int mostHit = 0;
8474     int mostNum = 0;
8475     int num = 0;
8476     ATTACK *aTop2 = U->CL.A;
8477     int mpCost = 0;
8478     while(U->CL.A){
8479         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8480         costVIG = U->C.A->vigor;
8481         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]){
8482             mostDmg = U->CL.A->totalD;
8483             mostNum = num;
8484         }
8485         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]){
8486             //mostDmg = U->C.A->totalD;
8487             mostHit = U->CL.A->hitPercent;
8488             mostNum = num;
8489         }
8490         U->CL.A = U->CL.A->next;
8491         num++;
8492     }
8493
8494
8495     mostNumSub = mostNum;
8496         U->CL.A = aTop2;
8497
8498         for(int i = 0;i < mostNum;i++){
8499             U->CL.A = U->CL.A->next;
8500         }
8501         if(U->CL.A->extent == 0){
8502
8503             U->CL.A = aTop2;
8504             crCAL1 = 0;
8505             for(int i = 0;i < mostNum;i++){
8506                 U->CL.A = U->CL.A->next;
8507                 crCAL1++;
8508             }
8509         }
8510         else{
8511             U->CL.A = aTop2;
8512             for(int i = 0;i < crCAL1;i++){
8513                 U->CL.A = U->CL.A->next;
8514             }
8515         }
8516     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8517         costVIG = U->C.A->vigor;
8518     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){
8519
8520     }else while(U->CL.A){
8521         U->CL.A = U->CL.A->next;
8522         crCAL1++;
8523     }
8524       U->CL.A = aTop2;
8525     }
8526     U = UTop;
8527
8528     while (!(AUN[1] == U->number)) {
8529         U = U->next;
8530     }
8531     U2 = U;
8532
8533     ATTACK *aTop = U->C.A;
8534     ATTACK *u2A;
8535
8536     if(U->C.A)
8537         crCAL1 = crCAL;
8538
8539     for(int i = 0;i < crCAL1;i++){
8540         U->C.A = U->C.A->next;
8541     }
8542
8543     if(battleSet1Flag){
8544
8545         U->C.A = aTop;
8546         for (int i = 0;i < crCAL1;i++) {
8547             U->C.A = U->C.A->next;
8548         }
8549
8550     }
8551
8552     [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8553     [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8554     [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8555     [combatATK1 setStringValue:[NSString stringWithFormat:@"%@", U->C.A->name]];
8556     [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8557     [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8558     double oops = U->C.S_C.HP/U->C.S_M.HP*100;
8559     [combatLHP1 setIntValue:(int)oops];
8560     oops = U->C.S_C.MP/U->C.S_M.MP*100;
8561     [combatLMP1 setIntValue:(int)oops];
8562
8563     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
8564     hitFix = U->C.A->hitPercent;
8565
8566     u2A = U->C.A;
8567     U->C.A = aTop;
8568
8569     if(battleDef1Flag){
8570         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8571         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8572         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8573         [combatATK1 setStringValue:[NSString stringWithFormat:@"防御耐性"]];
8574         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8575         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8576         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8577     }
8578     if(battleDod1Flag){
8579         [combatNAME1 setStringValue:[NSString stringWithFormat:@"%@", U->C.name]];
8580         [combatHP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.HP, U->C.S_M.HP]];
8581         [combatMP1 setStringValue:[NSString stringWithFormat:@"%g/%g", U->C.S_C.MP, U->C.S_M.MP]];
8582         [combatATK1 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8583         [combatVIG1 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8584         [combatAP1 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8585         [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8586
8587     }
8588
8589
8590
8591
8592
8593
8594
8595     U = UTop;
8596     while (!(DUN[1] == U->number)) {
8597         U = U->next;
8598     }
8599
8600     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;
8601     if(battleDod2Flag) hit = hit / 2;
8602     hit = floor(hit);
8603
8604     if(hit > 100) hit = 100;
8605     if(hit < 0) hit = 0;
8606
8607     if(u2A->D->sort == 1){
8608         hit = 100;
8609     }
8610     if([self sortEcheck:u2A opponent:U])
8611         hit = 0;
8612     [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8613     if(battleDef1Flag || battleDod1Flag) [combatHIT1 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8614
8615
8616
8617     int mostDmg = 0;
8618     int mostHit = 0;
8619     int mostNum = 0;
8620     int num = 0;
8621     ATTACK *aTop2 = U->CL.A;
8622     int mpCost = 0;
8623     while(U->CL.A){
8624         mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8625         costVIG = U->C.A->vigor;
8626         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]){
8627             mostDmg = U->CL.A->totalD;
8628             mostNum = num;
8629         }
8630         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]){
8631             //mostDmg = U->C.A->totalD;
8632             mostHit = U->CL.A->hitPercent;
8633             mostNum = num;
8634         }
8635         U->CL.A = U->CL.A->next;
8636         num++;
8637     }
8638
8639     mostNumSub = mostNum;
8640
8641     U->CL.A = aTop2;
8642
8643     for(int i = 0;i < mostNum;i++){
8644         U->CL.A = U->CL.A->next;
8645     }
8646     mpCost = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8647     costVIG = U->C.A->vigor;
8648     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){
8649
8650     }else while(U->CL.A){
8651         U->CL.A = U->CL.A->next;
8652     }
8653
8654
8655     if(battleSet2Flag){
8656
8657         U->CL.A = aTop2;
8658
8659         for (int i = 0;i < crCAL2;i++) {
8660             U->CL.A = U->CL.A->next;
8661         }
8662
8663     }
8664
8665
8666     [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8667     [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8668     [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8669     [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8670     [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8671     double oops2 = U->CL.S_C.HP/U->CL.S_M.HP*100;
8672     [combatLHP2 setIntValue:(int)oops2];
8673     oops2 = U->CL.S_C.EN/U->CL.S_M.EN*100;
8674     [combatLMP2 setIntValue:(int)oops2];
8675
8676     bool counter;
8677     int mpCost2 = 0;
8678     if(U->CL.A){
8679         mpCost2 = U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5;
8680
8681     }
8682     if(U->CL.A && U->CL.A->D){
8683     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]){
8684         [combatATK2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.A->name]];
8685         hit = U->CL.S_C.MOB + U->C.S_C.HIT;
8686         hitFix = U->CL.A->hitPercent;
8687         counter = true;
8688     }else if(u2A->D->sort == 1 || !U->CL.A || U->CL.A->D->sort == 1 || [self sortEcheck:U->CL.A opponent:U2]){
8689         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8690     }}else{
8691         [combatATK2 setStringValue:[NSString stringWithFormat:@"反撃不可能"]];
8692     }
8693     U2A = U->CL.A;
8694     U->CL.A = aTop2;
8695
8696     if(battleDef2Flag){
8697         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8698         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8699         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8700         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8701         [combatATK2 setStringValue:[NSString stringWithFormat:@"防御態勢"]];
8702         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8703         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8704     }
8705
8706     if(battleDod2Flag){
8707         [combatNAME2 setStringValue:[NSString stringWithFormat:@"%@", U->CL.name]];
8708         [combatHP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
8709         [combatMP2 setStringValue:[NSString stringWithFormat:@"%g/%g", U->CL.S_C.EN, U->CL.S_M.EN]];
8710         [combatVIG2 setStringValue:[NSString stringWithFormat:@"気力　%d", U->C.S_C.vigor]];
8711         [combatATK2 setStringValue:[NSString stringWithFormat:@"回避耐性"]];
8712         [combatAP2 setStringValue:[NSString stringWithFormat:@"%g", U->C.S_C.AP]];
8713         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8714
8715     }
8716
8717     U = UTop;
8718     while (!(DUN[1] == U->number)) {
8719         U = U->next;
8720     }
8721     U2 = U;
8722
8723     U = UTop;
8724     while (!(AUN[1] == U->number)) {
8725         U = U->next;
8726     }
8727
8728     if(counter){
8729
8730         double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
8731
8732         double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
8733         if(hi < 0) hi = 0;
8734
8735         hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
8736         if(battleDod1Flag) hit /= 2;
8737         hit = floor(hit);
8738
8739         if(hit > 100) hit = 100;
8740         if(hit < 0) hit = 0;
8741         if([self sortEcheck:U2A opponent:U])
8742             hit = 0;
8743         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　%g", hit]];
8744         if(battleDef2Flag || battleDod2Flag) [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8745
8746     }else{
8747         [combatHIT2 setStringValue:[NSString stringWithFormat:@"命中率　----"]];
8748     }
8749
8750     U = UTop;
8751     while (!(AUN[1] == U->number)) {
8752         U = U->next;
8753     }
8754
8755     if(U->CPU){
8756         [battleAttackBtn1 setEnabled:NO];
8757         [battleAttackBtn1 setTransparent:YES];
8758         [battleGuardBtn1 setEnabled:NO];
8759         [battleGuardBtn1 setTransparent:YES];
8760         [battleDodgeBtn1 setEnabled:NO];
8761         [battleDodgeBtn1 setTransparent:YES];
8762     }else{
8763         [battleAttackBtn1 setEnabled:YES];
8764         [battleAttackBtn1 setTransparent:NO];
8765         [battleGuardBtn1 setEnabled:YES];
8766         [battleGuardBtn1 setTransparent:NO];
8767         [battleDodgeBtn1 setEnabled:YES];
8768         [battleDodgeBtn1 setTransparent:NO];
8769     }U = UTop;
8770
8771     U = UTop;
8772     while (!(DUN[1] == U->number)) {
8773         U = U->next;
8774     }
8775     if(U->CPU){
8776         [battleAttackBtn2 setEnabled:NO];
8777         [battleAttackBtn2 setTransparent:YES];
8778         [battleGuardBtn2 setEnabled:NO];
8779         [battleGuardBtn2 setTransparent:YES];
8780         [battleDodgeBtn2 setEnabled:NO];
8781         [battleDodgeBtn2 setTransparent:YES];
8782     }else{
8783         [battleAttackBtn2 setEnabled:YES];
8784         [battleAttackBtn2 setTransparent:NO];
8785         [battleGuardBtn2 setEnabled:YES];
8786         [battleGuardBtn2 setTransparent:NO];
8787         [battleDodgeBtn2 setEnabled:YES];
8788         [battleDodgeBtn2 setTransparent:NO];
8789     }U = UTop;
8790
8791
8792     U = UTop;
8793
8794     for (int i = 1; i < DUN[1]; i++) {
8795         U = U->next;
8796     }
8797
8798     if((MF[MFselectedRow+1].MS.playerSet1 == 2 && MF[MFselectedRow+1].MS.playerSet2 == 2) ||
8799        unitBreak->team == 1 || (unitBreak->team == 2 && U->team == 1)
8800        ){
8801         /*
8802         [battleStartBtn setEnabled:NO];
8803         [battleStartBtn setTransparent:YES];
8804          */
8805     }else{
8806         [battleStartBtn setEnabled:YES];
8807         [battleStartBtn setTransparent:NO];
8808     }
8809
8810     U = UTop;
8811
8812     avPlayerFlag1 = false;
8813     avPlayerFlag2 = false;
8814 }
8815
8816 -(void)DisplayMessage{
8817
8818     battleFlag = true;
8819     attackExtentFlag = false;
8820     attackingWait = false;
8821
8822     if(!battleSetUp) return;
8823     if(!fuckingLoadBugFix) return;
8824
8825     if(!battleVeryBegunFlag){
8826     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8827     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8828     [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 ----"]];
8829     [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 ----"]];
8830     }
8831     battleVeryBegunFlag = true;
8832     pussyLoopFlag = true;
8833     if(AVpreview){
8834     if(AVpreview.rate > 0){
8835         //[battleWindow setIgnoresMouseEvents:YES];
8836         [battleWindow makeKeyAndOrderFront:nil];
8837         //NSLog(@"%g", AVpreview.rate);
8838         return;
8839     }else{
8840         //[battleWindow setIgnoresMouseEvents:NO];
8841         //NSLog(@"%g", AVpreview.rate);
8842         AVpreview = NULL;
8843         if(avPlayerFlag1){
8844
8845             [AVPV setHidden:YES];
8846         }
8847         else if(avPlayerFlag2){
8848             [AVPV setHidden:YES];
8849         }
8850     }
8851     }
8852     if(animationFlag3){
8853         if(animationFlag1){
8854             animationFlag1 = false;
8855             U = effCun;
8856             U->C.A = attackTop;
8857         }
8858         if(animationFlag2){
8859             animationFlag2 = false;
8860             U = effCun;
8861             U->C.A = attackTop2;
8862         }
8863         U = UTop;
8864     }else{
8865         if(animationFlag1 || animationFlag2){
8866             return;
8867         }
8868     }
8869
8870     double def2 = (double)31/32;
8871     NSString *message = @"";
8872
8873     enum{
8874         RIKU,
8875         UMI,
8876         CHU,
8877         SORA
8878     };
8879
8880     enum{
8881         A,
8882         B,
8883         C,
8884         D,
8885         E,
8886         S,
8887         SS
8888     };
8889     static bool extentbool = false;
8890     static bool extentbool2 = false;
8891
8892
8893     if(cpuAtkExtendFlag){
8894         extentBattleFlag2 = true;
8895     }
8896
8897     if(!extentbool && extentBattleFlag2){
8898         extentbool = true;
8899         extentMPcostFlag = false;
8900         DUNnum = 1;
8901     }
8902
8903     assholeLoadBugFix = true;
8904
8905     switch (messageProcess) {
8906         case 0:
8907             if(bLoopFlag) break;
8908
8909             DUNnum = 1;
8910
8911             U = UTop;
8912             while (!(DUN[DUNnum] == U->number)) {
8913                 U = U->next;
8914
8915             }
8916             U2 = U;
8917             U = UTop;
8918             while (!(AUN[1] == U->number)) {
8919                 U = U->next;
8920             }
8921
8922             if(U->number == U2->number){
8923                 btSelfAction = true;
8924             }else{
8925                 btSelfAction = false;
8926             }
8927
8928             U = UTop;
8929             U2 = UTop;
8930
8931             [battleDialog setStringValue:@"攻撃開始！"];
8932             if(!baseDistanceCompFlag)
8933                 break;
8934             bLoopFlag = true;
8935             messageProcess++;
8936             DUNnum = 1;
8937             battleIsProcFlag = true;
8938
8939             break;
8940         case 1:
8941
8942             if(bLoopFlag) break;
8943
8944
8945             if(DUNnum > 1){
8946
8947
8948                 btHitExtendFlag1 = true;
8949
8950                 if(btHitExtendProc1 >= 3){
8951                     btHitExtendProc1 = 0;
8952                 }
8953             }
8954
8955                 BTunitAttackFlag1 = true;
8956             if(battleDef1Flag || battleDod1Flag)
8957                 BTunitAttackFlag1 = false;
8958
8959             U = UTop;
8960             while (!(DUN[DUNnum] == U->number)) {
8961                 U = U->next;
8962
8963             }
8964             U2 = U;
8965             U = UTop;
8966             while (!(AUN[1] == U->number)) {
8967                 U = U->next;
8968             }
8969
8970
8971             if(U->number == U2->number){
8972                 btSelfAction = true;
8973             }else{
8974                 btSelfAction = false;
8975             }
8976
8977             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
8978                 U = UTop;
8979                 [self DisplayMessageMod1A];
8980                 return;
8981             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
8982                 U = UTop;
8983                 [self DisplayMessageMod2A];
8984                 return;
8985             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
8986                 U = UTop;
8987                 [self DisplayMessageMod3A];
8988                 return;
8989             }
8990
8991
8992             U = UTop;
8993             if(bLoopFlag) break;
8994
8995             U = UTop;
8996             while (!(AUN[1] == U->number)) {
8997                 U = U->next;
8998             }
8999             ATTACK *aTop = U->C.A;
9000             attackTop = aTop;
9001             for(int i = 0;i < crCAL1;i++){
9002                 U->C.A = U->C.A->next;
9003             }
9004             effCun = U;
9005             attackCR = U->C.A;
9006
9007             if(attackCR->magic){
9008                 btAttackType1 = BT_TYPE_MAGIC;
9009             }else{
9010                 btAttackType1 = BT_TYPE_NORMAL;
9011             }
9012
9013             if(BTunitAttackFlag1)
9014             if((btAttackType1 == BT_TYPE_NORMAL && btAttackMoveValue1 < 2)
9015                || (btAttackType1 == BT_TYPE_MAGIC && btAttackMoveValue1 < 5)
9016                || (btAttackType1 == BT_TYPE_ABILITY && btAttackMoveValue1 < 2)){
9017
9018                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9019
9020                 [battleDialog setStringValue:message];
9021                 U->C.A = aTop;
9022                 U = UTop;
9023
9024                 return;
9025             }
9026
9027             if(btHitExtendFlag1 && btHitExtendProc1 < 2){
9028
9029
9030
9031
9032                 U->C.A = aTop;
9033                 U = UTop;
9034
9035                 return;
9036             }
9037
9038             if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9039
9040
9041             [bplayer2 setImage:U2->C.imgb];
9042             [bplayer2 setImageScaling:NSScaleToFit];
9043             [nplayer2 setStringValue:U2->C.name];
9044             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->C.S_C.HP, U2->C.S_M.HP]];
9045             [lplayer2 setIntValue:U2->C.S_C.HP/U2->C.S_M.HP*100];
9046             [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
9047             [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
9048             [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
9049
9050             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){
9051                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
9052
9053                 NSString *path = @"data/AttackList/ALdata";
9054
9055                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
9056
9057                 path = [path stringByAppendingFormat:@"/"];
9058
9059                 path = [path stringByAppendingString:U->C.A->AN.movName];
9060
9061                 NSData *AVData = [NSData dataWithContentsOfFile:path];
9062
9063                 if(AVData)
9064                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9065
9066
9067                 if(!AVpreview){
9068
9069                     NSString *path = @"data/AttackList3/IALdata";
9070
9071                     path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
9072
9073                     path = [path stringByAppendingFormat:@"/"];
9074
9075                     path = [path stringByAppendingString:U->C.A->AN.movName];
9076
9077
9078                     NSData *AVData = [NSData dataWithContentsOfFile:path];
9079
9080                     if(AVData)
9081                     AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9082
9083
9084                 }
9085
9086                 if(AVpreview) {
9087                     AVPV.player = [AVpreview retain];
9088                 }else{
9089                     goto avAWESOME;
9090                 }
9091
9092
9093                 [AVPV setHidden:NO];
9094                 [AVpreview play];
9095                 [battleDialog setStringValue:message];
9096
9097                 avPlayerFlag1 = true;
9098
9099
9100                 U->C.A = aTop;
9101                 U = UTop;
9102                 return;
9103             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUNnum == 1){
9104
9105                 [battleDialog setStringValue:message];
9106                 animationFlag1 = true;
9107                 aniFrameCnt = 0;
9108                 return;
9109             }
9110
9111         avAWESOME:{}
9112
9113             double urSupposedToGet;
9114
9115             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9116
9117             double asItIs;
9118             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9119
9120             double oopsIsRight;
9121
9122             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9123             else oopsIsRight = U->C.S_C.MIS;
9124
9125             oopsIsRight = oopsIsRight/100;
9126             double val;
9127             if(!U2->C.aura && U->C.A->D){
9128             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
9129                                             - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9130             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
9131                                             - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9132             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
9133                                             - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9134             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
9135                                             - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9136             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
9137                                             - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9138             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9139             }else if(U->C.A->D){
9140                 val = 1/log(3+U2->C.S_C.MP/64);
9141                 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
9142                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9143                 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
9144                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9145                 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
9146                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9147                 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
9148                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9149                 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
9150                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9151                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9152             }
9153             double val2 = log(3+U2->C.S_C.MP/64);
9154             if(U->C.aura){
9155                 dmg = dmg*val2;
9156             }
9157
9158             if(U->C.A->D){
9159             if(U->C.A->D->fix == 2){
9160                 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;
9161
9162                 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;
9163                 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;
9164                 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;
9165                 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;
9166                 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;
9167
9168
9169             }else if(U->C.A->D->fix == 1){
9170                 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;
9171
9172                 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;
9173                 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;
9174                 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;
9175                 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;
9176                 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;
9177
9178             }else if(U->C.A->D->fix == 0){
9179
9180             }
9181             }
9182             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9183
9184             if(extentMPcostFlag && extentBattleFlag2){
9185
9186             }else{
9187                 U->C.S_C.MP -= costMP;
9188                 extentMPcostFlag = true;
9189             }
9190
9191             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9192             hitFix = U->C.A->hitPercent;
9193
9194             U2A = U->C.A;
9195             U->C.A = aTop;
9196
9197             U = UTop;
9198             while (!(AUN[1] == U->number)) {
9199                 U = U->next;
9200             }
9201             U2 = U;
9202
9203             U = UTop;
9204             while (!(DUN[DUNnum] == U->number)) {
9205                 U = U->next;
9206             }
9207
9208             double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9209
9210             double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9211             if(hi < 0) hi = 0;
9212
9213             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9214             if(hit > 100) hit = 100;
9215             if(hit < 0) hit = 0;
9216             if(U2A->D->sort == 1){
9217                 hit = 100;
9218             }
9219             if([self sortEcheck:U2A opponent:U])
9220                 hit = 0;
9221
9222             healFlag = false;
9223
9224             int wtf = 100;
9225             if(battleDod2Flag) wtf = 50;
9226             if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
9227
9228                 if(U2A->D->sort == 0){
9229                     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);
9230                     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);
9231                     NSLog(@"修正前のダメージ:%g", dmg);
9232                     dmg = [self dmgResist:dmg];
9233                     NSLog(@"属性後のダメージ:%g", dmg);
9234                     def2 = pow(def2, U->C.S_C.DEF);
9235                     int omfg = rand()%100;
9236                     NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9237                     dmg = (dmg*omfg/100/10 + dmg);
9238                     NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9239                     if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9240                     else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9241
9242                     if(U->C.S_C.typeMOVE == RIKU){
9243                         if(U2A->riku == A) dmg = dmg*1.2;
9244                         if(U2A->riku == B) dmg = dmg*1.0;
9245                         if(U2A->riku == C) dmg = dmg*0.6;
9246                         if(U2A->riku == D) dmg = dmg*0.2;
9247                         if(U2A->riku == E) dmg = 0;
9248                         if(U2A->riku == S) dmg = dmg*1.5;
9249                         if(U2A->riku == SS) dmg = dmg*2.0;
9250                     } if(U->C.S_C.typeMOVE == UMI &&
9251                        (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9252                         if(U2A->umi == A) dmg = dmg*1.2;
9253                         if(U2A->umi == B) dmg = dmg*1.0;
9254                         if(U2A->umi == C) dmg = dmg*0.6;
9255                         if(U2A->umi == D) dmg = dmg*0.2;
9256                         if(U2A->umi == E) dmg = 0;
9257                         if(U2A->umi == S) dmg = dmg*1.5;
9258                         if(U2A->umi == SS) dmg = dmg*2.0;
9259                     }else if(U->C.S_C.typeMOVE == UMI){
9260                         if(U2A->riku == A) dmg = dmg*1.2;
9261                         if(U2A->riku == B) dmg = dmg*1.0;
9262                         if(U2A->riku == C) dmg = dmg*0.6;
9263                         if(U2A->riku == D) dmg = dmg*0.2;
9264                         if(U2A->riku == E) dmg = 0;
9265                         if(U2A->riku == S) dmg = dmg*1.5;
9266                         if(U2A->riku == SS) dmg = dmg*2.0;
9267
9268                     } if(U->C.S_C.typeMOVE == CHU){
9269                         if(U2A->chu == A) dmg = dmg*1.2;
9270                         if(U2A->chu == B) dmg = dmg*1.0;
9271                         if(U2A->chu == C) dmg = dmg*0.6;
9272                         if(U2A->chu == D) dmg = dmg*0.2;
9273                         if(U2A->chu == E) dmg = 0;
9274                         if(U2A->chu == S) dmg = dmg*1.5;
9275                         if(U2A->chu == SS) dmg = dmg*2.0;
9276                     } if(U->C.S_C.typeMOVE == SORA){
9277                         if(U2A->sora == A) dmg = dmg*1.2;
9278                         if(U2A->sora == B) dmg = dmg*1.0;
9279                         if(U2A->sora == C) dmg = dmg*0.6;
9280                         if(U2A->sora == D) dmg = dmg*0.2;
9281                         if(U2A->sora == E) dmg = 0;
9282                         if(U2A->sora == S) dmg = dmg*1.5;
9283                         if(U2A->sora == SS) dmg = dmg*2.0;
9284                     }
9285
9286                     NSLog(@"ユニットの地形適用後:%g", dmg);
9287                     if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
9288                     graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9289
9290                     grazeFlag = false;
9291                     omfg = rand()%100;
9292                     if(graze > omfg && !healFlag) {dmg = dmg/5;
9293                         grazeFlag = true;
9294                     }
9295                     if(battleDef2Flag) dmg -= dmg*0.5;
9296                     battleDef2Flag = false;
9297                     dmg = floor(dmg);
9298                     if(dmg < 0) dmg = 0;
9299                     U->C.S_C.HP -= dmg;
9300                     U->C.S_C.vigor++;
9301
9302                     [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9303                     [btDMGtf1 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9304
9305
9306
9307                 }else if(U2A->D->sort == 1){
9308                     dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
9309                     dmg = floor(dmg);
9310
9311                     U->C.S_C.HP += dmg;
9312                     if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
9313                     healFlag = true;
9314                 }
9315
9316                 while(1){
9317                     if(U->C.S_C.HP <= 0) {
9318                         U->C.S_C.HP = 0;
9319                         U2->C.S_C.vigor += 5;
9320
9321                         messageProcess = 2;
9322                         if(U->dead) break;
9323                         U->dead = true;
9324
9325
9326                         if(U->targType1L)
9327                             targType1cnt[0]--;
9328                         if(U->targType2L) {
9329                             targType2cnt[0]--;
9330                             targType2Lflag = true;
9331                         }
9332
9333                         if(U->targType1D)
9334                             targType1cnt[1]--;
9335                         if(U->targType2D) {
9336                             targType2cnt[1]--;
9337                             targType2Dflag = true;
9338                         }
9339
9340                         break;
9341                     }
9342                     break;
9343                 }
9344
9345             [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9346             [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9347
9348                 if(![U2A->msg isEqualToString:@""]){
9349
9350                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9351                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9352
9353                 }
9354
9355             if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9356             if(!healFlag) {
9357                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9358                 btHitFlag1 = true;
9359                 }
9360             else {
9361                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
9362                 btHitFlag1 = false;
9363             }
9364             }else if(battleDef1Flag){
9365
9366
9367                 U = UTop;
9368                 while (!(AUN[1] == U->number)) {
9369                     U = U->next;
9370                 }
9371
9372
9373                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9374
9375                 btHitFlag1 = false;
9376
9377             }else if(battleDod1Flag){
9378
9379                 U = UTop;
9380                 while (!(AUN[1] == U->number)) {
9381                     U = U->next;
9382                 }
9383
9384                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9385
9386                 btHitFlag1 = false;
9387             }else{
9388
9389                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9390                 btHitFlag1 = false;
9391
9392             }
9393                 [battleDialog setStringValue:message];
9394
9395             [btHITtf1 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9396
9397             U = UTop;
9398
9399             bLoopFlag = true;
9400
9401             if(!extentBattleFlag2){
9402             if(healFlag) {
9403                 messageProcess++;
9404                  };
9405             messageProcess++;
9406             }else if(extentBattleFlag2){
9407                 if(btHitExtendProc1 == 2)
9408                     btHitExtendProc1 = 3;
9409                 if(btHitExtendProc1 >= 2)
9410                     btHitExtendFix1 = 1;
9411
9412                 btHitFlagCnt1 = 0;
9413                 DUNnum++;
9414                 messageProcess = 1;
9415                 if(DUN[DUNnum] <= 0){
9416                     messageProcess++;
9417                     messageProcess++;
9418                     extentBattleFlag2 = false;
9419                     extentbool = false;
9420                     extentMPcostFlag = false;
9421                 }
9422             }
9423             message = @"";
9424             avPlayerFlag1 = false;
9425             animationFlag3 = false;
9426             btAtattckMoveEnd = false;
9427             oopsCnt = 30;
9428             break;
9429
9430         case 2:
9431
9432             if(bLoopFlag) break;
9433             BTunitAttackFlag1 = false;
9434             BTunitAttackFlag2 = true;
9435             if(battleDef2Flag || battleDod2Flag)
9436                 BTunitAttackFlag2 = false;
9437             btHitFlag1 = false;
9438
9439
9440             U = UTop;
9441             while (!(DUN[1] == U->number)) {
9442                 U = U->next;
9443             }
9444             U2 = U;
9445             U = UTop;
9446             while (!(AUN[1] == U->number)) {
9447                 U = U->next;
9448             }
9449
9450
9451             if(U->number == U2->number){
9452                 btSelfAction = true;
9453             }else{
9454                 btSelfAction = false;
9455             }
9456
9457             if(U->chipNumberL >= 0 && U2->chipNumberL >= 0){
9458                 U = UTop;
9459                 [self DisplayMessageMod1B];
9460                 return;
9461             }else if(U->chipNumberL >= 0 && U2->chipNumberL < 0){
9462                 U = UTop;
9463                 [self DisplayMessageMod2B];
9464                 return;
9465             }else if(U->chipNumberL < 0 && U2->chipNumberL >= 0){
9466                 U = UTop;
9467                 [self DisplayMessageMod3B];
9468                 return;
9469             }
9470             U = UTop;
9471
9472             if(bLoopFlag) break;
9473
9474             U = UTop;
9475             while (!(AUN[1] == U->number)) {
9476                 U = U->next;
9477             }
9478             U2 = U;
9479             U = UTop;
9480
9481             U = UTop;
9482             while (!(DUN[1] == U->number)) {
9483                 U = U->next;
9484             }
9485
9486             ATTACK *aTop2 = U->C.A;
9487             attackTop2 = aTop2;
9488             int mostDmg = 0;
9489             int mostDmg2 = 0;
9490             int mostNum = 0;
9491             int num = 0;
9492             int mpCost =0;
9493
9494             if(!U->C.A) goto SKIP3;
9495
9496
9497
9498             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9499
9500             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9501
9502
9503             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9504             else oopsIsRight = U->C.S_C.MIS;
9505
9506             oopsIsRight = oopsIsRight/100;
9507
9508             if(U->C.A) {
9509                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9510             }
9511             while(U->C.A){
9512                 mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9513                 if(!U2->C.aura && U->C.A->D){
9514                     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
9515                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9516                     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
9517                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9518                     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
9519                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9520                     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
9521                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9522                     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
9523                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9524                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD;
9525                 }else if(U->C.A->D){
9526                     val = 1/log(3+U2->C.S_C.MP/64);
9527                     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
9528                                                          - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9529                     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
9530                                                          - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9531                     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
9532                                                          - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9533                     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
9534                                                          - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor)*asItIs*val;
9535                     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
9536                                                          - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9537                     if(U->C.A->D->type == 5) mostDmg2 = U->C.A->totalD*val;
9538                 }
9539                 double val2 = log(3+U2->C.S_C.MP/64);
9540                 if(U->C.aura){
9541                     mostDmg2 = mostDmg2*val2;
9542                 }
9543                 if(U->C.A->D){
9544                     if(U->C.A->D->fix == 2){
9545                         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;
9546
9547                         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;
9548                         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;
9549                         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;
9550                         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;
9551                         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;
9552
9553
9554                     }else if(U->C.A->D->fix == 1){
9555                         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;
9556
9557                         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;
9558                         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;
9559                         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;
9560                         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;
9561                         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;
9562
9563                     }else if(U->C.A->D->fix == 0){
9564
9565                     }
9566                 }
9567
9568                 U2A = U->C.A;
9569                 UNIT *oops = U;
9570                 U = U2;
9571                 mostDmg2 = [self dmgResist:mostDmg2];
9572                 U = oops;
9573
9574                 costVIG = U->C.A->vigor;
9575                 if(U->C.A->D)
9576                 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]){
9577
9578
9579                     mostDmg = mostDmg2;
9580
9581
9582                     //mostDmg = U->C.A->totalD;
9583                     mostNum = num;
9584                 }
9585                 U->C.A = U->C.A->next;
9586                 num++;
9587             }
9588
9589             U->C.A = aTop2;
9590
9591             if(!battleSet2PushedFlag){
9592                 for(int i = 0;i < mostNumSub;i++){
9593                 U->C.A = U->C.A->next;
9594             }
9595
9596             }else{
9597             for(int i = 0;i < crCAL2;i++){
9598                 U->C.A = U->C.A->next;
9599             }
9600
9601
9602             }
9603             if(U->C.A->D){
9604             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]){
9605
9606             }else while(U->C.A){
9607                 U->C.A = U->C.A->next;
9608             }}
9609
9610             if(!U->C.A){
9611                 U->C.A = aTop2;
9612                 U = UTop;
9613                 BTunitAttackFlag2 = false;
9614                 message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
9615                 goto SKIP1;
9616             }
9617             effCun = U;
9618             attackCR2 = U->C.A;
9619
9620             if(attackCR2->magic){
9621                 btAttackType2 = BT_TYPE_MAGIC;
9622             }else{
9623                 btAttackType2 = BT_TYPE_NORMAL;
9624             }
9625
9626             if(BTunitAttackFlag2)
9627                 if((btAttackType2 == BT_TYPE_NORMAL && btAttackMoveValue2 < 2)
9628                    || (btAttackType2 == BT_TYPE_MAGIC && btAttackMoveValue2 < 5)
9629                    || (btAttackType2 == BT_TYPE_ABILITY && btAttackMoveValue2 < 2)){
9630
9631
9632                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9633
9634                 [battleDialog setStringValue:message];
9635                 U->C.A = aTop2;
9636                 U = UTop;
9637
9638                 return;
9639             }
9640
9641             if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
9642
9643             if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
9644                 [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
9645
9646                 NSString *path = @"data/AttackList/ALdata";
9647
9648                 path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
9649
9650                 path = [path stringByAppendingFormat:@"/"];
9651
9652                 path = [path stringByAppendingString:U->C.A->AN.movName];
9653
9654
9655                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
9656
9657                 if(AVpreview) {
9658                     AVPV.player = [AVpreview retain];
9659                 }else{
9660                     goto avAWESOME2;
9661                 }
9662
9663                 [AVPV setControlsStyle:0];
9664                 [AVPV setHidden:NO];
9665                 [AVpreview play];
9666                 [battleDialog setStringValue:message];
9667
9668                 avPlayerFlag2 = true;
9669
9670                 U->C.A = aTop2;
9671                 U = UTop;
9672                 return;
9673             }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
9674
9675
9676                 animationFlag2 = true;
9677                 aniFrameCnt = 0;
9678                 return;
9679             }
9680
9681
9682         avAWESOME2:{}
9683             U2A = U->C.A;
9684
9685             /*
9686             if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
9687             if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
9688             if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
9689             if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
9690             if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
9691             if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9692             */
9693
9694             U->C.A = aTop2;
9695             U = UTop;
9696             while (!(AUN[1] == U->number)) {
9697                 U = U->next;
9698             }
9699             U2 = U;
9700             U = UTop;
9701             while (!(DUN[1] == U->number)) {
9702                 U = U->next;
9703             }
9704             NSString *string = [U2A->name retain];
9705             while (![U->C.A->name isEqualToString:string] && U->C.A) {
9706                 U->C.A = U->C.A->next;
9707             }
9708
9709             if(!U->C.A) U->C.A = aTop2;
9710
9711             if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
9712
9713             if(U2) asItIs = 1/log(3+U2->C.S_C.DEF/64);
9714
9715
9716             if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
9717             else oopsIsRight = U->C.S_C.MIS;
9718
9719             oopsIsRight = oopsIsRight/100;
9720
9721
9722             if(!U2->C.aura && U->C.A->D){
9723                 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
9724                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9725                 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
9726                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9727                 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
9728                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9729                 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
9730                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9731                 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
9732                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs;
9733                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
9734             }else if(U->C.A->D){
9735                 double val = val = 1/log(3+U2->C.S_C.MP/64);
9736                 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
9737                                                 - U2->C.S_C.DEF*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9738                 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
9739                                                 - U2->C.S_C.ATK*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9740                 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
9741                                                 - U2->C.S_C.EVA*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9742                 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
9743                                                 - U2->C.S_C.ACU*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9744                 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
9745                                                 - U2->C.S_C.CAP*U2->C.S_C.HP/U2->C.S_M.HP/2*U2->C.S_C.vigor/100)*asItIs*val;
9746                 if(U->C.A->D->type == 5) dmg = U->C.A->totalD*val;
9747             }
9748             val2 = log(3+U2->C.S_C.MP/64);
9749             if(U->C.aura){
9750                 dmg = dmg*val2;
9751             }
9752             if(U->C.A->D){
9753                 if(U->C.A->D->fix == 2){
9754                     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;
9755
9756                     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;
9757                     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;
9758                     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;
9759                     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;
9760                     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;
9761
9762
9763                 }else if(U->C.A->D->fix == 1){
9764                     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;
9765
9766                     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;
9767                     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;
9768                     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;
9769                     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;
9770                     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;
9771
9772                 }else if(U->C.A->D->fix == 0){
9773
9774                 }
9775             }
9776             costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
9777             U->C.S_C.MP -= costMP;
9778
9779             hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
9780             hitFix = U->C.A->hitPercent;
9781
9782             U2A = U->C.A;
9783
9784             U->C.A = aTop2;
9785
9786             U = UTop;
9787             while (!(DUN[1] == U->number)) {
9788                 U = U->next;
9789             }
9790             U2 = U;
9791
9792             U = UTop;
9793             while (!(AUN[1] == U->number)) {
9794                 U = U->next;
9795             }
9796
9797             hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
9798
9799             hi = U->C.S_C.LUK - U2->C.S_C.LUK;
9800             if(hi < 0) hi = 0;
9801
9802             hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
9803             if(hit > 100) hit = 100;
9804             if(hit < 0) hit = 0;
9805             if([self sortEcheck:U2A opponent:U])
9806                 hit = 0;
9807
9808             battleDod1Flag = false;
9809
9810             U = UTop;
9811             while (!(DUN[1] == U->number)) {
9812                 U = U->next;
9813             }
9814             U2 = U;
9815
9816             U = UTop;
9817             while (!(AUN[1] == U->number)) {
9818                 U = U->next;
9819             }
9820
9821             int omg = 100;
9822             if(battleDod1Flag) omg = 50;
9823
9824             if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
9825                 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);
9826                 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);
9827                 NSLog(@"修正前のダメージ:%g", dmg);
9828                 dmg = [self dmgResist:dmg];
9829                 NSLog(@"属性後のダメージ:%g", dmg);
9830             def2 = pow(def2, U->C.S_C.DEF);
9831             int omfg = rand()%100;
9832                 NSLog(@"ダメージ幅:%g〜%g", floor(dmg), floor(dmg + dmg/10));
9833                 dmg = (dmg*omfg/100/10 + dmg);
9834                 NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
9835                 if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
9836                 else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
9837
9838                 if(U->C.S_C.typeMOVE == RIKU){
9839                     if(U2A->riku == A) dmg = dmg*1.2;
9840                     if(U2A->riku == B) dmg = dmg*1.0;
9841                     if(U2A->riku == C) dmg = dmg*0.6;
9842                     if(U2A->riku == D) dmg = dmg*0.2;
9843                     if(U2A->riku == E) dmg = 0;
9844                     if(U2A->riku == S) dmg = dmg*1.5;
9845                     if(U2A->riku == SS) dmg = dmg*2.0;
9846                 } if(U->C.S_C.typeMOVE == UMI &&
9847                      (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
9848                     if(U2A->umi == A) dmg = dmg*1.2;
9849                     if(U2A->umi == B) dmg = dmg*1.0;
9850                     if(U2A->umi == C) dmg = dmg*0.6;
9851                     if(U2A->umi == D) dmg = dmg*0.2;
9852                     if(U2A->umi == E) dmg = 0;
9853                     if(U2A->umi == S) dmg = dmg*1.5;
9854                     if(U2A->umi == SS) dmg = dmg*2.0;
9855                 }else if(U->C.S_C.typeMOVE == UMI){
9856                     if(U2A->riku == A) dmg = dmg*1.2;
9857                     if(U2A->riku == B) dmg = dmg*1.0;
9858                     if(U2A->riku == C) dmg = dmg*0.6;
9859                     if(U2A->riku == D) dmg = dmg*0.2;
9860                     if(U2A->riku == E) dmg = 0;
9861                     if(U2A->riku == S) dmg = dmg*1.5;
9862                     if(U2A->riku == SS) dmg = dmg*2.0;
9863
9864                 } if(U->C.S_C.typeMOVE == CHU){
9865                     if(U2A->chu == A) dmg = dmg*1.2;
9866                     if(U2A->chu == B) dmg = dmg*1.0;
9867                     if(U2A->chu == C) dmg = dmg*0.6;
9868                     if(U2A->chu == D) dmg = dmg*0.2;
9869                     if(U2A->chu == E) dmg = 0;
9870                     if(U2A->chu == S) dmg = dmg*1.5;
9871                     if(U2A->chu == SS) dmg = dmg*2.0;
9872                 } if(U->C.S_C.typeMOVE == SORA){
9873                     if(U2A->sora == A) dmg = dmg*1.2;
9874                     if(U2A->sora == B) dmg = dmg*1.0;
9875                     if(U2A->sora == C) dmg = dmg*0.6;
9876                     if(U2A->sora == D) dmg = dmg*0.2;
9877                     if(U2A->sora == E) dmg = 0;
9878                     if(U2A->sora == S) dmg = dmg*1.5;
9879                     if(U2A->sora == SS) dmg = dmg*2.0;
9880                 }
9881
9882                 NSLog(@"ユニットの地形適用後:%g", dmg);
9883
9884
9885                 graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
9886
9887                 grazeFlag = false;
9888                 omfg = rand()&100;
9889                 if(graze > omfg && !healFlag) {dmg = dmg/5;
9890                     grazeFlag = true;
9891                 }
9892
9893             if(battleDef1Flag) dmg -= dmg*0.5;
9894             battleDef1Flag = false;
9895                 dmg = floor(dmg);
9896                 if(dmg < 0) dmg = 0;
9897                 U->C.S_C.HP -= dmg;
9898                 U->C.S_C.vigor++;
9899
9900                 [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9901                 [btDMGtf2 setStringValue:[NSString stringWithFormat:@"ダメージ値 %g", dmg]];
9902
9903                 while(1){
9904                 if(U->C.S_C.HP <= 0) {
9905                     U->C.S_C.HP = 0;
9906                     U2->C.S_C.vigor += 5;
9907
9908                     messageProcess = 2;
9909                     if(U->dead) break;
9910                     U->dead = true;
9911
9912
9913                     if(U->targType1L)
9914                         targType1cnt[0]--;
9915                     if(U->targType2L) {
9916                         targType2cnt[0]--;
9917                         targType2Lflag = true;
9918                     }
9919
9920                     if(U->targType1D)
9921                         targType1cnt[1]--;
9922                     if(U->targType2D) {
9923                         targType2cnt[1]--;
9924                         targType2Dflag = true;
9925                     }
9926
9927                     break;
9928                 }
9929                     break;
9930                 }
9931
9932
9933
9934                 [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
9935
9936                 [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
9937
9938                 if(![U2A->msg isEqualToString:@""]){
9939                     message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
9940                                                                 [self originalMessage:U2A->msg subj:U2->C.name obje:U->C.name]]];
9941                 }
9942
9943
9944
9945                 if(grazeFlag)
9946                     message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
9947
9948                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
9949                 btHitFlag2 = true;
9950
9951             }else if(battleDef2Flag){
9952
9953
9954                 U = UTop;
9955                 while (!(DUN[1] == U->number)) {
9956                     U = U->next;
9957                 }
9958
9959
9960                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
9961                 btHitFlag2 = false;
9962
9963             }else if(battleDod2Flag){
9964
9965                 U = UTop;
9966                 while (!(DUN[1] == U->number)) {
9967                     U = U->next;
9968                 }
9969
9970                 message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
9971
9972                 btHitFlag2 = false;
9973             }else{
9974
9975                 message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
9976                 btHitFlag2 = false;
9977             }
9978         SKIP1:
9979             [battleDialog setStringValue:message];
9980         SKIP3:
9981             U = UTop;
9982             [btHITtf2 setStringValue:[NSString stringWithFormat:@"命中率 %g％", floor(hit)]];
9983             bLoopFlag = true;
9984             messageProcess++;
9985             message = @"";
9986             avPlayerFlag2 = false;
9987             animationFlag3 = false;
9988             btAtattckMoveEnd = false;
9989             oopsCnt = 30;
9990             break;
9991         case 3:
9992             //おまんこ
9993             if(bLoopFlag) break;
9994             if(cpuAImodeflag && !cpuTurnEndFlag) {
9995                 wtRdy = false;
9996             wtRdy2 = false;
9997             }
9998
9999             fuckingLoadBugFix = false;
10000
10001             battleSetUp = false;
10002             battleSetFlag = false;
10003             battleFlag = false;
10004             battleRdy = false;
10005             battleSet2PushedFlag = false;
10006             cpuModeBATTLEendFlag = true;
10007             crCAL1 = 0;
10008             crCAL2 = 0;
10009             [battleWindow close];
10010             pussyLoopFlag = false;
10011             cpuAtkExtendFlag3 = false;
10012             cpuOMFGmoveATKfixFlag = false;
10013             unitNoMoveFlag = false;
10014             UA = NULL;
10015             Utarget = NULL;
10016             CPUmostDmgChoice = false;
10017             //おまんちん
10018             cpuIsAttackingFlag = false;
10019             for(int g = 0;g < chipWidth;g++){
10020                 for(int k = 0;k < chipHeight;k++){
10021                     g_attackRangeExtent[g][k] = 0;
10022                 }
10023             }
10024
10025             btDistanceX1 = 0;
10026             btDistanceX2 = 0;
10027             BTunitAttackFlag1 = false;
10028             BTunitAttackFlag2 = false;
10029             BTunitAttackFlag1 = false;
10030             btAttackMoveValue1 = 0;
10031             btAttackMoveValue2 = 0;
10032             btHitFlag1 = false;
10033             btHitFlag2 = false;
10034             btHitFlagCnt1 = 0;
10035             btHitFlagCnt2 = 0;
10036             btHitExtendFlag1 = false;
10037             btHitExtendProc1 = 0;
10038             btHitExtendMove1 = 0;
10039             btHitExtendFlag2 = false;
10040             btHitExtendProc2 = 0;
10041             btHitExtendMove2 = 0;
10042             baseDistanceCompFlag = false;
10043             battleVeryBegunFlag = false;
10044             CPUAttackSubmitFlag = false;
10045             battleSetUp = false;
10046             displayBattleCheckPanelFlag = 0;
10047             battleEndFlag = true;
10048             assholeLoadBugFix = false;
10049
10050             battleIsProcFlag = false;
10051             break;
10052
10053         default:
10054             break;
10055     }
10056
10057
10058     UCselected = UC[-1];
10059
10060
10061 }
10062
10063 -(void)DisplayMessageMod1A{//両方モビール
10064
10065     double def2 = (double)31/32;
10066     NSString *message = @"";
10067
10068     enum{
10069         RIKU,
10070         UMI,
10071         CHU,
10072         SORA,
10073     };
10074
10075     enum{
10076         A,
10077         B,
10078         C,
10079         D,
10080         E,
10081         S,
10082         SS
10083     };
10084
10085
10086
10087     if(bLoopFlag) return;
10088     U = UTop;
10089     while (!(AUN[1] == U->number)) {
10090         U = U->next;
10091     }
10092     U2 = U;
10093     ATTACK *aTop = U->CL.A;
10094     for(int i = 0;i < crCAL1;i++){
10095         U->CL.A = U->CL.A->next;
10096     }
10097
10098
10099     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10100
10101     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10102         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10103
10104         NSString *path = @"data/AttackList/ALdata";
10105
10106         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10107
10108         path = [path stringByAppendingFormat:@"/"];
10109
10110         path = [path stringByAppendingString:U->CL.A->AN.movName];
10111
10112         NSData *AVData = [NSData dataWithContentsOfFile:path];
10113
10114         if(AVData)
10115             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10116
10117
10118         if(!AVpreview){
10119
10120             NSString *path = @"data/AttackList3/IALdata";
10121
10122             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10123
10124             path = [path stringByAppendingFormat:@"/"];
10125
10126             path = [path stringByAppendingString:U->CL.A->AN.movName];
10127
10128
10129             NSData *AVData = [NSData dataWithContentsOfFile:path];
10130
10131             if(AVData)
10132                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10133
10134
10135         }
10136
10137         if(AVpreview) {
10138             AVPV.player = [AVpreview retain];
10139         }else{
10140             goto avAWESOME1A;
10141         }
10142
10143
10144         [AVPV setHidden:NO];
10145         [AVpreview play];
10146         [battleDialog setStringValue:message];
10147
10148         avPlayerFlag1 = true;
10149
10150         U->CL.A = aTop;
10151
10152         U = UTop;
10153         return;
10154     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10155
10156         [battleDialog setStringValue:message];
10157         animationFlag1 = true;
10158         aniFrameCnt = 0;
10159         return;
10160     }
10161
10162 avAWESOME1A:{}
10163
10164     dmg = U->CL.A->totalD;
10165
10166     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10167     U->CL.S_C.EN -= costMP;
10168
10169     hit = U->CL.S_C.MOB+U->C.S_C.HIT;
10170     hitFix = U->CL.A->hitPercent;
10171
10172     U2A = U->CL.A;
10173     U->CL.A = aTop;
10174
10175     U = UTop;
10176     while (!(DUN[1] == U->number)) {
10177         U = U->next;
10178     }
10179     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;
10180     if(hit > 100) hit = 100;
10181     if(U2A->D->sort == 1){
10182         hit = 100;
10183     }
10184     if([self sortEcheck:U2A opponent:U])
10185         hit = 0;
10186
10187     healFlag = false;
10188
10189     int wtf = 100;
10190     if(battleDod2Flag) wtf = 50;
10191     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10192
10193         if(U2A->D->sort == 0){
10194             NSLog(@"修正前のダメージ:%g", dmg);
10195             dmg = [self dmgResist:dmg];
10196             NSLog(@"属性後のダメージ:%g", dmg);
10197             def2 = pow(def2, U->CL.S_C.ARM);
10198             int omfg = rand()%100;
10199             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10200
10201             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10202             dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10203             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10204             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10205             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10206
10207             if(U->CL.S_C.typeMOVE == RIKU){
10208                 if(U2A->riku == A) dmg = dmg*1.2;
10209                 if(U2A->riku == B) dmg = dmg*1.0;
10210                 if(U2A->riku == C) dmg = dmg*0.6;
10211                 if(U2A->riku == D) dmg = dmg*0.2;
10212                 if(U2A->riku == E) dmg = 0;
10213                 if(U2A->riku == S) dmg = dmg*1.5;
10214                 if(U2A->riku == SS) dmg = dmg*2.0;
10215             } if(U->CL.S_C.typeMOVE == UMI &&
10216                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10217                 if(U2A->umi == A) dmg = dmg*1.2;
10218                 if(U2A->umi == B) dmg = dmg*1.0;
10219                 if(U2A->umi == C) dmg = dmg*0.6;
10220                 if(U2A->umi == D) dmg = dmg*0.2;
10221                 if(U2A->umi == E) dmg = 0;
10222                 if(U2A->umi == S) dmg = dmg*1.5;
10223                 if(U2A->umi == SS) dmg = dmg*2.0;
10224             }else if(U->CL.S_C.typeMOVE == UMI){
10225                 if(U2A->riku == A) dmg = dmg*1.2;
10226                 if(U2A->riku == B) dmg = dmg*1.0;
10227                 if(U2A->riku == C) dmg = dmg*0.6;
10228                 if(U2A->riku == D) dmg = dmg*0.2;
10229                 if(U2A->riku == E) dmg = 0;
10230                 if(U2A->riku == S) dmg = dmg*1.5;
10231                 if(U2A->riku == SS) dmg = dmg*2.0;
10232
10233             } if(U->CL.S_C.typeMOVE == CHU){
10234                 if(U2A->chu == A) dmg = dmg*1.2;
10235                 if(U2A->chu == B) dmg = dmg*1.0;
10236                 if(U2A->chu == C) dmg = dmg*0.6;
10237                 if(U2A->chu == D) dmg = dmg*0.2;
10238                 if(U2A->chu == E) dmg = 0;
10239                 if(U2A->chu == S) dmg = dmg*1.5;
10240                 if(U2A->chu == SS) dmg = dmg*2.0;
10241             } if(U->CL.S_C.typeMOVE == SORA){
10242                 if(U2A->sora == A) dmg = dmg*1.2;
10243                 if(U2A->sora == B) dmg = dmg*1.0;
10244                 if(U2A->sora == C) dmg = dmg*0.6;
10245                 if(U2A->sora == D) dmg = dmg*0.2;
10246                 if(U2A->sora == E) dmg = 0;
10247                 if(U2A->sora == S) dmg = dmg*1.5;
10248                 if(U2A->sora == SS) dmg = dmg*2.0;
10249             }
10250
10251             NSLog(@"ユニットの地形適用後:%g", dmg);
10252             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10253             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10254
10255             grazeFlag = false;
10256             omfg = rand()%100;
10257             if(graze > omfg && !healFlag) {dmg = dmg/5;
10258                 grazeFlag = true;
10259             }
10260             if(battleDef2Flag) dmg -= dmg*0.5;
10261             battleDef2Flag = false;
10262             dmg = floor(dmg);
10263             if(dmg < 0) dmg = 0;
10264             U->CL.S_C.HP -= dmg;
10265             U->C.S_C.vigor++;
10266
10267         }else if(U2A->D->sort == 1){
10268             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10269             dmg = floor(dmg);
10270
10271             U->CL.S_C.HP += dmg;
10272
10273             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10274             healFlag = true;
10275         }
10276
10277         while(1){
10278             if(U->CL.S_C.HP <= 0) {
10279                 U->CL.S_C.HP = 0;
10280                 U2->C.S_C.vigor += 5;
10281
10282                 messageProcess = 2;
10283                 if(U->dead) break;
10284                 U->dead = true;
10285
10286
10287                 if(U->targType1L)
10288                     targType1cnt[0]--;
10289                 if(U->targType2L) {
10290                     targType2cnt[0]--;
10291                     targType2Lflag = true;
10292                 }
10293
10294                 if(U->targType1D)
10295                     targType1cnt[1]--;
10296                 if(U->targType2D) {
10297                     targType2cnt[1]--;
10298                     targType2Dflag = true;
10299                 }
10300
10301                 break;
10302             }
10303             break;
10304         }
10305
10306         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10307         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10308
10309         if(![U2A->msg isEqualToString:@""]){
10310
10311             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10312                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10313
10314         }
10315
10316         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10317         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10318         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
10319     }else if(battleDef1Flag){
10320
10321
10322         U = UTop;
10323         while (!(AUN[1] == U->number)) {
10324             U = U->next;
10325         }
10326
10327
10328         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10329
10330
10331     }else if(battleDod1Flag){
10332
10333         U = UTop;
10334         while (!(AUN[1] == U->number)) {
10335             U = U->next;
10336         }
10337
10338         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10339
10340
10341     }else{
10342
10343         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10344
10345     }
10346     [battleDialog setStringValue:message];
10347
10348
10349     U = UTop;
10350
10351     bLoopFlag = true;
10352
10353     if(healFlag) {
10354         messageProcess++;
10355     };
10356     messageProcess++;
10357
10358     return;
10359
10360 }
10361
10362 -(void)DisplayMessageMod1B{
10363
10364     double def2 = (double)31/32;
10365     NSString *message = @"";
10366
10367     enum{
10368         RIKU,
10369         UMI,
10370         CHU,
10371         SORA,
10372     };
10373
10374     enum{
10375         A,
10376         B,
10377         C,
10378         D,
10379         E,
10380         S,
10381         SS
10382     };
10383
10384
10385     if(bLoopFlag) return;
10386
10387     U = UTop;
10388     while (!(AUN[1] == U->number)) {
10389         U = U->next;
10390     }
10391     U2 = U;
10392     U = UTop;
10393
10394     U = UTop;
10395     while (!(DUN[1] == U->number)) {
10396         U = U->next;
10397     }
10398
10399     ATTACK *aTop2 = U->CL.A;
10400     int mostDmg = 0;
10401     int mostNum = 0;
10402     int num = 0;
10403     int mpCost =0;
10404     if(U->CL.A) {
10405         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10406         costVIG = U->C.A->vigor;
10407     }
10408     while(U->CL.A){
10409         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10410         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]){
10411             mostDmg = U->CL.A->totalD;
10412             mostNum = num;
10413         }
10414         U->CL.A = U->CL.A->next;
10415         num++;
10416     }
10417
10418     U->CL.A = aTop2;
10419
10420     if(!battleSet2PushedFlag){
10421         for(int i = 0;i < mostNumSub;i++){
10422             U->CL.A = U->CL.A->next;
10423         }
10424
10425     }else{
10426         for(int i = 0;i < crCAL2;i++){
10427             U->CL.A = U->CL.A->next;
10428         }
10429     }
10430
10431     if(!U->CL.A->name){
10432
10433         U->CL.A = NULL;
10434     }
10435     if(U->CL.A){
10436     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]){
10437     }else while(U->CL.A){
10438         U->CL.A = U->CL.A->next;
10439     }
10440     }
10441
10442     if(!U->CL.A){
10443         U->CL.A = aTop2;
10444         U = UTop;
10445         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
10446         goto SKIP1;
10447     }
10448
10449     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10450
10451
10452     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10453         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10454
10455         NSString *path = @"data/AttackList/ALdata";
10456
10457         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10458
10459         path = [path stringByAppendingFormat:@"/"];
10460
10461         path = [path stringByAppendingString:U->CL.A->AN.movName];
10462
10463
10464         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10465
10466         if(AVpreview) {
10467             AVPV.player = [AVpreview retain];
10468         }else{
10469             goto avAWESOME1B;
10470         }
10471
10472         [AVPV setControlsStyle:0];
10473         [AVPV setHidden:NO];
10474         [AVpreview play];
10475         [battleDialog setStringValue:message];
10476
10477         avPlayerFlag2 = true;
10478
10479         U->CL.A = aTop2;
10480         U = UTop;
10481         return;
10482     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
10483
10484
10485         animationFlag2 = true;
10486         aniFrameCnt = 0;
10487         return;
10488     }
10489
10490
10491 avAWESOME1B:{}
10492
10493     dmg = U->CL.A->totalD;
10494
10495     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10496     U->CL.S_C.EN -= costMP;
10497
10498     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10499     hitFix = U->CL.A->hitPercent;
10500
10501     U2A = U->CL.A;
10502     U->CL.A = aTop2;
10503
10504
10505     U = UTop;
10506     while (!(AUN[1] == U->number)) {
10507         U = U->next;
10508     }
10509
10510
10511     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;
10512     if(hit > 100) hit = 100;
10513
10514     if([self sortEcheck:U2A opponent:U])
10515         hit = 0;
10516
10517     battleDod1Flag = false;
10518
10519     int omg = 100;
10520     if(battleDod1Flag) omg = 50;
10521
10522     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
10523         NSLog(@"修正前のダメージ:%g", dmg);
10524         dmg = [self dmgResist:dmg];
10525         NSLog(@"属性後のダメージ:%g", dmg);
10526         def2 = pow(def2, U->CL.S_C.ARM);
10527         int omfg = rand()%100;
10528         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
10529         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg + dmg - U->CL.S_C.ARM));
10530         dmg = (dmg*omfg/100 + dmg - U->CL.S_C.ARM);
10531
10532
10533         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10534         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10535         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10536
10537         if(U->CL.S_C.typeMOVE == RIKU){
10538             if(U2A->riku == A) dmg = dmg*1.2;
10539             if(U2A->riku == B) dmg = dmg*1.0;
10540             if(U2A->riku == C) dmg = dmg*0.6;
10541             if(U2A->riku == D) dmg = dmg*0.2;
10542             if(U2A->riku == E) dmg = 0;
10543             if(U2A->riku == S) dmg = dmg*1.5;
10544             if(U2A->riku == SS) dmg = dmg*2.0;
10545         } if(U->CL.S_C.typeMOVE == UMI &&
10546              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10547             if(U2A->umi == A) dmg = dmg*1.2;
10548             if(U2A->umi == B) dmg = dmg*1.0;
10549             if(U2A->umi == C) dmg = dmg*0.6;
10550             if(U2A->umi == D) dmg = dmg*0.2;
10551             if(U2A->umi == E) dmg = 0;
10552             if(U2A->umi == S) dmg = dmg*1.5;
10553             if(U2A->umi == SS) dmg = dmg*2.0;
10554         }else if(U->CL.S_C.typeMOVE == UMI){
10555             if(U2A->riku == A) dmg = dmg*1.2;
10556             if(U2A->riku == B) dmg = dmg*1.0;
10557             if(U2A->riku == C) dmg = dmg*0.6;
10558             if(U2A->riku == D) dmg = dmg*0.2;
10559             if(U2A->riku == E) dmg = 0;
10560             if(U2A->riku == S) dmg = dmg*1.5;
10561             if(U2A->riku == SS) dmg = dmg*2.0;
10562
10563         } if(U->CL.S_C.typeMOVE == CHU){
10564             if(U2A->chu == A) dmg = dmg*1.2;
10565             if(U2A->chu == B) dmg = dmg*1.0;
10566             if(U2A->chu == C) dmg = dmg*0.6;
10567             if(U2A->chu == D) dmg = dmg*0.2;
10568             if(U2A->chu == E) dmg = 0;
10569             if(U2A->chu == S) dmg = dmg*1.5;
10570             if(U2A->chu == SS) dmg = dmg*2.0;
10571         } if(U->CL.S_C.typeMOVE == SORA){
10572             if(U2A->sora == A) dmg = dmg*1.2;
10573             if(U2A->sora == B) dmg = dmg*1.0;
10574             if(U2A->sora == C) dmg = dmg*0.6;
10575             if(U2A->sora == D) dmg = dmg*0.2;
10576             if(U2A->sora == E) dmg = 0;
10577             if(U2A->sora == S) dmg = dmg*1.5;
10578             if(U2A->sora == SS) dmg = dmg*2.0;
10579         }
10580
10581         NSLog(@"ユニットの地形適用後:%g", dmg);
10582
10583         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10584
10585         grazeFlag = false;
10586         omfg = rand()&100;
10587         if(graze > omfg && !healFlag) {dmg = dmg/5;
10588             grazeFlag = true;
10589         }
10590
10591         if(battleDef1Flag) dmg -= dmg*0.5;
10592         battleDef1Flag = false;
10593         dmg = floor(dmg);
10594         if(dmg < 0) dmg = 0;
10595         U->CL.S_C.HP -= dmg;
10596         U->C.S_C.vigor++;
10597
10598         while(1){
10599             if(U->CL.S_C.HP <= 0) {
10600                 U->CL.S_C.HP = 0;
10601                 U2->C.S_C.vigor += 5;
10602
10603                 messageProcess = 2;
10604                 if(U->dead) break;
10605                 U->dead = true;
10606
10607
10608                 if(U->targType1L)
10609                     targType1cnt[0]--;
10610                 if(U->targType2L) {
10611                     targType2cnt[0]--;
10612                     targType2Lflag = true;
10613                 }
10614
10615                 if(U->targType1D)
10616                     targType1cnt[1]--;
10617                 if(U->targType2D) {
10618                     targType2cnt[1]--;
10619                     targType2Dflag = true;
10620                 }
10621
10622                 break;
10623             }
10624             break;
10625         }
10626
10627
10628
10629         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
10630
10631         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
10632
10633         if(![U2A->msg isEqualToString:@""]){
10634             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10635                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->CL.name]]];
10636         }
10637
10638
10639
10640         if(grazeFlag)
10641             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10642
10643         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
10644
10645     }else if(battleDef2Flag){
10646
10647
10648         U = UTop;
10649         while (!(DUN[1] == U->number)) {
10650             U = U->next;
10651         }
10652
10653
10654         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10655
10656
10657     }else if(battleDod2Flag){
10658
10659         U = UTop;
10660         while (!(DUN[1] == U->number)) {
10661             U = U->next;
10662         }
10663
10664         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10665
10666
10667     }else{
10668
10669         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
10670     }
10671 SKIP1:
10672     [battleDialog setStringValue:message];
10673
10674     U = UTop;
10675     bLoopFlag = true;
10676     messageProcess++;
10677     return;
10678
10679 }
10680
10681 -(void)DisplayMessageMod2A{//攻撃側モビール
10682
10683     double def2 = (double)31/32;
10684     NSString *message = @"";
10685
10686     enum{
10687         RIKU,
10688         UMI,
10689         CHU,
10690         SORA,
10691     };
10692
10693     enum{
10694         A,
10695         B,
10696         C,
10697         D,
10698         E,
10699         S,
10700         SS
10701     };
10702
10703
10704     if(bLoopFlag) return;
10705     U = UTop;
10706
10707     while (!(DUN[1] == U->number)) {
10708         U = U->next;
10709     }
10710     U2 = U;
10711
10712     U = UTop;
10713     while (!(AUN[1] == U->number)) {
10714         U = U->next;
10715     }
10716
10717     ATTACK *aTop = U->CL.A;
10718     for(int i = 0;i < crCAL1;i++){
10719         U->CL.A = U->CL.A->next;
10720     }
10721
10722
10723     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
10724
10725     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
10726         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
10727
10728         NSString *path = @"data/AttackList/ALdata";
10729
10730         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
10731
10732         path = [path stringByAppendingFormat:@"/"];
10733
10734         path = [path stringByAppendingString:U->CL.A->AN.movName];
10735
10736         NSData *AVData = [NSData dataWithContentsOfFile:path];
10737
10738         if(AVData)
10739             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10740
10741
10742         if(!AVpreview){
10743
10744             NSString *path = @"data/AttackList3/IALdata";
10745
10746             path = [path stringByAppendingFormat:@"%dE", U->CL.A->indexE];
10747
10748             path = [path stringByAppendingFormat:@"/"];
10749
10750             path = [path stringByAppendingString:U->CL.A->AN.movName];
10751
10752
10753             NSData *AVData = [NSData dataWithContentsOfFile:path];
10754
10755             if(AVData)
10756                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
10757
10758
10759         }
10760
10761         if(AVpreview) {
10762             AVPV.player = [AVpreview retain];
10763         }else{
10764             goto avAWESOME2A;
10765         }
10766
10767
10768         [AVPV setHidden:NO];
10769         [AVpreview play];
10770         [battleDialog setStringValue:message];
10771
10772         avPlayerFlag1 = true;
10773
10774         U->CL.A = aTop;
10775
10776         U = UTop;
10777         return;
10778     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->CL.A->AN.ANI && !animationFlag3){
10779
10780         [battleDialog setStringValue:message];
10781         animationFlag1 = true;
10782         aniFrameCnt = 0;
10783         return;
10784     }
10785
10786 avAWESOME2A:{}
10787
10788     dmg = U->CL.A->totalD;
10789     double val = 1/log(3+U2->C.S_C.MP/64);
10790     if(U2->C.aura){
10791         dmg = dmg*val;
10792     }
10793
10794     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
10795     U->CL.S_C.EN -= costMP;
10796
10797     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
10798     hitFix = U->CL.A->hitPercent;
10799
10800     U2A = U->CL.A;
10801     U->CL.A = aTop;
10802
10803     U = UTop;
10804     while (!(DUN[1] == U->number)) {
10805         U = U->next;
10806     }
10807
10808     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
10809
10810     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
10811     if(hi < 0) hi = 0;
10812
10813     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
10814     if(hit > 100) hit = 100;
10815     if(U2A->D->sort == 1){
10816         hit = 100;
10817     }
10818     if([self sortEcheck:U2A opponent:U])
10819         hit = 0;
10820
10821     healFlag = false;
10822
10823     int wtf = 100;
10824     if(battleDod2Flag) wtf = 50;
10825     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
10826
10827         if(U2A->D->sort == 0){
10828             NSLog(@"修正前のダメージ:%g", dmg);
10829             dmg = [self dmgResist:dmg];
10830             NSLog(@"属性後のダメージ:%g", dmg);
10831             def2 = pow(def2, U->C.S_C.DEF);
10832             int omfg = rand()%100;
10833             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
10834             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
10835             dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
10836             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
10837             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
10838             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
10839
10840             if(U->C.S_C.typeMOVE == RIKU){
10841                 if(U2A->riku == A) dmg = dmg*1.2;
10842                 if(U2A->riku == B) dmg = dmg*1.0;
10843                 if(U2A->riku == C) dmg = dmg*0.6;
10844                 if(U2A->riku == D) dmg = dmg*0.2;
10845                 if(U2A->riku == E) dmg = 0;
10846                 if(U2A->riku == S) dmg = dmg*1.5;
10847                 if(U2A->riku == SS) dmg = dmg*2.0;
10848             } if(U->C.S_C.typeMOVE == UMI &&
10849                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
10850                 if(U2A->umi == A) dmg = dmg*1.2;
10851                 if(U2A->umi == B) dmg = dmg*1.0;
10852                 if(U2A->umi == C) dmg = dmg*0.6;
10853                 if(U2A->umi == D) dmg = dmg*0.2;
10854                 if(U2A->umi == E) dmg = 0;
10855                 if(U2A->umi == S) dmg = dmg*1.5;
10856                 if(U2A->umi == SS) dmg = dmg*2.0;
10857             }else if(U->C.S_C.typeMOVE == UMI){
10858                 if(U2A->riku == A) dmg = dmg*1.2;
10859                 if(U2A->riku == B) dmg = dmg*1.0;
10860                 if(U2A->riku == C) dmg = dmg*0.6;
10861                 if(U2A->riku == D) dmg = dmg*0.2;
10862                 if(U2A->riku == E) dmg = 0;
10863                 if(U2A->riku == S) dmg = dmg*1.5;
10864                 if(U2A->riku == SS) dmg = dmg*2.0;
10865
10866             } if(U->C.S_C.typeMOVE == CHU){
10867                 if(U2A->chu == A) dmg = dmg*1.2;
10868                 if(U2A->chu == B) dmg = dmg*1.0;
10869                 if(U2A->chu == C) dmg = dmg*0.6;
10870                 if(U2A->chu == D) dmg = dmg*0.2;
10871                 if(U2A->chu == E) dmg = 0;
10872                 if(U2A->chu == S) dmg = dmg*1.5;
10873                 if(U2A->chu == SS) dmg = dmg*2.0;
10874             } if(U->C.S_C.typeMOVE == SORA){
10875                 if(U2A->sora == A) dmg = dmg*1.2;
10876                 if(U2A->sora == B) dmg = dmg*1.0;
10877                 if(U2A->sora == C) dmg = dmg*0.6;
10878                 if(U2A->sora == D) dmg = dmg*0.2;
10879                 if(U2A->sora == E) dmg = 0;
10880                 if(U2A->sora == S) dmg = dmg*1.5;
10881                 if(U2A->sora == SS) dmg = dmg*2.0;
10882             }
10883
10884             NSLog(@"ユニットの地形適用後:%g", dmg);
10885             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
10886             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
10887
10888             grazeFlag = false;
10889             omfg = rand()%100;
10890             if(graze > omfg && !healFlag) {dmg = dmg/5;
10891                 grazeFlag = true;
10892             }
10893             if(battleDef2Flag) dmg -= dmg*0.5;
10894             battleDef2Flag = false;
10895             dmg = floor(dmg);
10896             if(dmg < 0) dmg = 0;
10897             U->C.S_C.HP -= dmg;
10898             U->C.S_C.vigor++;
10899
10900         }else if(U2A->D->sort == 1){
10901             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
10902             dmg = floor(dmg);
10903
10904             U->CL.S_C.HP += dmg;
10905
10906             if(U->CL.S_C.HP > U->CL.S_M.HP) U->CL.S_C.HP = U->CL.S_M.HP;
10907             healFlag = true;
10908         }
10909
10910         while(1){
10911             if(U->C.S_C.HP <= 0) {
10912                 U->C.S_C.HP = 0;
10913                 U2->C.S_C.vigor += 5;
10914
10915                 messageProcess = 2;
10916                 if(U->dead) break;
10917                 U->dead = true;
10918
10919
10920                 if(U->targType1L)
10921                     targType1cnt[0]--;
10922                 if(U->targType2L) {
10923                     targType2cnt[0]--;
10924                     targType2Lflag = true;
10925                 }
10926
10927                 if(U->targType1D)
10928                     targType1cnt[1]--;
10929                 if(U->targType2D) {
10930                     targType2cnt[1]--;
10931                     targType2Dflag = true;
10932                 }
10933
10934                 break;
10935             }
10936             break;
10937         }
10938
10939         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
10940         [lplayer2 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
10941
10942         if(![U2A->msg isEqualToString:@""]){
10943
10944             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
10945                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
10946
10947         }
10948
10949         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
10950         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
10951         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->C.name, dmg]];
10952     }else if(battleDef1Flag){
10953
10954
10955         U = UTop;
10956         while (!(AUN[1] == U->number)) {
10957             U = U->next;
10958         }
10959
10960
10961         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
10962
10963
10964     }else if(battleDod1Flag){
10965
10966         U = UTop;
10967         while (!(AUN[1] == U->number)) {
10968             U = U->next;
10969         }
10970
10971         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
10972
10973
10974     }else{
10975
10976         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
10977
10978     }
10979     [battleDialog setStringValue:message];
10980
10981
10982     U = UTop;
10983
10984     bLoopFlag = true;
10985
10986     if(healFlag) {
10987         messageProcess++;
10988     };
10989     messageProcess++;
10990
10991     return;
10992
10993
10994 }
10995
10996 -(void)DisplayMessageMod2B{
10997
10998     double def2 = (double)31/32;
10999     NSString *message = @"";
11000
11001     enum{
11002         RIKU,
11003         UMI,
11004         CHU,
11005         SORA,
11006     };
11007
11008     enum{
11009         A,
11010         B,
11011         C,
11012         D,
11013         E,
11014         S,
11015         SS
11016     };
11017
11018
11019     if(bLoopFlag) return;
11020
11021     U = UTop;
11022     while (!(AUN[1] == U->number)) {
11023         U = U->next;
11024     }
11025     U2 = U;
11026     U = UTop;
11027
11028     U = UTop;
11029     while (!(DUN[1] == U->number)) {
11030         U = U->next;
11031     }
11032
11033     ATTACK *aTop2 = U->C.A;
11034     int mostDmg = 0;
11035     int mostNum = -1;
11036     int num = 0;
11037     int mpCost =0;
11038     if(U->C.A) {
11039         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11040         costVIG = U->C.A->vigor;
11041         }
11042     while(U->C.A){
11043         costVIG = U->C.A->vigor;
11044
11045         mpCost = floor(U->C.A->MP + U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11046         if(U->C.A->D)
11047         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]){
11048             mostDmg = U->C.A->totalD;
11049             mostNum = num;
11050         }
11051         U->C.A = U->C.A->next;
11052         num++;
11053     }
11054
11055     U->C.A = aTop2;
11056
11057     if(!battleSet2PushedFlag){
11058         for(int i = 0;i < mostNumSub;i++){
11059             U->C.A = U->C.A->next;
11060         }
11061
11062         if(mostNum < 0) U->C.A = NULL;
11063     }else{
11064         for(int i = 0;i < crCAL2;i++){
11065             U->C.A = U->C.A->next;
11066         }
11067     }
11068     if(U->C.A){
11069         if(U->C.A->D){
11070     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]){
11071     }else while(U->CL.A){
11072         U->C.A = U->C.A->next;
11073     }}
11074     }
11075     if(!U->C.A){
11076         U->C.A = aTop2;
11077         U = UTop;
11078         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11079         goto SKIP1;
11080     }
11081     if(!U->C.A->name){
11082         U->C.A = aTop2;
11083         U = UTop;
11084         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11085         goto SKIP1;
11086     }
11087
11088     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
11089
11090
11091     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->C.A->AN.movName isEqualToString:@""] && ![U->C.A->AN.movName isEqualToString:@"(null)"] && U->C.A->AN.movName != NULL){
11092         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11093
11094         NSString *path = @"data/AttackList/ALdata";
11095
11096         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11097
11098         path = [path stringByAppendingFormat:@"/"];
11099
11100         path = [path stringByAppendingString:U->C.A->AN.movName];
11101
11102
11103         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11104
11105         if(AVpreview) {
11106             AVPV.player = [AVpreview retain];
11107         }else{
11108             goto avAWESOME2B;
11109         }
11110
11111         [AVPV setControlsStyle:0];
11112         [AVPV setHidden:NO];
11113         [AVpreview play];
11114         [battleDialog setStringValue:message];
11115
11116         avPlayerFlag2 = true;
11117
11118         U->C.A = aTop2;
11119         U = UTop;
11120         return;
11121     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->C.A->AN.ANI && !animationFlag3){
11122
11123
11124         animationFlag2 = true;
11125         aniFrameCnt = 0;
11126         return;
11127     }
11128
11129
11130 avAWESOME2B:{}
11131
11132
11133     /*
11134     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11135     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11136     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11137     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11138     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11139     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11140     */
11141
11142     double urSupposedToGet;
11143
11144     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11145
11146     double oopsIsRight;
11147     bool lolFlag = false;
11148     if(U->C.A) {
11149     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11150     else oopsIsRight = U->C.S_C.MIS;
11151
11152         if(U->C.A->D){
11153     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;
11154     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;
11155     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;
11156     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;
11157     if(U->C.A->D->type == 4) {
11158         lolFlag = true;
11159         dmg = (U->C.S_C.CAP + urSupposedToGet)*oopsIsRight/100;
11160     }
11161     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11162         }}
11163         costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11164     U->C.S_C.MP -= costMP;
11165
11166     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11167     hitFix = U->C.A->hitPercent;
11168
11169     U2A = U->C.A;
11170     U->C.A = aTop2;
11171
11172     U = UTop;
11173     while (!(AUN[1] == U->number)) {
11174         U = U->next;
11175     }
11176
11177     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;
11178     if(hit > 100) hit = 100;
11179
11180     if([self sortEcheck:U2A opponent:U])
11181         hit = 0;
11182
11183     battleDod1Flag = false;
11184
11185     int omg = 100;
11186     if(battleDod1Flag) omg = 50;
11187
11188     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11189         NSLog(@"修正前のダメージ:%g, %g", dmg, U2A->D->seed);
11190
11191         dmg = [self dmgResist:dmg];
11192         NSLog(@"属性後のダメージ:%g", dmg);
11193         def2 = pow(def2, U->CL.S_C.ARM);
11194         int omfg = rand()%100;
11195         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->CL.S_C.ARM);
11196         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11197         if(lolFlag) dmg = (dmg*omfg/100/10 + dmg);
11198         else dmg = (dmg*omfg/100/10+ dmg - U->CL.S_C.ARM);
11199
11200
11201         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11202         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11203         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11204
11205         if(U->CL.S_C.typeMOVE == RIKU){
11206             if(U2A->riku == A) dmg = dmg*1.2;
11207             if(U2A->riku == B) dmg = dmg*1.0;
11208             if(U2A->riku == C) dmg = dmg*0.6;
11209             if(U2A->riku == D) dmg = dmg*0.2;
11210             if(U2A->riku == E) dmg = 0;
11211             if(U2A->riku == S) dmg = dmg*1.5;
11212             if(U2A->riku == SS) dmg = dmg*2.0;
11213         } if(U->CL.S_C.typeMOVE == UMI &&
11214              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11215             if(U2A->umi == A) dmg = dmg*1.2;
11216             if(U2A->umi == B) dmg = dmg*1.0;
11217             if(U2A->umi == C) dmg = dmg*0.6;
11218             if(U2A->umi == D) dmg = dmg*0.2;
11219             if(U2A->umi == E) dmg = 0;
11220             if(U2A->umi == S) dmg = dmg*1.5;
11221             if(U2A->umi == SS) dmg = dmg*2.0;
11222         }else if(U->CL.S_C.typeMOVE == UMI){
11223             if(U2A->riku == A) dmg = dmg*1.2;
11224             if(U2A->riku == B) dmg = dmg*1.0;
11225             if(U2A->riku == C) dmg = dmg*0.6;
11226             if(U2A->riku == D) dmg = dmg*0.2;
11227             if(U2A->riku == E) dmg = 0;
11228             if(U2A->riku == S) dmg = dmg*1.5;
11229             if(U2A->riku == SS) dmg = dmg*2.0;
11230
11231         } if(U->CL.S_C.typeMOVE == CHU){
11232             if(U2A->chu == A) dmg = dmg*1.2;
11233             if(U2A->chu == B) dmg = dmg*1.0;
11234             if(U2A->chu == C) dmg = dmg*0.6;
11235             if(U2A->chu == D) dmg = dmg*0.2;
11236             if(U2A->chu == E) dmg = 0;
11237             if(U2A->chu == S) dmg = dmg*1.5;
11238             if(U2A->chu == SS) dmg = dmg*2.0;
11239         } if(U->CL.S_C.typeMOVE == SORA){
11240             if(U2A->sora == A) dmg = dmg*1.2;
11241             if(U2A->sora == B) dmg = dmg*1.0;
11242             if(U2A->sora == C) dmg = dmg*0.6;
11243             if(U2A->sora == D) dmg = dmg*0.2;
11244             if(U2A->sora == E) dmg = 0;
11245             if(U2A->sora == S) dmg = dmg*1.5;
11246             if(U2A->sora == SS) dmg = dmg*2.0;
11247         }
11248
11249         NSLog(@"ユニットの地形適用後:%g", dmg);
11250
11251         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11252
11253         grazeFlag = false;
11254         omfg = rand()&100;
11255         if(graze > omfg && !healFlag) {dmg = dmg/5;
11256             grazeFlag = true;
11257         }
11258
11259         if(battleDef1Flag) dmg -= dmg*0.5;
11260         battleDef1Flag = false;
11261         dmg = floor(dmg);
11262         if(dmg < 0) dmg = 0;
11263         U->CL.S_C.HP -= dmg;
11264         U->C.S_C.vigor++;
11265
11266         while(1){
11267             if(U->CL.S_C.HP <= 0) {
11268                 U->CL.S_C.HP = 0;
11269                 U2->C.S_C.vigor += 5;
11270
11271                 messageProcess = 2;
11272                 if(U->dead) break;
11273                 U->dead = true;
11274
11275
11276                 if(U->targType1L)
11277                     targType1cnt[0]--;
11278                 if(U->targType2L) {
11279                     targType2cnt[0]--;
11280                     targType2Lflag = true;
11281                 }
11282
11283                 if(U->targType1D)
11284                     targType1cnt[1]--;
11285                 if(U->targType2D) {
11286                     targType2cnt[1]--;
11287                     targType2Dflag = true;
11288                 }
11289
11290                 break;
11291             }
11292             break;
11293         }
11294
11295
11296
11297         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11298
11299         [lplayer1 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11300
11301         if(![U2A->msg isEqualToString:@""]){
11302             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11303                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11304         }
11305
11306
11307
11308         if(grazeFlag)
11309             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11310
11311         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11312
11313     }else if(battleDef2Flag){
11314
11315
11316         U = UTop;
11317         while (!(DUN[1] == U->number)) {
11318             U = U->next;
11319         }
11320
11321
11322         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11323
11324
11325     }else if(battleDod2Flag){
11326
11327         U = UTop;
11328         while (!(DUN[1] == U->number)) {
11329             U = U->next;
11330         }
11331
11332         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11333
11334
11335     }else{
11336
11337         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11338     }
11339 SKIP1:
11340     [battleDialog setStringValue:message];
11341
11342     U = UTop;
11343     bLoopFlag = true;
11344     messageProcess++;
11345     return;
11346
11347
11348 }
11349
11350 -(void)DisplayMessageMod3A{//防御側モビール
11351
11352     double def2 = (double)31/32;
11353     NSString *message = @"";
11354
11355     enum{
11356         RIKU,
11357         UMI,
11358         CHU,
11359         SORA,
11360     };
11361
11362     enum{
11363         A,
11364         B,
11365         C,
11366         D,
11367         E,
11368         S,
11369         SS
11370     };
11371
11372     static bool extentbool3 = false;
11373     static bool extentbool4 = false;
11374     if(!extentbool3 && extentBattleFlag2){
11375         extentbool3 = true;
11376         extentMPcostFlag = false;
11377         DUNnum = 1;
11378     }
11379     if(!extentBattleFlag2){
11380         DUNnum = 1;
11381     }
11382
11383     if(bLoopFlag) return;
11384     U = UTop;
11385     U = UTop;
11386     while (!(DUN[DUNnum] == U->number)) {
11387         U = U->next;
11388     }
11389     U2 = U;
11390
11391     U = UTop;
11392     while (!(AUN[1] == U->number)) {
11393         U = U->next;
11394     }
11395
11396     ATTACK *aTop = U->C.A;
11397     for(int i = 0;i < crCAL1;i++){
11398         U->C.A = U->C.A->next;
11399     }
11400
11401
11402     if(!battleDef1Flag && !battleDod1Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->C.name, U->C.A->name]];
11403
11404
11405     [bplayer2 setImage:U2->CL.imgb];
11406     //[bplayer2 setImageScaling:NSScaleToFit];
11407     [nplayer2 setStringValue:U2->CL.name];
11408     [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U2->CL.S_C.HP, U2->CL.S_M.HP]];
11409     [lplayer2 setIntValue:U2->CL.S_C.HP/U2->CL.S_M.HP*100];
11410     [iplayer2 setImage:MC[chipNum[U2->x][U2->y]].img];
11411     [mplayer2 setStringValue:MC[chipNum[U2->x][U2->y]].name];
11412     [rplayer2 setStringValue:[NSString stringWithFormat:@"地形効果 %d％", MC[chipNum[U2->x][U2->y]].dmgfix]];
11413
11414     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){
11415         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11416
11417         NSString *path = @"data/AttackList/ALdata";
11418
11419         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11420
11421         path = [path stringByAppendingFormat:@"/"];
11422
11423         path = [path stringByAppendingString:U->C.A->AN.movName];
11424
11425         NSData *AVData = [NSData dataWithContentsOfFile:path];
11426
11427         if(AVData)
11428             AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11429
11430
11431         if(!AVpreview){
11432
11433             NSString *path = @"data/AttackList3/IALdata";
11434
11435             path = [path stringByAppendingFormat:@"%dE", U->C.A->indexE];
11436
11437             path = [path stringByAppendingFormat:@"/"];
11438
11439             path = [path stringByAppendingString:U->C.A->AN.movName];
11440
11441
11442             NSData *AVData = [NSData dataWithContentsOfFile:path];
11443
11444             if(AVData)
11445                 AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11446
11447
11448         }
11449
11450         if(AVpreview) {
11451             AVPV.player = [AVpreview retain];
11452         }else{
11453             goto avAWESOME3A;
11454         }
11455
11456
11457         [AVPV setHidden:NO];
11458         [AVpreview play];
11459         [battleDialog setStringValue:message];
11460
11461         avPlayerFlag1 = true;
11462
11463
11464         U->C.A = aTop;
11465         U = UTop;
11466         return;
11467     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag1 && U->C.A->AN.ANI && !animationFlag3 && DUN[DUNnum] == 1){
11468
11469         [battleDialog setStringValue:message];
11470         animationFlag1 = true;
11471         aniFrameCnt = 0;
11472         return;
11473     }
11474
11475 avAWESOME3A:{}
11476
11477     /*
11478     if(U->C.A->D->type == 0) dmg = U->C.S_C.ATK + U->C.A->totalD;
11479     if(U->C.A->D->type == 1) dmg = U->C.S_C.DEF + U->C.A->totalD;
11480     if(U->C.A->D->type == 2) dmg = U->C.S_C.ACU + U->C.A->totalD;
11481     if(U->C.A->D->type == 3) dmg = U->C.S_C.EVA + U->C.A->totalD;
11482     if(U->C.A->D->type == 4) dmg = U->C.S_C.CAP + U->C.A->totalD;
11483     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11484     */
11485
11486     double urSupposedToGet;
11487
11488     if(U->C.A) urSupposedToGet = pow(8, log(3+U->C.A->totalD/16));
11489
11490     double oopsIsRight;
11491
11492     if(U->C.A->melee) oopsIsRight = U->C.S_C.MEL;
11493     else oopsIsRight = U->C.S_C.MIS;
11494     bool lolflag = false;
11495     if(U->C.A->D){
11496     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;
11497     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;
11498     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;
11499     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;
11500
11501     if(U->C.A->D->type == 4){
11502         lolflag = true;
11503         dmg = (U->C.S_C.CAP + U->C.A->totalD)*oopsIsRight/100;
11504
11505     }
11506     if(U->C.A->D->type == 5) dmg = U->C.A->totalD;
11507     double val2 = log(3+U2->C.S_C.MP/64);
11508         if(U->C.aura){
11509             dmg = dmg*val2;
11510         }
11511     }
11512     costMP = U->C.A->MP + floor(U->C.A->pMP*U->C.S_M.MP/100 + 0.5);
11513
11514     if(extentMPcostFlag && extentBattleFlag2){
11515
11516     }else{
11517         U->C.S_C.MP -= costMP;
11518         extentMPcostFlag = true;
11519     }
11520
11521     hit = U->C.S_C.ACU*U->C.S_C.HIT/100*U->C.S_C.HP/U->C.S_M.HP;
11522     hitFix = U->C.A->hitPercent;
11523
11524     U2A = U->C.A;
11525     U->C.A = aTop;
11526
11527     U = UTop;
11528     while (!(DUN[DUNnum] == U->number)) {
11529         U = U->next;
11530     }
11531     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;
11532     if(hit > 100) hit = 100;
11533     if(U2A->D->sort == 1){
11534         hit = 100;
11535     }
11536     if([self sortEcheck:U2A opponent:U])
11537         hit = 0;
11538
11539     healFlag = false;
11540
11541     int wtf = 100;
11542     if(battleDod2Flag) wtf = 50;
11543     if(hit - rand()%wtf > 0 && !battleDef1Flag && !battleDod1Flag){
11544
11545         if(U2A->D->sort == 0){
11546             NSLog(@"修正前のダメージ:%g", dmg);
11547             dmg = [self dmgResist:dmg];
11548             NSLog(@"属性後のダメージ:%g", dmg);
11549             def2 = pow(def2, U->CL.S_C.ARM);
11550             int omfg = rand()%100;
11551             NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, (U->CL.S_C.ARM));
11552             NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->CL.S_C.ARM), (dmg/10 + dmg - U->CL.S_C.ARM));
11553             if(lolflag) dmg = (dmg*omfg/100/10 + dmg);
11554             else dmg = (dmg*omfg/100/10 + dmg - U->CL.S_C.ARM);
11555             NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11556             if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11557             else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11558
11559             if(U->CL.S_C.typeMOVE == RIKU){
11560                 if(U2A->riku == A) dmg = dmg*1.2;
11561                 if(U2A->riku == B) dmg = dmg*1.0;
11562                 if(U2A->riku == C) dmg = dmg*0.6;
11563                 if(U2A->riku == D) dmg = dmg*0.2;
11564                 if(U2A->riku == E) dmg = 0;
11565                 if(U2A->riku == S) dmg = dmg*1.5;
11566                 if(U2A->riku == SS) dmg = dmg*2.0;
11567             } if(U->CL.S_C.typeMOVE == UMI &&
11568                  (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11569                 if(U2A->umi == A) dmg = dmg*1.2;
11570                 if(U2A->umi == B) dmg = dmg*1.0;
11571                 if(U2A->umi == C) dmg = dmg*0.6;
11572                 if(U2A->umi == D) dmg = dmg*0.2;
11573                 if(U2A->umi == E) dmg = 0;
11574                 if(U2A->umi == S) dmg = dmg*1.5;
11575                 if(U2A->umi == SS) dmg = dmg*2.0;
11576             }else if(U->CL.S_C.typeMOVE == UMI){
11577                 if(U2A->riku == A) dmg = dmg*1.2;
11578                 if(U2A->riku == B) dmg = dmg*1.0;
11579                 if(U2A->riku == C) dmg = dmg*0.6;
11580                 if(U2A->riku == D) dmg = dmg*0.2;
11581                 if(U2A->riku == E) dmg = 0;
11582                 if(U2A->riku == S) dmg = dmg*1.5;
11583                 if(U2A->riku == SS) dmg = dmg*2.0;
11584
11585             } if(U->CL.S_C.typeMOVE == CHU){
11586                 if(U2A->chu == A) dmg = dmg*1.2;
11587                 if(U2A->chu == B) dmg = dmg*1.0;
11588                 if(U2A->chu == C) dmg = dmg*0.6;
11589                 if(U2A->chu == D) dmg = dmg*0.2;
11590                 if(U2A->chu == E) dmg = 0;
11591                 if(U2A->chu == S) dmg = dmg*1.5;
11592                 if(U2A->chu == SS) dmg = dmg*2.0;
11593             } if(U->CL.S_C.typeMOVE == SORA){
11594                 if(U2A->sora == A) dmg = dmg*1.2;
11595                 if(U2A->sora == B) dmg = dmg*1.0;
11596                 if(U2A->sora == C) dmg = dmg*0.6;
11597                 if(U2A->sora == D) dmg = dmg*0.2;
11598                 if(U2A->sora == E) dmg = 0;
11599                 if(U2A->sora == S) dmg = dmg*1.5;
11600                 if(U2A->sora == SS) dmg = dmg*2.0;
11601             }
11602
11603             NSLog(@"ユニットの地形適用後:%g", dmg);
11604             if(battleDef2Flag) NSLog(@"防御後のダメージ:%g", dmg/2);
11605             graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11606
11607             grazeFlag = false;
11608             omfg = rand()%100;
11609             if(graze > omfg && !healFlag) {dmg = dmg/5;
11610                 grazeFlag = true;
11611             }
11612             if(battleDef2Flag) dmg -= dmg*0.5;
11613             battleDef2Flag = false;
11614             dmg = floor(dmg);
11615             if(dmg < 0) dmg = 0;
11616             U->CL.S_C.HP -= dmg;
11617             U->C.S_C.vigor++;
11618
11619         }else if(U2A->D->sort == 1){
11620             dmg = dmg + rand()%5*dmg/10 - rand()%5*dmg/10;
11621             dmg = floor(dmg);
11622
11623             U->C.S_C.HP += dmg;
11624             if(U->C.S_C.HP > U->C.S_M.HP) U->C.S_C.HP = U->C.S_M.HP;
11625             healFlag = true;
11626         }
11627
11628         while(1){
11629             if(U->CL.S_C.HP <= 0) {
11630                 U->CL.S_C.HP = 0;
11631                 U2->C.S_C.vigor += 5;
11632
11633                 messageProcess = 2;
11634                 if(U->dead) break;
11635                 U->dead = true;
11636
11637
11638                 if(U->targType1L)
11639                     targType1cnt[0]--;
11640                 if(U->targType2L) {
11641                     targType2cnt[0]--;
11642                     targType2Lflag = true;
11643                 }
11644
11645                 if(U->targType1D)
11646                     targType1cnt[1]--;
11647                 if(U->targType2D) {
11648                     targType2cnt[1]--;
11649                     targType2Dflag = true;
11650                 }
11651
11652                 break;
11653             }
11654             break;
11655         }
11656
11657         [tplayer2 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->CL.S_C.HP, U->CL.S_M.HP]];
11658         [lplayer2 setIntValue:U->CL.S_C.HP/U->CL.S_M.HP*100];
11659
11660         if(![U2A->msg isEqualToString:@""]){
11661
11662             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
11663                                                         [self originalMessage:U2A->msg subj:U2->C.name obje:U->CL.name]]];
11664
11665         }
11666
11667         if(grazeFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
11668         if(!healFlag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->CL.name, dmg]];
11669         else message = [message stringByAppendingString:[NSString stringWithFormat:@"%@はHPが%g回復した！", U->CL.name, dmg]];
11670     }else if(battleDef1Flag){
11671
11672
11673         U = UTop;
11674         while (!(AUN[1] == U->number)) {
11675             U = U->next;
11676         }
11677
11678
11679         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->C.name]];
11680
11681
11682     }else if(battleDod1Flag){
11683
11684         U = UTop;
11685         while (!(AUN[1] == U->number)) {
11686             U = U->next;
11687         }
11688
11689         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->C.name]];
11690
11691
11692     }else{
11693
11694         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->CL.name]];
11695
11696     }
11697     [battleDialog setStringValue:message];
11698
11699
11700     U = UTop;
11701
11702     bLoopFlag = true;
11703
11704     if(!extentBattleFlag2){
11705         if(healFlag) {
11706             messageProcess++;
11707         };
11708         messageProcess++;
11709     }else if(extentBattleFlag2){
11710         DUNnum++;
11711         messageProcess = 1;
11712         if(DUN[DUNnum] <= 0){
11713             DUNnum = 1;
11714             messageProcess++;
11715             messageProcess++;
11716             extentBattleFlag2 = false;
11717             extentbool3 = false;
11718             extentMPcostFlag = false;
11719         }
11720     }
11721     return;
11722
11723 }
11724
11725 -(void)DisplayMessageMod3B{
11726
11727
11728     double def2 = (double)31/32;
11729     NSString *message = @"";
11730
11731     enum{
11732         RIKU,
11733         UMI,
11734         CHU,
11735         SORA,
11736     };
11737
11738     enum{
11739         A,
11740         B,
11741         C,
11742         D,
11743         E,
11744         S,
11745         SS
11746     };
11747
11748
11749     if(bLoopFlag) return;
11750     U = UTop;
11751
11752     U = UTop;
11753     while (!(AUN[1] == U->number)) {
11754         U = U->next;
11755     }
11756     U2 = U;
11757
11758     U = UTop;
11759     while (!(DUN[1] == U->number)) {
11760         U = U->next;
11761     }
11762     ATTACK *aTop2 = U->CL.A;
11763     int mostDmg = 0;
11764     int mostNum = -1;
11765     int num = 0;
11766     int mpCost =0;
11767     if(U->CL.A) {
11768         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11769         costVIG = U->C.A->vigor;
11770     }
11771     while(U->CL.A){
11772         mpCost = floor(U->CL.A->EN + U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11773         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]){
11774             mostDmg = U->CL.A->totalD;
11775             mostNum = num;
11776         }
11777         U->CL.A = U->CL.A->next;
11778         num++;
11779     }
11780
11781     if(mostNum < 0) U->C.A = NULL;
11782
11783     U->CL.A = aTop2;
11784
11785     if(!battleSet2PushedFlag){
11786         for(int i = 0;i < mostNumSub;i++){
11787             U->CL.A = U->CL.A->next;
11788         }
11789
11790
11791     }else{
11792         for(int i = 0;i < crCAL2;i++){
11793             U->CL.A = U->C.A->next;
11794         }
11795     }
11796
11797     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]){
11798     }else while(U->CL.A){
11799         U->CL.A = U->CL.A->next;
11800     }
11801
11802     if(!U->CL.A){
11803         U->CL.A = aTop2;
11804         U = UTop;
11805
11806         message = [message stringByAppendingString:[NSString stringWithFormat:@"射程外\n"]];
11807         goto SKIP1;
11808     }
11809
11810     if(!battleDef2Flag && !battleDod2Flag) message = [message stringByAppendingString:[NSString stringWithFormat:@"%@の%@\n", U->CL.name, U->CL.A->name]];
11811
11812     if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag2 && ![U->CL.A->AN.movName isEqualToString:@""] && ![U->CL.A->AN.movName isEqualToString:@"(null)"] && U->CL.A->AN.movName != NULL){
11813         [[NSFileManager defaultManager] changeCurrentDirectoryPath:[[[NSBundle mainBundle] bundlePath]  stringByDeletingLastPathComponent]];
11814
11815         NSString *path = @"data/AttackList/ALdata";
11816
11817         path = [path stringByAppendingFormat:@"%dE", U->chipNumber+1];
11818
11819         path = [path stringByAppendingFormat:@"/"];
11820
11821         path = [path stringByAppendingString:U->CL.A->AN.movName];
11822
11823
11824         AVpreview = [AVPlayer playerWithURL:[NSURL fileURLWithPath:path]];
11825
11826         if(AVpreview) {
11827             AVPV.player = [AVpreview retain];
11828         }else{
11829             goto avAWESOME3B;
11830         }
11831
11832         [AVPV setControlsStyle:0];
11833         [AVPV setHidden:NO];
11834         [AVpreview play];
11835         [battleDialog setStringValue:message];
11836
11837         avPlayerFlag2 = true;
11838
11839         U->CL.A = aTop2;
11840         U = UTop;
11841         return;
11842     }else if(!battleDef1Flag && !battleDod1Flag && !avPlayerFlag1 && !animationFlag2 && U->CL.A->AN.ANI && !animationFlag3){
11843
11844
11845         animationFlag2 = true;
11846         aniFrameCnt = 0;
11847         return;
11848     }
11849
11850
11851 avAWESOME3B:{}
11852
11853
11854
11855     dmg = U->CL.A->totalD;
11856
11857     costMP = U->CL.A->EN + floor(U->CL.A->pEN*U->CL.S_M.EN/100 + 0.5);
11858     U->CL.S_C.EN -= costMP;
11859
11860     hit = U->CL.S_C.MOB + U->C.S_C.HIT;
11861     hitFix = U->CL.A->hitPercent;
11862
11863     U2A = U->CL.A;
11864     U->CL.A = aTop2;
11865
11866     U = UTop;
11867     while (!(AUN[1] == U->number)) {
11868         U = U->next;
11869     }
11870
11871     double hit2 = U->C.S_C.EVA*U->C.S_C.DOD/100*U->C.S_C.HP/U->C.S_M.HP;
11872
11873     double hi = U->C.S_C.LUK - U2->C.S_C.LUK;
11874     if(hi < 0) hi = 0;
11875
11876     hit = 60 + hit/hit2*10 - hit2/hit*10 + hitFix - log(hi/10+1)*hit2/hit*10;
11877     if(hit > 100) hit = 100;
11878
11879     if([self sortEcheck:U2A opponent:U])
11880         hit = 0;
11881
11882     battleDod1Flag = false;
11883
11884     int omg = 100;
11885     if(battleDod1Flag) omg = 50;
11886
11887     if(hit - rand()%omg > 0 && !battleDef2Flag && !battleDod2Flag){
11888         NSLog(@"修正前のダメージ:%g", dmg);
11889         dmg = [self dmgResist:dmg];
11890         NSLog(@"属性後のダメージ:%g", dmg);
11891         def2 = pow(def2, U->C.S_C.DEF);
11892         int omfg = rand()%100;
11893         NSLog(@"計算式:(%g + %g - %g)", dmg*omfg/100, dmg, U->C.S_C.DEF);
11894         NSLog(@"ダメージ幅:%g〜%g", (0 + dmg - U->C.S_C.DEF), (dmg/10 + dmg - U->C.S_C.DEF));
11895         dmg = (dmg*omfg/100/10 + dmg - U->C.S_C.DEF);
11896
11897
11898         NSLog(@"地形効果:%g - %g", dmg, dmg*MC[chipNum[possionX][possionY]].dmgfix/100);
11899         if(buildNum[possionX][possionY] < 0) dmg -= dmg*MC[chipNum[possionX][possionY]].dmgfix/100 - 0.5;
11900         else dmg -= dmg*BC[buildNum[possionX][possionY]].dmgfix/100 - 0.5;
11901
11902         if(U->C.S_C.typeMOVE == RIKU){
11903             if(U2A->riku == A) dmg = dmg*1.2;
11904             if(U2A->riku == B) dmg = dmg*1.0;
11905             if(U2A->riku == C) dmg = dmg*0.6;
11906             if(U2A->riku == D) dmg = dmg*0.2;
11907             if(U2A->riku == E) dmg = 0;
11908             if(U2A->riku == S) dmg = dmg*1.5;
11909             if(U2A->riku == SS) dmg = dmg*2.0;
11910         } if(U->C.S_C.typeMOVE == UMI &&
11911              (MC[chipNum[possionX][possionY]].type == 3 || MC[chipNum[possionX][possionY]].type == 4)){
11912             if(U2A->umi == A) dmg = dmg*1.2;
11913             if(U2A->umi == B) dmg = dmg*1.0;
11914             if(U2A->umi == C) dmg = dmg*0.6;
11915             if(U2A->umi == D) dmg = dmg*0.2;
11916             if(U2A->umi == E) dmg = 0;
11917             if(U2A->umi == S) dmg = dmg*1.5;
11918             if(U2A->umi == SS) dmg = dmg*2.0;
11919         }else if(U->C.S_C.typeMOVE == UMI){
11920             if(U2A->riku == A) dmg = dmg*1.2;
11921             if(U2A->riku == B) dmg = dmg*1.0;
11922             if(U2A->riku == C) dmg = dmg*0.6;
11923             if(U2A->riku == D) dmg = dmg*0.2;
11924             if(U2A->riku == E) dmg = 0;
11925             if(U2A->riku == S) dmg = dmg*1.5;
11926             if(U2A->riku == SS) dmg = dmg*2.0;
11927
11928         } if(U->C.S_C.typeMOVE == CHU){
11929             if(U2A->chu == A) dmg = dmg*1.2;
11930             if(U2A->chu == B) dmg = dmg*1.0;
11931             if(U2A->chu == C) dmg = dmg*0.6;
11932             if(U2A->chu == D) dmg = dmg*0.2;
11933             if(U2A->chu == E) dmg = 0;
11934             if(U2A->chu == S) dmg = dmg*1.5;
11935             if(U2A->chu == SS) dmg = dmg*2.0;
11936         } if(U->C.S_C.typeMOVE == SORA){
11937             if(U2A->sora == A) dmg = dmg*1.2;
11938             if(U2A->sora == B) dmg = dmg*1.0;
11939             if(U2A->sora == C) dmg = dmg*0.6;
11940             if(U2A->sora == D) dmg = dmg*0.2;
11941             if(U2A->sora == E) dmg = 0;
11942             if(U2A->sora == S) dmg = dmg*1.5;
11943             if(U2A->sora == SS) dmg = dmg*2.0;
11944         }
11945
11946         NSLog(@"ユニットの地形適用後:%g", dmg);
11947
11948         graze = U->C.S_C.MEN/U2->C.S_C.MEN*U->C.S_C.LUK/3;
11949
11950         grazeFlag = false;
11951         omfg = rand()&100;
11952         if(graze > omfg && !healFlag) {dmg = dmg/5;
11953             grazeFlag = true;
11954         }
11955
11956         if(battleDef1Flag) dmg -= dmg*0.5;
11957         battleDef1Flag = false;
11958         dmg = floor(dmg);
11959         if(dmg < 0) dmg = 0;
11960         U->C.S_C.HP -= dmg;
11961         U->C.S_C.vigor++;
11962
11963         while(1){
11964             if(U->C.S_C.HP <= 0) {
11965                 U->C.S_C.HP = 0;
11966                 U2->C.S_C.vigor += 5;
11967
11968                 messageProcess = 2;
11969                 if(U->dead) break;
11970                 U->dead = true;
11971
11972
11973                 if(U->targType1L)
11974                     targType1cnt[0]--;
11975                 if(U->targType2L) {
11976                     targType2cnt[0]--;
11977                     targType2Lflag = true;
11978                 }
11979
11980                 if(U->targType1D)
11981                     targType1cnt[1]--;
11982                 if(U->targType2D) {
11983                     targType2cnt[1]--;
11984                     targType2Dflag = true;
11985                 }
11986
11987                 break;
11988             }
11989             break;
11990         }
11991
11992
11993
11994         [tplayer1 setStringValue:[NSString stringWithFormat:@"HP %g/%g", U->C.S_C.HP, U->C.S_M.HP]];
11995
11996         [lplayer1 setIntValue:U->C.S_C.HP/U->C.S_M.HP*100];
11997
11998         if(![U2A->msg isEqualToString:@""]){
11999             message = [message stringByAppendingString:[NSString stringWithFormat:@"%@\n",
12000                                                         [self originalMessage:U2A->msg subj:U2->CL.name obje:U->C.name]]];
12001         }
12002
12003
12004
12005         if(grazeFlag)
12006             message = [message stringByAppendingString:[NSString stringWithFormat:@"かすりヒット！\n"]];
12007
12008         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は%gのダメージを受けた！", U->C.name, dmg]];
12009
12010     }else if(battleDef2Flag){
12011
12012
12013         U = UTop;
12014         while (!(DUN[1] == U->number)) {
12015             U = U->next;
12016         }
12017
12018
12019         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は身構えている", U->CL.name]];
12020
12021
12022     }else if(battleDod2Flag){
12023
12024         U = UTop;
12025         while (!(DUN[1] == U->number)) {
12026             U = U->next;
12027         }
12028
12029         message = [message stringByAppendingString:[NSString stringWithFormat:@"%@は様子をうかがっている", U->CL.name]];
12030
12031
12032     }else{
12033
12034         message = [message stringByAppendingString:[NSString stringWithFormat:@"ミス！%@はダメージを受けていない！", U->C.name]];
12035     }
12036 SKIP1:
12037     [battleDialog setStringValue:message];
12038
12039     U = UTop;
12040     bLoopFlag = true;
12041     messageProcess++;
12042     return;
12043
12044 }
12045
12046 -(NSString*)originalMessage:(NSString*)str subj:(NSString*)subj obje:(NSString*)obje{
12047
12048     NSString *string;
12049     NSArray *array;
12050     NSString *result = @"";
12051
12052     string = [str copy];
12053
12054     array = [string componentsSeparatedByString:@"$subj"];
12055
12056     for(int i = 0;i < [array count];i++){
12057         if(i != 0)
12058             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", subj]] retain];
12059
12060         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
12061     }
12062
12063     string = [result copy];
12064
12065     array = [string componentsSeparatedByString:@"$obje"];
12066
12067     result = @"";
12068
12069     for(int i = 0;i < [array count];i++){
12070         if(i != 0)
12071             result = [[result stringByAppendingString:[NSString stringWithFormat:@"%@", obje]] retain];
12072
12073         result = [[result stringByAppendingString:[array objectAtIndex:i]] retain];
12074     }
12075
12076     //NSLog(@"%@", result);
12077
12078     return result;
12079 }
12080
12081
12082
12083 -(double)dmgResist:(double)DMG{
12084
12085     int sd[22];
12086
12087     sd[0] = U->C.R_C.blow + U->C.R_F.blow;
12088     sd[1] = U->C.R_C.slash + U->C.R_F.slash;
12089     sd[2] = U->C.R_C.stub + U->C.R_F.stub;
12090     sd[3] = U->C.R_C.arrow + U->C.R_F.arrow;
12091     sd[4] = U->C.R_C.gun + U->C.R_F.gun;
12092     sd[5] = U->C.R_C.shell + U->C.R_F.shell;
12093
12094     sd[6] = U->C.R_C.flame + U->C.R_F.flame;
12095     sd[7] = U->C.R_C.cold + U->C.R_F.cold;
12096     sd[8] = U->C.R_C.electoric + U->C.R_F.electoric;
12097     sd[9] = U->C.R_C.air + U->C.R_F.air;
12098     sd[10] = U->C.R_C.water + U->C.R_F.water;
12099     sd[11] = U->C.R_C.gas + U->C.R_F.gas;
12100     sd[12] = U->C.R_C.holy + U->C.R_F.holy;
12101     sd[13] = U->C.R_C.dark + U->C.R_F.dark;
12102     sd[14] = U->C.R_C.explosion + U->C.R_F.explosion;
12103     sd[15] = U->C.R_C.blood + U->C.R_F.blood;
12104
12105     sd[16] = U->C.R_C.paralysis + U->C.R_F.paralysis;
12106     sd[17] = U->C.R_C.confusion + U->C.R_F.confusion;
12107     sd[18] = U->C.R_C.poison + U->C.R_F.poison;
12108     sd[19] = U->C.R_C.sleep + U->C.R_F.sleep;
12109     sd[20] = U->C.R_C.charm + U->C.R_F.charm;
12110     sd[21] = U->C.R_C.silent + U->C.R_F.silent;
12111
12112
12113
12114     for(int i = 0;i <= 21;i++)
12115         sd[i] &= ~(sd[i] >> 31);
12116
12117     if(U2A->D){
12118
12119     if(U2A->D->seed == 0) DMG = DMG * sd[0]/100;
12120     if(U2A->D->seed == 1) DMG = DMG * sd[1]/100;
12121     if(U2A->D->seed == 2) DMG = DMG * sd[2]/100;
12122     if(U2A->D->seed == 3) DMG = DMG * sd[3]/100;
12123     if(U2A->D->seed == 4) DMG = DMG * sd[4]/100;
12124     if(U2A->D->seed == 5) DMG = DMG * sd[5]/100;
12125
12126     if(U2A->D->seed == 6) DMG = DMG * sd[6]/100;
12127     if(U2A->D->seed == 7) DMG = DMG * sd[7]/100;
12128     if(U2A->D->seed == 8) DMG = DMG * sd[8]/100;
12129     if(U2A->D->seed == 9) DMG = DMG * sd[9]/100;
12130     if(U2A->D->seed == 10) DMG = DMG * sd[10]/100;
12131     if(U2A->D->seed == 11) DMG = DMG * sd[11]/100;
12132     if(U2A->D->seed == 12) DMG = DMG * sd[12]/100;
12133     if(U2A->D->seed == 13) DMG = DMG * sd[13]/100;
12134     if(U2A->D->seed == 14) DMG = DMG * sd[14]/100;
12135     if(U2A->D->seed == 15) DMG = DMG * sd[15]/100;
12136
12137     if(U2A->D->seed == 16) DMG = DMG * sd[16]/100;
12138     if(U2A->D->seed == 17) DMG = DMG * sd[17]/100;
12139     if(U2A->D->seed == 18) DMG = DMG * sd[18]/100;
12140     if(U2A->D->seed == 19) DMG = DMG * sd[19]/100;
12141     if(U2A->D->seed == 20) DMG = DMG * sd[20]/100;
12142     if(U2A->D->seed == 21) DMG = DMG * sd[21]/100;
12143     }
12144     return DMG;
12145 }
12146
12147 -(IBAction)battleStart:(id)sender{
12148     battleSetUp = true;
12149     battleSet1Flag = false;
12150     battleSet2Flag = false;
12151     battleSettingFlag = false;
12152
12153     attackingWait = false;
12154     crapBugFixFlag = true;
12155
12156     [battlePanel close];
12157 }
12158
12159
12160 -(void)battleStartCPU{
12161     battleSetUp = true;
12162     battleSet1Flag = false;
12163     battleSet2Flag = false;
12164     battleSettingFlag = false;
12165
12166     crapBugFixFlag = true;
12167
12168     [battlePanel close];
12169 }
12170
12171 -(IBAction)battleSet1:(id)sender{
12172     battleSetFlag = false;
12173     battleSet1Flag = true;
12174     battleDef1Flag = false;
12175     battleDod1Flag = false;
12176     battleSettingFlag = true;
12177     battleSet2PushedFlag = false;
12178
12179     U = UTop;
12180     while (!(AUN[1] == U->number)) {
12181         U = U->next;
12182     }
12183     if(U->chipNumberL >= 0)
12184     {
12185         U = UTop;
12186         [self initCAttackList2];
12187         [self initCAttackSelect2];
12188     }
12189     else if(U->chipNumber >= 0) {
12190         U = UTop;
12191         [self initCAttackList];
12192         [self initCAttackSelect];
12193     }
12194     U = UTop;
12195
12196     [atkPanel makeKeyAndOrderFront:nil];
12197 }
12198 -(IBAction)battleDef1:(id)sender{
12199     battleDef1Flag = true;
12200     battleSet1Flag = false;
12201     battleDod1Flag = false;
12202 }
12203 -(IBAction)battleDod1:(id)sender{
12204     battleDod1Flag = true;
12205     battleDef1Flag = false;
12206     battleSet1Flag = false;
12207 }
12208 -(IBAction)battleSet2:(id)sender{
12209     battleSetFlag = true;
12210     battleSet2Flag = true;
12211     battleDef2Flag = false;
12212     battleDod2Flag = false;
12213     battleSettingFlag = true;
12214     battleSet2PushedFlag = true;
12215
12216     U = UTop;
12217     while (!(DUN[1] == U->number)) {
12218         U = U->next;
12219     }
12220
12221     if(U->chipNumberL >= 0){
12222         U = UTop;
12223         [self initCAttackList2];
12224         [self initCAttackSelect2];
12225     }
12226     else if(U->chipNumber >= 0) {
12227         U = UTop;
12228         [self initCAttackList];
12229         [self initCAttackSelect];
12230     }
12231     U = UTop;
12232     [atkPanel makeKeyAndOrderFront:nil];
12233 }
12234 -(IBAction)battleDef2:(id)sender{
12235     battleDef2Flag = true;
12236     battleSet2Flag = false;
12237     battleDod2Flag = false;
12238 }
12239 -(IBAction)battleDod2:(id)sender{
12240     battleDod2Flag = true;
12241     battleDef2Flag = false;
12242     battleSet2Flag = false;
12243 }
12244
12245 -(IBAction)battleCancel:(id)sender{
12246     battleFlag = false;
12247     battleSettingFlag = false;
12248
12249     battleSet2PushedFlag = false;
12250     attackingWait = false;
12251
12252     [battlePanel close];
12253 }
12254
12255 -(IBAction)researchCancel:(id)sender{
12256     [researchPanel close];
12257 }
12258
12259 -(void)setCommandPanel{
12260
12261     menuPoint.x = [mapWindow frame].origin.x + possionLocalX*32;
12262     menuPoint.y = [mapWindow frame].origin.y + possionLocalY*32 - 180;
12263
12264
12265     if(buildSkillFlag) {
12266         cIncludeCreateFlag = true;
12267         menuPoint.y -= 20;
12268     }else cIncludeCreateFlag = false;
12269     if(summonSkillFlag) {
12270         cIncludeSummonFlag = true;
12271         menuPoint.y -= 20;
12272     }else cIncludeSummonFlag = false;
12273     int plusBtnValue = 0;
12274
12275     if(cIncludeCreateFlag && cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12276
12277         plusBtnValue = 200;
12278         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12279
12280
12281         plusBtnValue -= moveBtn.frame.size.height + 12;
12282         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12283         [[commandPanel contentView] addSubview:moveBtn];
12284
12285         plusBtnValue -= attackBtn.frame.size.height + 2;
12286         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12287         [[commandPanel contentView] addSubview:attackBtn];
12288
12289         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12290         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12291         [[commandPanel contentView] addSubview:stanbyBtn];
12292
12293         [createBtn setTransparent: NO];
12294         [createBtn setEnabled: YES];
12295         plusBtnValue -= createBtn.frame.size.height + 2;
12296         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12297         [[commandPanel contentView] addSubview:createBtn];
12298
12299         [summonBtn setTransparent: NO];
12300         [summonBtn setEnabled: YES];
12301         plusBtnValue -= summonBtn.frame.size.height + 2;
12302         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12303         [[commandPanel contentView] addSubview:summonBtn];
12304
12305         plusBtnValue -= statusBtn.frame.size.height + 2;
12306         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12307         [[commandPanel contentView] addSubview:statusBtn];
12308
12309         plusBtnValue -= cancelBtn.frame.size.height + 2;
12310         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12311         [[commandPanel contentView] addSubview:cancelBtn];
12312
12313     }
12314     else if(cIncludeCreateFlag && !cIncludeSummonFlag && MF[MFselectedRow+1].MS.buildAllowedFlag){
12315         plusBtnValue = 180;
12316         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12317
12318         plusBtnValue -= moveBtn.frame.size.height + 12;
12319         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12320         [[commandPanel contentView] addSubview:moveBtn];
12321
12322         plusBtnValue -= attackBtn.frame.size.height + 2;
12323         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12324         [[commandPanel contentView] addSubview:attackBtn];
12325
12326         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12327         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12328         [[commandPanel contentView] addSubview:stanbyBtn];
12329
12330         [createBtn setTransparent: NO];
12331         [createBtn setEnabled: YES];
12332         plusBtnValue -= createBtn.frame.size.height + 2;
12333         [createBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12334         [[commandPanel contentView] addSubview:createBtn];
12335
12336         [summonBtn setTransparent: YES];
12337         [summonBtn setEnabled: NO];
12338
12339         plusBtnValue -= statusBtn.frame.size.height + 2;
12340         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12341         [[commandPanel contentView] addSubview:statusBtn];
12342
12343         plusBtnValue -= cancelBtn.frame.size.height + 2;
12344         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12345         [[commandPanel contentView] addSubview:cancelBtn];
12346
12347
12348     }else if(cIncludeSummonFlag && !cIncludeCreateFlag && MF[MFselectedRow+1].MS.summonAllowedFlag){
12349
12350         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, 210) display:YES];
12351
12352         plusBtnValue = 180;
12353         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12354
12355
12356         plusBtnValue -= moveBtn.frame.size.height + 12;
12357         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12358         [[commandPanel contentView] addSubview:moveBtn];
12359
12360         plusBtnValue -= attackBtn.frame.size.height + 2;
12361         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12362         [[commandPanel contentView] addSubview:attackBtn];
12363
12364         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12365         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12366         [[commandPanel contentView] addSubview:stanbyBtn];
12367
12368         [createBtn setTransparent: YES];
12369         [createBtn setEnabled: NO];
12370
12371         [summonBtn setTransparent: NO];
12372         [summonBtn setEnabled: YES];
12373         plusBtnValue -= summonBtn.frame.size.height + 2;
12374         [summonBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12375         [[commandPanel contentView] addSubview:summonBtn];
12376
12377         plusBtnValue -= statusBtn.frame.size.height + 2;
12378         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12379         [[commandPanel contentView] addSubview:statusBtn];
12380
12381         plusBtnValue -= cancelBtn.frame.size.height + 2;
12382         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12383         [[commandPanel contentView] addSubview:cancelBtn];
12384     }else{
12385
12386         plusBtnValue = 160;
12387         [commandPanel setFrame:NSMakeRect(menuPoint.x, menuPoint.y, 150, plusBtnValue) display:YES];
12388
12389         plusBtnValue -= moveBtn.frame.size.height + 12;
12390         [moveBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12391         [[commandPanel contentView] addSubview:moveBtn];
12392
12393         plusBtnValue -= attackBtn.frame.size.height + 2;
12394         [attackBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12395         [[commandPanel contentView] addSubview:attackBtn];
12396
12397         plusBtnValue -= stanbyBtn.frame.size.height + 2;
12398         [stanbyBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12399         [[commandPanel contentView] addSubview:stanbyBtn];
12400
12401         [createBtn setTransparent: YES];
12402         [createBtn setEnabled: NO];
12403
12404         [summonBtn setTransparent: YES];
12405         [summonBtn setEnabled: NO];
12406
12407         plusBtnValue -= statusBtn.frame.size.height + 2;
12408         [statusBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12409         [[commandPanel contentView] addSubview:statusBtn];
12410
12411         plusBtnValue -= cancelBtn.frame.size.height + 2;
12412         [cancelBtn setFrame:NSMakeRect(25, plusBtnValue, 100, 23)];
12413         [[commandPanel contentView] addSubview:cancelBtn];
12414     }
12415
12416
12417 }
12418
12419 -(void)openMessage{
12420     [IVimage setHidden:NO];
12421     [TFname setHidden:NO];
12422     [TFmessage setHidden:NO];
12423     [BXname setHidden:NO];
12424     [BXmessage setHidden:NO];
12425     [IVimage setEnabled:YES];
12426     [TFname setEnabled:YES];
12427     [TFmessage setEnabled:YES];
12428 }
12429
12430 -(void)closeMessage{
12431     [IVimage setHidden:YES];
12432     [TFname setHidden:YES];
12433     [TFmessage setHidden:YES];
12434     [BXname setHidden:YES];
12435     [BXmessage setHidden:YES];
12436     [IVimage setEnabled:NO];
12437     [TFname setEnabled:NO];
12438     [TFmessage setEnabled:NO];
12439 }
12440
12441 -(MAPSCRIPT0*)setMessage:(MAPSCRIPT0*)MS0{
12442
12443
12444     if(!messageDialog){
12445         [self closeMessage];
12446         damnitFixFlag = true;
12447     }else if(MS0->S1.str){
12448         [self openMessage];
12449         damnitFixFlag = false;
12450     NSString *string = @"";
12451
12452         string = [MS0->S1.str retain];
12453         if(!string){
12454             MS0->endFlag = true;
12455             textInstantBugFixFlag = false;
12456             messageEndFlag = false;
12457             messageDialog = false;
12458             return MS0;
12459         }
12460
12461         if(!initStringNum){
12462             msgLvl = 0;
12463             msgCnt = 0;
12464             initStringNum = true;
12465             textInstantBugFixFlag = true;
12466         }
12467
12468         msgMax = (int)[string length];
12469
12470
12471         if(!initImgFlag)
12472         {
12473             [self loadImg];
12474             initImgFlag = true;
12475         }
12476
12477         [IVimage setImage:MS0->S1.img];
12478         if(MS0->S1.name) [TFname setStringValue:MS0->S1.name];
12479         else [TFname setStringValue:@""];
12480
12481         if(msgCnt <= msgMax){
12482             if(string) {
12483                 [TFmessage setStringValue:[string substringToIndex:msgCnt]];
12484                 msgCnt++;
12485             }
12486             else [TFmessage setStringValue:@""];
12487         }
12488         wtRdy3 = true;
12489
12490
12491         if(messageEndFlag){
12492             MS0->endFlag = true;
12493             messageEndFlag = false;
12494             initStringNum = false;
12495             messageDialog = false;
12496             MS0->succeessfulFlag = true;
12497             wtRdy3 = false;
12498             textInstantBugFixFlag = false;
12499             [self setMessage:NULL];
12500         }
12501
12502         return MS0;
12503     }else{
12504         MS0->endFlag = true;
12505         messageEndFlag = false;
12506         messageDialog = false;
12507         initStringNum = false;
12508     }
12509
12510
12511     return MS0;
12512 }
12513
12514 -(void) loadImg{
12515
12516     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
12517     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
12518
12519     NSString *path = @"Map/";
12520     NSString *fileData = nil;
12521     NSArray *fileDataArray;
12522
12523     path = [path stringByAppendingFormat:@"%@"  ,MF[MFselectedRow+1].fileName];
12524
12525     fileData = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:nil];
12526
12527     fileDataArray = [fileData componentsSeparatedByString:@"\n"];
12528
12529     MAPSCRIPT0 *MS00 = MF[MFselectedRow+1].MS.D->P;
12530     MAPSCRIPT0 *m00Top = MS00;
12531     for (int i = 0; i < [fileDataArray count]; i++) {
12532         if(!MS00) break;
12533         NSRange range = [[fileDataArray objectAtIndex:i] rangeOfString:@"◆"];
12534         if(range.location != NSNotFound){
12535
12536             NSArray *array2 = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
12537             if(MS00->type == 1)
12538             {
12539                 MS00->S1.iName = [[array2 objectAtIndex:2] retain];
12540
12541             for(int k = 0; k < UCN;k++){
12542
12543                 if([MS00->S1.iName isEqualToString:UC[k].nameClass]){
12544                     MS00->S1.img = [UC[k].imgb retain];
12545                     MS00 = MS00->next;
12546                     break;
12547                 }
12548
12549             }
12550             }
12551
12552         }
12553     }
12554
12555     MS00 = m00Top;
12556
12557 }
12558
12559
12560 -(MAPSCRIPT0*)setSwitch:(MAPSCRIPT0*)MS0{
12561
12562     if(MS0->switch1)
12563     for(int i = 0;*(MS0->switch1 + i) >0;i++){
12564         Suicchi[*(MS0->switch1+i)] = true;
12565
12566     }
12567     if(MS0->switch2)
12568     for(int i = 0;*(MS0->switch2 + i) >0;i++){
12569         Suicchi[*(MS0->switch2+i)] = false;
12570
12571     }
12572
12573     MS0->succeessfulFlag = true;
12574     MS0->endFlag = true;
12575     return MS0;
12576 }
12577
12578 -(MAPSCRIPT0*)setBranch:(MAPSCRIPT0*)MS0{
12579
12580     MAPSCRIPT0 *CRMS0 = MS0;
12581     bool branchEndFlag = false;
12582     bool branchSuceedFlag = false;
12583     bool trueFlag = true;
12584
12585
12586     if(MS0->endFlag)
12587         return MS0;
12588
12589     /*
12590     if(!Uselected){
12591         MS0->endFlag = true;
12592         return MS0;
12593     }*/
12594
12595     if(1){
12596
12597         if(MS0->S4.suicchiFlag){
12598             if(MS0->S4.suicchiONOFF == 0){
12599                 if(MS0->S4.suicchi)
12600                 for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12601                     if(!Suicchi[*(MS0->S4.suicchi + i)]){
12602                         trueFlag = false;
12603                     }
12604                 }
12605             }else{
12606                 if(MS0->S4.suicchi)
12607                     for (int i = 0;*(MS0->S4.suicchi + i);i++) {
12608                         if(Suicchi[*(MS0->S4.suicchi + i)]){
12609                             trueFlag = false;
12610                         }
12611                     }
12612             }
12613         }
12614
12615         if(MS0->S4.hensuFlag){
12616
12617             if(MS0->S4.teisuFlag){
12618                 if(MS0->S4.hensuType == 0){
12619                     if([Hensuu[MS0->S4.hensu1] intValue] == MS0->S4.teisuValue){
12620
12621                     }else{
12622                         trueFlag = false;
12623                     }
12624                 }else if(MS0->S4.hensuType == 1){
12625                     if([Hensuu[MS0->S4.hensu1] intValue] >= MS0->S4.teisuValue){
12626
12627                     }else{
12628                         trueFlag = false;
12629                     }
12630                 }else if(MS0->S4.hensuType == 2){
12631                     if([Hensuu[MS0->S4.hensu1] intValue] <= MS0->S4.teisuValue){
12632
12633                     }else{
12634                         trueFlag = false;
12635                     }
12636                 }else if(MS0->S4.hensuType == 3){
12637                     if([Hensuu[MS0->S4.hensu1] intValue] > MS0->S4.teisuValue){
12638
12639                     }else{
12640                         trueFlag = false;
12641                     }
12642                 }else if(MS0->S4.hensuType == 4){
12643                     if([Hensuu[MS0->S4.hensu1] intValue] < MS0->S4.teisuValue){
12644
12645                     }else{
12646                         trueFlag = false;
12647                     }
12648                 }else if(MS0->S4.hensuType == 5){
12649                     if([Hensuu[MS0->S4.hensu1] intValue] != MS0->S4.teisuValue){
12650
12651                     }else{
12652                         trueFlag = false;
12653                     }
12654                 }
12655
12656             }if(MS0->S4.hensu2flag){
12657                 if(MS0->S4.hensuType == 0){
12658                     if([Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12659
12660                     }else{
12661                         trueFlag = false;
12662                     }
12663                 }else if(MS0->S4.hensuType == 1){
12664                     if([Hensuu[MS0->S4.hensu1] intValue] >= [Hensuu[MS0->S4.hensu2] intValue]){
12665
12666                     }else{
12667                         trueFlag = false;
12668                     }
12669                 }else if(MS0->S4.hensuType == 2){
12670                     if([Hensuu[MS0->S4.hensu1] intValue] <= [Hensuu[MS0->S4.hensu2] intValue]){
12671
12672                     }else{
12673                         trueFlag = false;
12674                     }
12675                 }else if(MS0->S4.hensuType == 3){
12676                     if([Hensuu[MS0->S4.hensu1] intValue] > [Hensuu[MS0->S4.hensu2] intValue]){
12677
12678                     }else{
12679                         trueFlag = false;
12680                     }
12681                 }else if(MS0->S4.hensuType == 4){
12682                     if([Hensuu[MS0->S4.hensu1] intValue] < [Hensuu[MS0->S4.hensu2] intValue]){
12683
12684                     }else{
12685                         trueFlag = false;
12686                     }
12687                 }else if(MS0->S4.hensuType == 5){
12688                     if(![Hensuu[MS0->S4.hensu1] isEqualToString:Hensuu[MS0->S4.hensu2]]){
12689
12690                     }else{
12691                         trueFlag = false;
12692                     }
12693                 }
12694             }
12695
12696         }
12697         if(MS0->S4.timerFlag){
12698
12699             if(MS0->S4.timerType == 0){
12700                 if(MS0->S4.timerMin <= cntTimerMin){
12701
12702                 }else if(MS0->S4.timerSec <= cntTimerSec && MS0->S4.timerMin <= cntTimerMin){
12703
12704                 }else{
12705                     trueFlag = false;
12706                 }
12707
12708
12709
12710             }else{
12711                 if(MS0->S4.timerMin >= cntTimerMin){
12712
12713                 }else if(MS0->S4.timerSec >= cntTimerSec && MS0->S4.timerMin >= cntTimerMin){
12714
12715                 }else{
12716                     trueFlag = false;
12717                 }
12718
12719             }
12720         }
12721
12722
12723
12724         if(MS0->S4.unitNumFlag){
12725
12726
12727             int Unum = 0;
12728             U = UTop;;
12729             while (U) {
12730                 Unum++;
12731                 U = U->next;
12732             }U = UTop;
12733
12734             int objeSCSunitCnt = 0;
12735
12736             if(MS0->S4.objeFlag){
12737
12738                 UNIT2 *objeT = MS0->S4.obje;
12739
12740                 while (MS0->S4.obje) {
12741
12742
12743
12744                     U = UTop;
12745                     static bool okflag = true;
12746                     while(U){
12747                         for (int i = 0;i < 1002;i++) {
12748                             for (int k = 0;k < 1002;k++) {
12749                                 objeR[i][k] = 0;
12750                             }
12751                         }
12752
12753                         U2 = UTop;
12754                         while(U2){
12755                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
12756                                 break;
12757                             }
12758                             U2 = U2->next;
12759                         }
12760
12761                         if(!U2){
12762                             U2 = UTop;
12763                             break;
12764                         }
12765
12766                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
12767
12768                         int Cnum = 0;
12769
12770                         for(int bx=1;bx<=chipWidth;bx++){
12771                             for(int by=1;by<=chipHeight;by++){
12772                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
12773
12774                                     if(objeR[U->x][U->y] > 0){
12775                                         Cnum++;
12776                                         if(Unum < Cnum) goto omfgUnitOver2;
12777
12778
12779
12780
12781
12782                                         if(UP)
12783                                         {
12784                                             if(!UPT){
12785                                                 UPT = UP;
12786                                             }
12787
12788                                             UP = UPT;
12789                                             while (UP) {
12790                                                 if(UP->x == U->x && UP->y == U->y){
12791
12792                                                     break;
12793                                                 }else{
12794                                                     okflag = true;
12795                                                 }
12796
12797                                                 UP = UP->next;
12798                                             }
12799
12800                                         }
12801                                         UP = UPT;
12802
12803                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
12804                                         else if(UP){
12805                                             while(UP->next) UP = UP->next;
12806                                         }
12807                                         if(okflag){
12808                                             UP->x = U->x;
12809                                             UP->y = U->y;
12810                                             UP->next = calloc(1, sizeof(UNITPOINT));
12811                                             okflag = false;
12812                                             objeSCSunitCnt++;
12813                                         }
12814                                     }
12815
12816                                 }
12817                             }
12818                         }
12819
12820                     omfgUnitOver2:
12821                         UP = NULL;
12822                         UPT = NULL;
12823
12824                         //NSLog(@"%@, %d, %d", U->C.name, objeSCSunitCnt, objeR[0][0]);
12825
12826                         U = U->next;
12827                     }U = UTop;
12828                     okflag = true;
12829                     MS0->S4.obje = MS0->S4.obje->next;
12830                 }
12831                 MS0->S4.obje = objeT;
12832             }
12833
12834             /*
12835             if(MS0->S4.buildFlag){
12836                 if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12837
12838                 }
12839
12840                 if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
12841                    BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
12842                    Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
12843
12844                 }
12845             }
12846             */
12847
12848             int team0num = 0;
12849             int team1num = 0;
12850             int team2num = 0;
12851             if(MS0->S4.team == 0){
12852                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12853                 U = UTop;
12854                 while (U) {
12855                     if(U->team == 0 && !U->dead)
12856                         team0num++;
12857                     U = U->next;
12858                 }U = UTop;
12859                 }
12860                 if(MS0->S4.unitType == 0){
12861                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
12862
12863                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12864
12865                     }else if((MS0->S4.unitNum == team0num) && !MS0->S4.objeFlag){
12866
12867                     }else{
12868                         trueFlag = false;
12869                     }
12870                 }else if(MS0->S4.unitType == 1){
12871                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team0num = 65000;
12872
12873                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12874
12875                     }else if((MS0->S4.unitNum <= team0num) && !MS0->S4.objeFlag){
12876
12877                     }else{
12878                         trueFlag = false;
12879                     }
12880                 }else if(MS0->S4.unitType == 2){
12881                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12882
12883                     }else if((MS0->S4.unitNum >= team0num) && !MS0->S4.objeFlag){
12884
12885                     }else{
12886                         trueFlag = false;
12887                     }
12888                 }
12889
12890
12891             }else if(MS0->S4.team == 1){
12892                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12893                 U = UTop;
12894                 while (U) {
12895                     if(U->team == 1 && !U->dead)
12896                         team1num++;
12897                     U = U->next;
12898                 }U = UTop;
12899                 }
12900                 if(MS0->S4.unitType == 0){
12901                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
12902
12903                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12904
12905                     }else if((MS0->S4.unitNum == team1num) && !MS0->S4.objeFlag){
12906
12907                     }else{
12908                         trueFlag = false;
12909                     }
12910                 }else if(MS0->S4.unitType == 1){
12911                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team1num = 65000;
12912                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12913
12914                     }else if((MS0->S4.unitNum <= team1num) && !MS0->S4.objeFlag){
12915
12916                     }else{
12917                         trueFlag = false;
12918                     }
12919                 }else if(MS0->S4.unitType == 2){
12920
12921                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12922
12923                     }else if((MS0->S4.unitNum >= team1num) && !MS0->S4.objeFlag){
12924
12925                     }else{
12926                         trueFlag = false;
12927                     }
12928                 }
12929             }else if(MS0->S4.team == 2){
12930                 if(!MS0->S4.objeFlag && !MS0->S4.placeFlag){
12931                 U = UTop;
12932                 while (U) {
12933                     if(U->team == 2 && !U->dead)
12934                         team2num++;
12935                     U = U->next;
12936                 }U = UTop;
12937                 }
12938                 if(MS0->S4.unitType == 0){
12939                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
12940
12941                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == objeSCSunitCnt)){
12942
12943                     }else if((MS0->S4.unitNum == team2num) && !MS0->S4.objeFlag){
12944
12945                     }else{
12946                         trueFlag = false;
12947                     }
12948                 }else if(MS0->S4.unitType == 1){
12949                     if(MS0->S4.objeFlag || MS0->S4.placeFlag) team2num = 65000;
12950
12951                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= objeSCSunitCnt)){
12952
12953                     }else if((MS0->S4.unitNum <= team2num) && !MS0->S4.objeFlag){
12954
12955                     }else{
12956                         trueFlag = false;
12957                     }
12958                 }else if(MS0->S4.unitType == 2){
12959                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= objeSCSunitCnt)){
12960
12961                     }else if((MS0->S4.unitNum >= team2num) && !MS0->S4.objeFlag){
12962
12963                     }else{
12964                         trueFlag = false;
12965                     }
12966                 }
12967             }
12968
12969         }
12970
12971
12972
12973         if(MS0->S4.unitTypeFlag && MS0->S4.unitNumFlag){
12974             UNIT2 *sjt = MS0->S4.subj;
12975             UNIT *chosen = NULL;
12976             UNIT *chosenT = NULL;
12977             int cntUnit = 0;
12978             bool lmao = false;
12979             while(MS0->S4.subj){
12980                 U = UTop;
12981                 while(U){
12982                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
12983                         if(chosen){
12984                             chosen->next = calloc(1, sizeof(UNIT));
12985                             if(!lmao){
12986                                 chosenT = chosen;
12987                                 lmao = true;
12988                             }
12989                             chosen = chosen->next;
12990                         }
12991                         if(!chosen){
12992                             chosen = calloc(1, sizeof(UNIT));
12993                         }
12994                         chosen->x = U->x;
12995                         chosen->y = U->y;
12996                         chosen->C.name = U->C.name;
12997
12998                         if(!U->dead)
12999                             cntUnit++;
13000                     }
13001                     U = U->next;
13002                 }U = UTop;
13003                 if(!lmao){
13004                     chosenT = chosen;
13005                     lmao = true;
13006                 }
13007                 MS0->S4.subj = MS0->S4.subj->next;
13008             }MS0->S4.subj = sjt;
13009             chosen = chosenT;
13010
13011             int objeSCSunitCnt = 0;
13012
13013
13014             int Unum = 0;
13015
13016
13017             while (chosen) {
13018                 Unum++;
13019                 chosen = chosen->next;
13020             }chosen = chosenT;
13021
13022             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
13023
13024                 UNIT2 *objeT = MS0->S4.obje;
13025
13026                 while (MS0->S4.obje) {
13027
13028
13029
13030                     chosen = chosenT;
13031                     static bool okflag = true;
13032                     while(chosen){
13033                         for (int i = 0;i < 1002;i++) {
13034                             for (int k = 0;k < 1002;k++) {
13035                                 objeR[i][k] = 0;
13036                             }
13037                         }
13038
13039                         U2 = UTop;
13040                         while(U2){
13041                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13042                                 break;
13043                             }
13044                             U2 = U2->next;
13045                         }
13046
13047                         if(!U2){
13048                             U2 = UTop;
13049                             break;
13050                         }
13051
13052
13053                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
13054
13055                         int Cnum = 0;
13056
13057                         for(int bx=1;bx<=chipWidth;bx++){
13058                             for(int by=1;by<=chipHeight;by++){
13059                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13060
13061                                     if(objeR[chosen->x][chosen->y] > 0){
13062                                         Cnum++;
13063                                         if(Unum < Cnum) goto omfgUnitOver3;
13064
13065
13066
13067
13068
13069                                         if(UP)
13070                                         {
13071                                             if(!UPT){
13072                                                 UPT = UP;
13073                                             }
13074
13075                                             UP = UPT;
13076                                             while (UP) {
13077                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13078
13079                                                     break;
13080                                                 }else{
13081                                                     okflag = true;
13082                                                 }
13083
13084                                                 UP = UP->next;
13085                                             }
13086
13087                                         }
13088                                         UP = UPT;
13089
13090                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13091                                         else if(UP){
13092                                             while(UP->next) UP = UP->next;
13093                                         }
13094                                         if(okflag){
13095                                             UP->x = chosen->x;
13096                                             UP->y = chosen->y;
13097                                             UP->next = calloc(1, sizeof(UNITPOINT));
13098                                             okflag = false;
13099                                             objeSCSunitCnt++;
13100                                         }
13101                                     }
13102
13103                                 }
13104                             }
13105                         }
13106
13107                     omfgUnitOver3:
13108                         UP = NULL;
13109                         UPT = NULL;
13110
13111                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13112
13113                         chosen = chosen->next;
13114                     }chosen = chosenT;
13115                     okflag = true;
13116                     MS0->S4.obje = MS0->S4.obje->next;
13117                 }
13118                 MS0->S4.obje = objeT;
13119             }else if(MS0->S4.objeFlag){
13120
13121                 UNIT2 *objeT = MS0->S4.obje;
13122
13123                 while (MS0->S4.obje) {
13124
13125
13126
13127                     U = UTop;
13128                     static bool okflag = true;
13129                     while(U){
13130                         if(U->team != MS0->S4.team){
13131                             U = U->next;
13132                             continue;
13133                         }
13134                         for (int i = 0;i < 1002;i++) {
13135                             for (int k = 0;k < 1002;k++) {
13136                                 objeR[i][k] = 0;
13137                             }
13138                         }
13139
13140                         U2 = UTop;
13141                         while(U2){
13142                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13143                                 break;
13144                             }
13145                             U2 = U2->next;
13146                         }
13147
13148                         if(!U2){
13149                             U2 = UTop;
13150                             break;
13151                         }
13152
13153                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
13154
13155                         int Cnum = 0;
13156
13157                         for(int bx=1;bx<=chipWidth;bx++){
13158                             for(int by=1;by<=chipHeight;by++){
13159                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13160
13161                                     if(objeR[chosen->x][chosen->y] > 0){
13162                                         Cnum++;
13163                                         if(Unum < Cnum) goto omfgUnitOver30;
13164
13165
13166
13167
13168
13169                                         if(UP)
13170                                         {
13171                                             if(!UPT){
13172                                                 UPT = UP;
13173                                             }
13174
13175                                             UP = UPT;
13176                                             while (UP) {
13177                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13178
13179                                                     break;
13180                                                 }else{
13181                                                     okflag = true;
13182                                                 }
13183
13184                                                 UP = UP->next;
13185                                             }
13186
13187                                         }
13188                                         UP = UPT;
13189
13190                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13191                                         else if(UP){
13192                                             while(UP->next) UP = UP->next;
13193                                         }
13194                                         if(okflag){
13195                                             UP->x = chosen->x;
13196                                             UP->y = chosen->y;
13197                                             UP->next = calloc(1, sizeof(UNITPOINT));
13198                                             okflag = false;
13199                                             objeSCSunitCnt++;
13200                                         }
13201                                     }
13202
13203                                 }
13204                             }
13205                         }
13206
13207                     omfgUnitOver30:
13208                         UP = NULL;
13209                         UPT = NULL;
13210
13211                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
13212
13213                         chosen = chosen->next;
13214                     }chosen = chosenT;
13215                     okflag = true;
13216                     MS0->S4.obje = MS0->S4.obje->next;
13217                 }
13218                 MS0->S4.obje = objeT;
13219                 U = UTop;
13220             }
13221
13222
13223             int team0num = 0;
13224             int team1num = 0;
13225             int team2num = 0;
13226             if(MS0->S4.team == 0){
13227                 if(!MS0->S4.unitTypeFlag){
13228                 U = UTop;
13229                 while (U) {
13230                     if(U->team == 0 && !U->dead)
13231                         team0num++;
13232                     U = U->next;
13233                 }U = UTop;
13234                 }
13235                 if(MS0->S4.unitType == 0){
13236                     if(MS0->S4.unitTypeFlag) team0num = MS0->S4.unitNum;
13237
13238                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit)
13239                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13240
13241                     }else if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13242
13243                     }else{
13244                         trueFlag = false;
13245                     }
13246                 }else if(MS0->S4.unitType == 1){
13247                     if(MS0->S4.unitTypeFlag) team0num = 65000;
13248
13249                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit)
13250                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13251
13252                     }else if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13253
13254                     }else{
13255                         trueFlag = false;
13256                     }
13257                 }else if(MS0->S4.unitType == 2){
13258                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit)
13259                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13260
13261                     }else if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13262
13263                     }else{
13264                         trueFlag = false;
13265                     }
13266                 }
13267
13268
13269             }else if(MS0->S4.team == 1){
13270                 if(!MS0->S4.unitTypeFlag){
13271                 U = UTop;
13272                 while (U) {
13273                     if(U->team == 1 && !U->dead)
13274                         team1num++;
13275                     U = U->next;
13276                 }U = UTop;
13277                 }
13278                 if(MS0->S4.unitType == 0){
13279                     if(MS0->S4.unitTypeFlag) team1num = MS0->S4.unitNum;
13280
13281                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit)
13282                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13283
13284                     }else if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13285
13286                     }else{
13287                         trueFlag = false;
13288                     }
13289                 }else if(MS0->S4.unitType == 1){
13290                     if(MS0->S4.unitTypeFlag) team1num = 65000;
13291
13292                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit)
13293                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13294
13295                     }else if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13296
13297                     }else{
13298                         trueFlag = false;
13299                     }
13300                 }else if(MS0->S4.unitType == 2){
13301                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit)
13302                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13303
13304                     }else if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13305
13306                     }else{
13307                         trueFlag = false;
13308                     }
13309                 }
13310             }else if(MS0->S4.team == 2){
13311                 if(!MS0->S4.unitTypeFlag){
13312                 U = UTop;
13313                 while (U) {
13314                     if(U->team == 2 && !U->dead)
13315                         team2num++;
13316                     U = U->next;
13317                 }U = UTop;
13318                 }
13319                 if(MS0->S4.unitType == 0){
13320                     if(MS0->S4.unitTypeFlag) team2num = MS0->S4.unitNum;
13321
13322                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit)
13323                        && (MS0->S4.unitNum == objeSCSunitCnt)){
13324
13325                     }else if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == cntUnit) && !MS0->S4.objeFlag){
13326
13327                     }else{
13328                         trueFlag = false;
13329                     }
13330                 }else if(MS0->S4.unitType == 1){
13331                     if(MS0->S4.unitTypeFlag) team2num = 65000;
13332
13333                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit)
13334                        && (MS0->S4.unitNum <= objeSCSunitCnt)){
13335
13336                     }else if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= cntUnit) && !MS0->S4.objeFlag){
13337
13338                     }else{
13339                         trueFlag = false;
13340                     }
13341                 }else if(MS0->S4.unitType == 2){
13342                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit)
13343                        && (MS0->S4.unitNum >= objeSCSunitCnt)){
13344
13345                     }else if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= cntUnit) && !MS0->S4.objeFlag){
13346
13347                     }else{
13348                         trueFlag = false;
13349                     }
13350                 }
13351             }
13352
13353
13354
13355
13356
13357
13358         }
13359
13360
13361
13362
13363         if(MS0->S4.placeFlag && MS0->S4.unitNumFlag){
13364             int Unum = 0;
13365             U = UTop;;
13366             while (U) {
13367                 Unum++;
13368                 U = U->next;
13369             }U = UTop;
13370
13371
13372
13373             UNIT2 *sjt = MS0->S4.subj;
13374             UNIT *chosen = NULL;
13375             UNIT *chosenT = NULL;
13376             int cntUnit = 0;
13377             bool lmao = false;
13378             if(MS0->S4.unitTypeFlag){
13379                 while(MS0->S4.subj){
13380                     U = UTop;
13381                     while(U){
13382                         if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13383                             if(chosen){
13384                                 chosen->next = calloc(1, sizeof(UNIT));
13385                                 if(!lmao){
13386                                     chosenT = chosen;
13387                                     lmao = true;
13388                                 }
13389                                 chosen = chosen->next;
13390                             }
13391                             if(!chosen){
13392                                 chosen = calloc(1, sizeof(UNIT));
13393                             }
13394                             chosen->x = U->x;
13395                             chosen->y = U->y;
13396                             chosen->C.name = U->C.name;
13397
13398                             if(!U->dead)
13399                                 cntUnit++;
13400                         }
13401                         U = U->next;
13402                     }U = UTop;
13403                     if(!lmao){
13404                         chosenT = chosen;
13405                         lmao = true;
13406                     }
13407                     MS0->S4.subj = MS0->S4.subj->next;
13408                 }MS0->S4.subj = sjt;
13409                 chosen = chosenT;
13410
13411
13412
13413                 Unum = 0;
13414                 while (chosen) {
13415                     Unum++;
13416                     chosen = chosen->next;
13417                 }chosen = chosenT;
13418
13419             }
13420
13421
13422                 PLACEMENT *wpt = MS0->S4.wayp;
13423                 int waypCnt = 0;
13424                 int waypSCScnt = 0;
13425                 bool waypSCS = false;
13426                 int waypSCSunitCnt = 0;
13427
13428
13429             if(!MS0->S4.unitTypeFlag){
13430
13431             while (MS0->S4.wayp) {
13432                     waypCnt++;
13433
13434
13435
13436
13437                     if(MS0->S4.wayp->type == 0){
13438                     U = UTop;
13439                     while(U){
13440                         if(U->team != MS0->S4.team){
13441                             U = U->next;
13442                             continue;
13443                         }
13444                         if(MS0->S4.wayp->x == U->x && MS0->S4.wayp->y == U->y){
13445                             waypSCScnt++;
13446                             waypSCSunitCnt++;
13447                             break;
13448                         }
13449                         U = U->next;
13450                     }U = UTop;
13451
13452                     }else if(MS0->S4.wayp->type == 1){
13453                         U = UTop;
13454                         static bool okflag = true;
13455                         while(U){
13456                             if(U->team != MS0->S4.team){
13457                                 U = U->next;
13458                                 continue;
13459                             }
13460                             for (int i = 0;i < 1002;i++) {
13461                                 for (int k = 0;k < 1002;k++) {
13462                                     waypR[i][k] = 0;
13463                                 }
13464                             }
13465                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:U scsCnt:&waypSCSunitCnt];
13466
13467                             int Cnum = 0;
13468
13469                             for(int bx=1;bx<=chipWidth;bx++){
13470                                 for(int by=1;by<=chipHeight;by++){
13471                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13472
13473                                         if(waypR[U->x][U->y] > 0){
13474                                             Cnum++;
13475                                             if(Unum < Cnum) goto omfgUnitOver;
13476
13477
13478
13479
13480
13481                                             if(UP)
13482                                             {
13483                                                 if(!UPT){
13484                                                     UPT = UP;
13485                                                 }
13486
13487                                                 UP = UPT;
13488                                                 while (UP) {
13489                                                     if(UP->x == U->x && UP->y == U->y){
13490
13491                                                         break;
13492                                                     }else{
13493                                                         okflag = true;
13494                                                     }
13495
13496                                                     UP = UP->next;
13497                                                 }
13498
13499                                             }
13500                                             UP = UPT;
13501
13502                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13503                                             else if(UP){
13504                                                 while(UP->next) UP = UP->next;
13505                                             }
13506                                             if(okflag){
13507                                                 UP->x = U->x;
13508                                                 UP->y = U->y;
13509                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13510                                                 okflag = false;
13511                                                 waypSCSunitCnt++;
13512                                             }
13513                                         }
13514
13515                                     }
13516                                 }
13517                             }
13518
13519                         omfgUnitOver:
13520                             UP = NULL;
13521                             UPT = NULL;
13522                    //         NSLog(@"%d", waypSCSunitCnt);
13523
13524                              U = U->next;
13525                         }U = UTop;
13526                         okflag = true;
13527
13528
13529
13530                     }else if(MS0->S4.wayp->type == 2){
13531                         U = UTop;
13532                         waypSCSunitCnt = 0;
13533                         static bool okflag = true;
13534                         while(U){
13535                             if(U->team != MS0->S4.team){
13536                                 U = U->next;
13537                                 continue;
13538                             }
13539                             if((MS0->S4.wayp->x <= U->x) && (MS0->S4.wayp->x2 >= U->x) &&
13540                                (MS0->S4.wayp->y <= U->y) && (MS0->S4.wayp->y2 >= U->y)){
13541
13542
13543                                 int Cnum = 0;
13544
13545                                 if(1){
13546                                     Cnum++;
13547                                     if(Unum < Cnum) goto omfgUnitOver;
13548
13549
13550
13551
13552
13553                                     if(UP)
13554                                     {
13555                                         if(!UPT){
13556                                             UPT = UP;
13557                                         }
13558
13559                                         UP = UPT;
13560                                         while (UP) {
13561                                             if(UP->x == U->x && UP->y == U->y){
13562
13563                                                 break;
13564                                             }else{
13565                                                 okflag = true;
13566                                             }
13567
13568                                             UP = UP->next;
13569                                         }
13570
13571                                     }
13572                                     UP = UPT;
13573
13574                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13575                                     else if(UP){
13576                                         while(UP->next) UP = UP->next;
13577                                     }
13578                                     if(okflag){
13579                                         UP->x = U->x;
13580                                         UP->y = U->y;
13581                                         UP->next = calloc(1, sizeof(UNITPOINT));
13582                                         okflag = false;
13583                                         waypSCScnt++;
13584                                         waypSCSunitCnt++;
13585                                     }
13586                                 }
13587
13588
13589
13590
13591                             }
13592                             U = U->next;
13593                         }U = UTop;
13594                         okflag = true;
13595                     }
13596
13597                     MS0->S4.wayp = MS0->S4.wayp->next;
13598                 }MS0->S4.wayp = wpt;
13599            // NSLog(@"%d", waypSCSunitCnt);
13600
13601             if(waypSCScnt >= waypCnt)
13602                 waypSCS = true;
13603
13604             }else if(MS0->S4.unitTypeFlag){
13605
13606                 while (MS0->S4.wayp) {
13607                     waypCnt++;
13608
13609
13610
13611
13612                     if(MS0->S4.wayp->type == 0){
13613                         chosen = chosenT;
13614                         while(chosen){
13615                             if(MS0->S4.wayp->x == chosen->x && MS0->S4.wayp->y == chosen->y){
13616                                 waypSCScnt++;
13617                                 waypSCSunitCnt++;
13618                                 break;
13619                             }
13620                             chosen = chosen->next;
13621                         }chosen = chosenT;
13622
13623                     }else if(MS0->S4.wayp->type == 1){
13624                         chosen = chosenT;
13625                         static bool okflag = true;
13626                         while(chosen){
13627                             for (int i = 0;i < 1002;i++) {
13628                                 for (int k = 0;k < 1002;k++) {
13629                                     waypR[i][k] = 0;
13630                                 }
13631                             }
13632                             [self checkPlaceHani:MS0->S4.wayp->z+1 tX:MS0->S4.wayp->y tY:MS0->S4.wayp->x aMap:waypR u:chosen scsCnt:&waypSCSunitCnt];
13633
13634                             int Cnum = 0;
13635
13636                             for(int bx=1;bx<=chipWidth;bx++){
13637                                 for(int by=1;by<=chipHeight;by++){
13638                                     if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
13639
13640                                         if(waypR[chosen->x][chosen->y] > 0){
13641                                             Cnum++;
13642                                             if(Unum < Cnum) goto omfgUnitOver5;
13643
13644
13645
13646
13647
13648                                             if(UP)
13649                                             {
13650                                                 if(!UPT){
13651                                                     UPT = UP;
13652                                                 }
13653
13654                                                 UP = UPT;
13655                                                 while (UP) {
13656                                                     if(UP->x == chosen->x && UP->y == chosen->y){
13657
13658                                                         break;
13659                                                     }else{
13660                                                         okflag = true;
13661                                                     }
13662
13663                                                     UP = UP->next;
13664                                                 }
13665
13666                                             }
13667                                             UP = UPT;
13668
13669                                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13670                                             else if(UP){
13671                                                 while(UP->next) UP = UP->next;
13672                                             }
13673                                             if(okflag){
13674                                                 UP->x = chosen->x;
13675                                                 UP->y = chosen->y;
13676                                                 UP->next = calloc(1, sizeof(UNITPOINT));
13677                                                 okflag = false;
13678                                                 waypSCSunitCnt++;
13679                                             }
13680                                         }
13681
13682                                     }
13683                                 }
13684                             }
13685
13686                         omfgUnitOver5:
13687                             UP = NULL;
13688                             UPT = NULL;
13689
13690                           //           NSLog(@"%d", waypSCSunitCnt);
13691
13692                             chosen = chosen->next;
13693                         }chosen = chosenT;
13694                         okflag = true;
13695
13696
13697
13698                     }else if(MS0->S4.wayp->type == 2){
13699                         chosen = chosenT;
13700                         waypSCSunitCnt = 0;
13701                         static bool okflag = true;
13702                         while(chosen){
13703                             if((MS0->S4.wayp->x <= chosen->x) && (MS0->S4.wayp->x2 >= chosen->x) &&
13704                                (MS0->S4.wayp->y <= chosen->y) && (MS0->S4.wayp->y2 >= chosen->y)){
13705
13706
13707                                 int Cnum = 0;
13708
13709                                 if(1){
13710                                     Cnum++;
13711                                     if(Unum < Cnum) goto omfgUnitOver;
13712
13713
13714
13715
13716
13717                                     if(UP)
13718                                     {
13719                                         if(!UPT){
13720                                             UPT = UP;
13721                                         }
13722
13723                                         UP = UPT;
13724                                         while (UP) {
13725                                             if(UP->x == chosen->x && UP->y == chosen->y){
13726
13727                                                 break;
13728                                             }else{
13729                                                 okflag = true;
13730                                             }
13731
13732                                             UP = UP->next;
13733                                         }
13734
13735                                     }
13736                                     UP = UPT;
13737
13738                                     if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13739                                     else if(UP){
13740                                         while(UP->next) UP = UP->next;
13741                                     }
13742                                     if(okflag){
13743                                         UP->x = chosen->x;
13744                                         UP->y = chosen->y;
13745                                         UP->next = calloc(1, sizeof(UNITPOINT));
13746                                         okflag = false;
13747                                         waypSCScnt++;
13748                                         waypSCSunitCnt++;
13749                                     }
13750                                 }
13751
13752
13753
13754
13755                             }
13756                             chosen = chosen->next;
13757                         }chosen = chosenT;
13758                         okflag = true;
13759                     }
13760
13761                     MS0->S4.wayp = MS0->S4.wayp->next;
13762                 }MS0->S4.wayp = wpt;
13763               //  NSLog(@"%d", waypSCSunitCnt);
13764
13765                 if(waypSCScnt >= waypCnt)
13766                     waypSCS = true;
13767
13768
13769
13770
13771
13772             }
13773
13774             int team0num = 0;
13775             int team1num = 0;
13776             int team2num = 0;
13777             if(MS0->S4.team == 0){
13778                 if(!MS0->S4.placeFlag){
13779                 U = UTop;
13780                 while (U) {
13781                     if(U->team == 0 && !U->dead)
13782                         team0num++;
13783                     U = U->next;
13784                 }U = UTop;
13785                 }
13786                 if(MS0->S4.unitType == 0){
13787                     if(MS0->S4.placeFlag) team0num = MS0->S4.unitNum;
13788
13789                     if((MS0->S4.unitNum == team0num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13790
13791                     }else{
13792                         trueFlag = false;
13793                     }
13794                 }else if(MS0->S4.unitType == 1){
13795                     if(MS0->S4.placeFlag) team0num = 65000;
13796
13797                     if((MS0->S4.unitNum <= team0num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13798
13799                     }else{
13800                         trueFlag = false;
13801                     }
13802                 }else if(MS0->S4.unitType == 2){
13803                     if((MS0->S4.unitNum >= team0num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13804
13805                     }else{
13806                         trueFlag = false;
13807                     }
13808                 }
13809
13810
13811             }else if(MS0->S4.team == 1){
13812                 if(!MS0->S4.placeFlag){
13813                 U = UTop;
13814                 while (U) {
13815                     if(U->team == 1 && !U->dead)
13816                         team1num++;
13817                     U = U->next;
13818                 }U = UTop;
13819                 }
13820                 if(MS0->S4.unitType == 0){
13821                     if(MS0->S4.placeFlag) team1num = MS0->S4.unitNum;
13822
13823                     if((MS0->S4.unitNum == team1num) && (MS0->S4.unitNum = waypSCSunitCnt)){
13824
13825                     }else{
13826                         trueFlag = false;
13827                     }
13828                 }else if(MS0->S4.unitType == 1){
13829                     if(MS0->S4.placeFlag) team1num = 65000;
13830
13831                     if((MS0->S4.unitNum <= team1num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13832
13833                     }else{
13834                         trueFlag = false;
13835                     }
13836                 }else if(MS0->S4.unitType == 2){
13837                     if((MS0->S4.unitNum >= team1num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13838
13839                     }else{
13840                         trueFlag = false;
13841                     }
13842                 }
13843             }else if(MS0->S4.team == 2){
13844                 if(!MS0->S4.placeFlag){
13845                 U = UTop;
13846                 while (U) {
13847                     if(U->team == 2 && !U->dead)
13848                         team2num++;
13849                     U = U->next;
13850                 }U = UTop;
13851                 }
13852                 if(MS0->S4.unitType == 0){
13853                     if(MS0->S4.placeFlag) team2num = MS0->S4.unitNum;
13854
13855                     if((MS0->S4.unitNum == team2num) && (MS0->S4.unitNum == waypSCSunitCnt)){
13856
13857                     }else{
13858                         trueFlag = false;
13859                     }
13860                 }else if(MS0->S4.unitType == 1){
13861                     if(MS0->S4.placeFlag) team2num = 65000;
13862
13863                     if((MS0->S4.unitNum <= team2num) && (MS0->S4.unitNum <= waypSCSunitCnt)){
13864
13865                     }else{
13866                         trueFlag = false;
13867                     }
13868                 }else if(MS0->S4.unitType == 2){
13869                     if((MS0->S4.unitNum >= team2num) && (MS0->S4.unitNum >= waypSCSunitCnt)){
13870
13871                     }else{
13872                         trueFlag = false;
13873                     }
13874                 }
13875             }
13876
13877         }
13878
13879
13880         if(MS0->S4.unitCMDflag){
13881
13882             UNIT2 *sjt = MS0->S4.subj;
13883             UNIT *chosen = NULL;
13884             UNIT *chosenT = NULL;
13885             int cntUnit = 0;
13886             bool lmao = false;
13887             while(MS0->S4.subj){
13888                 U = UTop;
13889                 while(U){
13890                     if(MS0->S4.subj->x == U->ix && MS0->S4.subj->y == U->iy && U->iz == 1){
13891                         if(chosen){
13892                             chosen->next = calloc(1, sizeof(UNIT));
13893                             if(!lmao){
13894                                 chosenT = chosen;
13895                                 lmao = true;
13896                             }
13897                             chosen = chosen->next;
13898                         }
13899                         if(!chosen){
13900                             chosen = calloc(1, sizeof(UNIT));
13901                         }
13902                         chosen->x = U->x;
13903                         chosen->y = U->y;
13904                         chosen->C.name = U->C.name;
13905
13906                         if(!U->dead)
13907                             cntUnit++;
13908                     }
13909                     U = U->next;
13910                 }U = UTop;
13911                 if(!lmao){
13912                     chosenT = chosen;
13913                     lmao = true;
13914                 }
13915                 MS0->S4.subj = MS0->S4.subj->next;
13916             }MS0->S4.subj = sjt;
13917             chosen = chosenT;
13918
13919             int objeSCSunitCnt = 0;
13920
13921
13922             int Unum = 0;
13923
13924
13925             while (chosen) {
13926                 Unum++;
13927                 chosen = chosen->next;
13928             }chosen = chosenT;
13929
13930             if(MS0->S4.unitTypeFlag && MS0->S4.objeFlag){
13931
13932                 UNIT2 *objeT = MS0->S4.obje;
13933
13934                 while (MS0->S4.obje) {
13935
13936
13937
13938                     chosen = chosenT;
13939                     static bool okflag = true;
13940                     while(chosen){
13941                         for (int i = 0;i < 1002;i++) {
13942                             for (int k = 0;k < 1002;k++) {
13943                                 objeR[i][k] = 0;
13944                             }
13945                         }
13946
13947                         U2 = UTop;
13948                         while(U2){
13949                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
13950                                 break;
13951                             }
13952                             U2 = U2->next;
13953                         }
13954
13955                         if(!U2){
13956                             U2 = UTop;
13957                             break;
13958                         }
13959
13960                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:chosen scsCnt:&objeSCSunitCnt];
13961
13962                         int Cnum = 0;
13963
13964                         for(int bx=1;bx<=chipWidth;bx++){
13965                             for(int by=1;by<=chipHeight;by++){
13966                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
13967
13968                                     if(objeR[chosen->x][chosen->y] > 0){
13969                                         Cnum++;
13970                                         if(Unum < Cnum) goto omfgUnitOver31;
13971
13972
13973
13974
13975
13976                                         if(UP)
13977                                         {
13978                                             if(!UPT){
13979                                                 UPT = UP;
13980                                             }
13981
13982                                             UP = UPT;
13983                                             while (UP) {
13984                                                 if(UP->x == chosen->x && UP->y == chosen->y){
13985
13986                                                     break;
13987                                                 }else{
13988                                                     okflag = true;
13989                                                 }
13990
13991                                                 UP = UP->next;
13992                                             }
13993
13994                                         }
13995                                         UP = UPT;
13996
13997                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
13998                                         else if(UP){
13999                                             while(UP->next) UP = UP->next;
14000                                         }
14001                                         if(okflag){
14002                                             UP->x = chosen->x;
14003                                             UP->y = chosen->y;
14004                                             UP->next = calloc(1, sizeof(UNITPOINT));
14005                                             okflag = false;
14006                                             objeSCSunitCnt++;
14007                                         }
14008                                     }
14009
14010                                 }
14011                             }
14012                         }
14013
14014                     omfgUnitOver31:
14015                         UP = NULL;
14016                         UPT = NULL;
14017
14018                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
14019
14020                         chosen = chosen->next;
14021                     }chosen = chosenT;
14022                     okflag = true;
14023                     MS0->S4.obje = MS0->S4.obje->next;
14024                 }
14025                 MS0->S4.obje = objeT;
14026             }else if(MS0->S4.objeFlag){
14027
14028                 UNIT2 *objeT = MS0->S4.obje;
14029
14030                 while (MS0->S4.obje) {
14031
14032
14033
14034                     U = UTop;
14035                     static bool okflag = true;
14036                     while(U){
14037                         if(U->team != MS0->S4.team){
14038                             U = U->next;
14039                             continue;
14040                         }
14041                         for (int i = 0;i < 1002;i++) {
14042                             for (int k = 0;k < 1002;k++) {
14043                                 objeR[i][k] = 0;
14044                             }
14045                         }
14046
14047                         U2 = UTop;
14048                         while(U2){
14049                             if(U2->ix == MS0->S4.obje->x && U2->iy == MS0->S4.obje->y){
14050                                 break;
14051                             }
14052                             U2 = U2->next;
14053                         }
14054
14055                         if(!U2){
14056                             U2 = UTop;
14057                             break;
14058                         }
14059
14060                         [self checkPlaceHani:MS0->S4.objeRange+1 tX:U2->y tY:U2->x aMap:objeR u:U scsCnt:&objeSCSunitCnt];
14061
14062                         int Cnum = 0;
14063
14064                         for(int bx=1;bx<=chipWidth;bx++){
14065                             for(int by=1;by<=chipHeight;by++){
14066                                 if(objeR[bx][by] != 999 && objeR[bx][by] > 0){
14067
14068                                     if(objeR[chosen->x][chosen->y] > 0){
14069                                         Cnum++;
14070                                         if(Unum < Cnum) goto omfgUnitOver32;
14071
14072
14073
14074
14075
14076                                         if(UP)
14077                                         {
14078                                             if(!UPT){
14079                                                 UPT = UP;
14080                                             }
14081
14082                                             UP = UPT;
14083                                             while (UP) {
14084                                                 if(UP->x == chosen->x && UP->y == chosen->y){
14085
14086                                                     break;
14087                                                 }else{
14088                                                     okflag = true;
14089                                                 }
14090
14091                                                 UP = UP->next;
14092                                             }
14093
14094                                         }
14095                                         UP = UPT;
14096
14097                                         if(!UP) UP = calloc(1, sizeof(UNITPOINT));
14098                                         else if(UP){
14099                                             while(UP->next) UP = UP->next;
14100                                         }
14101                                         if(okflag){
14102                                             UP->x = chosen->x;
14103                                             UP->y = chosen->y;
14104                                             UP->next = calloc(1, sizeof(UNITPOINT));
14105                                             okflag = false;
14106                                             objeSCSunitCnt++;
14107                                         }
14108                                     }
14109
14110                                 }
14111                             }
14112                         }
14113
14114                     omfgUnitOver32:
14115                         UP = NULL;
14116                         UPT = NULL;
14117
14118                         //NSLog(@"%@, %d, %d", chosen->C.name, objeSCSunitCnt, objeR[0][0]);
14119
14120                         chosen = chosen->next;
14121                     }chosen = chosenT;
14122                     okflag = true;
14123                     MS0->S4.obje = MS0->S4.obje->next;
14124                 }
14125                 MS0->S4.obje = objeT;
14126                 U = UTop;
14127             }
14128
14129             if(MS0->S4.team == 0){
14130
14131                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14132
14133                 if(MS0->S4.unitCMD == 0){
14134                     if(pushStanbyFlag){
14135
14136                     }else{
14137                         trueFlag = false;
14138                     }
14139                 }else if(MS0->S4.unitCMD == 1){
14140                     if(battleSetUp){
14141                         battleSetUpIgnore = true;
14142                     }else{
14143                         trueFlag = false;
14144                     }
14145                 }else if(MS0->S4.unitCMD == 2){
14146
14147                 }
14148
14149
14150                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14151
14152
14153
14154                     BUILD2 *bldt = MS0->S4.build;
14155
14156                     while(MS0->S4.build){
14157                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14158
14159                         if(MS0->S4.unitCMD == 0){
14160                             if(pushStanbyFlag){
14161
14162                             }else{
14163                                 trueFlag = false;
14164                             }
14165                         }else if(MS0->S4.unitCMD == 1){
14166                             if(battleSetUp){
14167                                 battleSetUpIgnore = true;
14168                             }else{
14169                                 trueFlag = false;
14170
14171                             }
14172
14173                         }else if(MS0->S4.unitCMD == 2){
14174
14175
14176                         }
14177                     }else{
14178                         trueFlag = false;
14179                     }
14180                         MS0->S4.build = MS0->S4.build->next;
14181                     }MS0->S4.build = bldt;
14182
14183
14184                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14185
14186
14187                     UNIT2 *sbjt = MS0->S4.subj;
14188
14189                     while(MS0->S4.subj){
14190                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14191
14192                     if(MS0->S4.unitCMD == 0){
14193                         if(pushStanbyFlag){
14194
14195                         }else{
14196                             trueFlag = false;
14197                         }
14198                     }else if(MS0->S4.unitCMD == 1){
14199                         if(battleSetUp){
14200                             battleSetUpIgnore = true;
14201                         }else{
14202                             trueFlag = false;
14203
14204                         }
14205
14206                     }else if(MS0->S4.unitCMD == 2){
14207
14208
14209                     }
14210                     }else{
14211                         trueFlag = false;
14212                     }
14213
14214                         MS0->S4.subj = MS0->S4.subj->next;
14215                     }MS0->S4.subj = sbjt;
14216
14217
14218                 }
14219                 else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14220
14221                     UNIT2 *sbjt = MS0->S4.subj;
14222                     UNIT2 *objt = MS0->S4.obje;
14223
14224                     while(MS0->S4.subj){
14225                         while(MS0->S4.obje){
14226                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14227                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14228
14229                     if(MS0->S4.unitCMD == 0){
14230
14231                         if(MS0->S4.unitType == 0){
14232                         if(objeSCSunitCnt == MS0->S4.unitNum){
14233
14234                             if(pushStanbyFlag){
14235
14236                             }else{
14237                                 trueFlag = false;
14238                             }
14239                         }
14240
14241                         }else if(MS0->S4.unitType == 1){
14242                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14243
14244                                 if(pushStanbyFlag){
14245
14246                                 }else{
14247                                     trueFlag = false;
14248                                 }
14249                             }
14250
14251                         }else if(MS0->S4.unitType == 2){
14252                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14253
14254                                 if(pushStanbyFlag){
14255
14256                                 }else{
14257                                     trueFlag = false;
14258                                 }
14259                             }
14260                         }
14261
14262                     }else if(MS0->S4.unitCMD == 1){
14263
14264                         if(MS0->S4.unitType == 0){
14265                             if(objeSCSunitCnt == MS0->S4.unitNum){
14266
14267                                 if(battleSetUp){
14268                                     battleSetUpIgnore = true;
14269                                 }else{
14270                                     trueFlag = false;
14271                                 }
14272                             }
14273
14274                         }else if(MS0->S4.unitType == 1){
14275                             if(objeSCSunitCnt >= MS0->S4.unitNum){
14276
14277                                 if(battleSetUp){
14278                                     battleSetUpIgnore = true;
14279                                 }else{
14280                                     trueFlag = false;
14281                                 }
14282                             }
14283
14284                         }else if(MS0->S4.unitType == 2){
14285                             if(objeSCSunitCnt <= MS0->S4.unitNum){
14286
14287                                 if(battleSetUp){
14288                                     battleSetUpIgnore = true;
14289                                 }else{
14290                                     trueFlag = false;
14291                                 }
14292                             }
14293                         }
14294
14295                     }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14296
14297
14298                     }
14299
14300
14301
14302
14303
14304                     }else{
14305                         trueFlag = false;
14306                     }
14307                         MS0->S4.obje = MS0->S4.obje->next;
14308                         }MS0->S4.obje = objt;
14309                         MS0->S4.subj = MS0->S4.subj->next;
14310                     }MS0->S4.subj = sbjt;
14311
14312                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14313
14314
14315                     UNIT2 *sbjt = MS0->S4.subj;
14316                     BUILD2 *bldt = MS0->S4.build;
14317
14318                     while(MS0->S4.subj){
14319                         while(MS0->S4.build){
14320                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14321                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14322                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14323
14324                         if(MS0->S4.unitCMD == 0){
14325                             if(pushStanbyFlag){
14326
14327                             }else{
14328                                 trueFlag = false;
14329                             }
14330                         }else if(MS0->S4.unitCMD == 1){
14331                             if(battleSetUp){
14332                                 battleSetUpIgnore = true;
14333                             }else{
14334                                 trueFlag = false;
14335
14336                             }
14337
14338                         }else if(MS0->S4.unitCMD == 2){
14339
14340
14341                         }
14342
14343
14344                     }else{
14345                         trueFlag = false;
14346                     }
14347                         MS0->S4.build = MS0->S4.build->next;
14348                         }MS0->S4.build = bldt;
14349
14350                         MS0->S4.subj = MS0->S4.subj->next;
14351                 }
14352                    MS0->S4.subj = sbjt;
14353
14354                 }
14355             }else if(MS0->S4.team == 1){
14356                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14357
14358                     if(MS0->S4.unitCMD == 0){
14359                         if(pushStanbyFlag){
14360
14361                         }else{
14362                             trueFlag = false;
14363                         }
14364                     }else if(MS0->S4.unitCMD == 1){
14365                         if(battleSetUp){
14366                             battleSetUpIgnore = true;
14367                         }else{
14368                             trueFlag = false;
14369                         }
14370                     }else if(MS0->S4.unitCMD == 2){
14371
14372                     }
14373
14374
14375                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14376
14377
14378
14379                     BUILD2 *bldt = MS0->S4.build;
14380                     while(MS0->S4.build){
14381                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14382
14383                         if(MS0->S4.unitCMD == 0){
14384                             if(pushStanbyFlag){
14385
14386                             }else{
14387                                 trueFlag = false;
14388                             }
14389                         }else if(MS0->S4.unitCMD == 1){
14390                             if(battleSetUp){
14391                                 battleSetUpIgnore = true;
14392                             }else{
14393                                 trueFlag = false;
14394
14395                             }
14396
14397                         }else if(MS0->S4.unitCMD == 2){
14398
14399
14400                         }
14401                     }else{
14402                         trueFlag = false;
14403                     }
14404                         MS0->S4.build = MS0->S4.build->next;
14405                     }MS0->S4.build = bldt;
14406
14407
14408                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14409
14410
14411
14412                     UNIT2 *sbjt = MS0->S4.subj;
14413
14414                     while(MS0->S4.subj){
14415                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14416
14417                         if(MS0->S4.unitCMD == 0){
14418                             if(pushStanbyFlag){
14419
14420                             }else{
14421                                 trueFlag = false;
14422                             }
14423                         }else if(MS0->S4.unitCMD == 1){
14424                             if(battleSetUp){
14425                                 battleSetUpIgnore = true;
14426                             }else{
14427                                 trueFlag = false;
14428
14429                             }
14430
14431                         }else if(MS0->S4.unitCMD == 2){
14432
14433
14434                         }
14435                     }else{
14436                         trueFlag = false;
14437                     }
14438
14439                         MS0->S4.subj = MS0->S4.subj->next;
14440                     }MS0->S4.subj = sbjt;
14441
14442                 }else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14443
14444                     UNIT2 *sbjt = MS0->S4.subj;
14445                     UNIT2 *objt = MS0->S4.obje;
14446
14447                     while(MS0->S4.subj){
14448                         while(MS0->S4.obje){
14449                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14450                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14451
14452                         if(MS0->S4.unitCMD == 0){
14453
14454                             if(MS0->S4.unitType == 0){
14455                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14456
14457                                     if(pushStanbyFlag){
14458
14459                                     }else{
14460                                         trueFlag = false;
14461                                     }
14462                                 }
14463
14464                             }else if(MS0->S4.unitType == 1){
14465                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14466
14467                                     if(pushStanbyFlag){
14468
14469                                     }else{
14470                                         trueFlag = false;
14471                                     }
14472                                 }
14473
14474                             }else if(MS0->S4.unitType == 2){
14475                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14476
14477                                     if(pushStanbyFlag){
14478
14479                                     }else{
14480                                         trueFlag = false;
14481                                     }
14482                                 }
14483                             }
14484
14485                         }else if(MS0->S4.unitCMD == 1){
14486
14487                             if(MS0->S4.unitType == 0){
14488                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14489
14490                                     if(battleSetUp){
14491                                         battleSetUpIgnore = true;
14492                                     }else{
14493                                         trueFlag = false;
14494                                     }
14495                                 }
14496
14497                             }else if(MS0->S4.unitType == 1){
14498                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14499
14500                                     if(battleSetUp){
14501                                         battleSetUpIgnore = true;
14502                                     }else{
14503                                         trueFlag = false;
14504                                     }
14505                                 }
14506
14507                             }else if(MS0->S4.unitType == 2){
14508                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14509
14510                                     if(battleSetUp){
14511                                         battleSetUpIgnore = true;
14512                                     }else{
14513                                         trueFlag = false;
14514                                     }
14515                                 }
14516                             }
14517
14518                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14519
14520
14521                         }
14522
14523
14524
14525
14526                     }else{
14527                         trueFlag = false;
14528                     }
14529
14530
14531                             MS0->S4.obje = MS0->S4.obje->next;
14532                         }MS0->S4.obje = objt;
14533                         MS0->S4.subj = MS0->S4.subj->next;
14534                     }MS0->S4.subj = sbjt;
14535
14536                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14537
14538                     UNIT2 *sbjt = MS0->S4.subj;
14539                     BUILD2 *bldt = MS0->S4.build;
14540                     while(MS0->S4.subj){
14541                         while(MS0->S4.build){
14542                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14543                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14544                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14545
14546                         if(MS0->S4.unitCMD == 0){
14547                             if(pushStanbyFlag){
14548
14549                             }else{
14550                                 trueFlag = false;
14551                             }
14552                         }else if(MS0->S4.unitCMD == 1){
14553                             if(battleSetUp){
14554                                 battleSetUpIgnore = true;
14555                             }else{
14556                                 trueFlag = false;
14557
14558                             }
14559
14560                         }else if(MS0->S4.unitCMD == 2){
14561
14562
14563                         }
14564
14565
14566                     }else{
14567                         trueFlag = false;
14568                     }
14569                         MS0->S4.build = MS0->S4.build->next;
14570                         }MS0->S4.build = bldt;
14571                         MS0->S4.subj = MS0->S4.subj->next;
14572                     }MS0->S4.subj = sbjt;
14573                 }
14574             }else if(MS0->S4.team == 2){
14575                 if(!MS0->S4.subj && !MS0->S4.obje && !MS0->S4.build){
14576
14577                     if(MS0->S4.unitCMD == 0){
14578                         if(pushStanbyFlag){
14579
14580                         }else{
14581                             trueFlag = false;
14582                         }
14583                     }else if(MS0->S4.unitCMD == 1){
14584                         if(battleSetUp){
14585                             battleSetUpIgnore = true;
14586                         }else{
14587                             trueFlag = false;
14588                         }
14589                     }else if(MS0->S4.unitCMD == 2){
14590
14591                     }
14592
14593
14594                 }else if(!MS0->S4.subj && !MS0->S4.obje && MS0->S4.build && Uselected){
14595
14596
14597
14598                     BUILD2 *bldt = MS0->S4.build;
14599                     while(MS0->S4.build){
14600                     if(Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14601
14602                         if(MS0->S4.unitCMD == 0){
14603                             if(pushStanbyFlag){
14604
14605                             }else{
14606                                 trueFlag = false;
14607                             }
14608                         }else if(MS0->S4.unitCMD == 1){
14609                             if(battleSetUp){
14610                                 battleSetUpIgnore = true;
14611                             }else{
14612                                 trueFlag = false;
14613
14614                             }
14615
14616                         }else if(MS0->S4.unitCMD == 2){
14617
14618
14619                         }
14620                     }else{
14621                         trueFlag = false;
14622                     }
14623                         MS0->S4.build = MS0->S4.build->next;
14624                     }MS0->S4.build = bldt;
14625
14626
14627                 }else if(MS0->S4.subj && !MS0->S4.obje && Uselected){
14628
14629                     UNIT2 *sbjt = MS0->S4.subj;
14630
14631                     while(MS0->S4.subj){
14632                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1){
14633
14634                         if(MS0->S4.unitCMD == 0){
14635                             if(pushStanbyFlag){
14636
14637                             }else{
14638                                 trueFlag = false;
14639                             }
14640                         }else if(MS0->S4.unitCMD == 1){
14641                             if(battleSetUp){
14642                                 battleSetUpIgnore = true;
14643                             }else{
14644                                 trueFlag = false;
14645
14646                             }
14647
14648                         }else if(MS0->S4.unitCMD == 2){
14649
14650
14651                         }
14652                     }else{
14653                         trueFlag = false;
14654                     }
14655                       MS0->S4.subj = MS0->S4.subj->next;
14656                     }MS0->S4.subj = sbjt;
14657
14658                 }else if(MS0->S4.subj && MS0->S4.obje && Uselected){
14659
14660                     UNIT2 *sbjt = MS0->S4.subj;
14661                     UNIT2 *objt = MS0->S4.obje;
14662
14663                     while(MS0->S4.subj){
14664                         while(MS0->S4.obje){
14665                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14666                        Utarget->ix == MS0->S4.obje->x && Utarget->iy == MS0->S4.obje->y && Utarget->iz == 1){
14667
14668                         if(MS0->S4.unitCMD == 0){
14669
14670                             if(MS0->S4.unitType == 0){
14671                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14672
14673                                     if(pushStanbyFlag){
14674
14675                                     }else{
14676                                         trueFlag = false;
14677                                     }
14678                                 }
14679
14680                             }else if(MS0->S4.unitType == 1){
14681                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14682
14683                                     if(pushStanbyFlag){
14684
14685                                     }else{
14686                                         trueFlag = false;
14687                                     }
14688                                 }
14689
14690                             }else if(MS0->S4.unitType == 2){
14691                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14692
14693                                     if(pushStanbyFlag){
14694
14695                                     }else{
14696                                         trueFlag = false;
14697                                     }
14698                                 }
14699                             }
14700
14701                         }else if(MS0->S4.unitCMD == 1){
14702
14703                             if(MS0->S4.unitType == 0){
14704                                 if(objeSCSunitCnt == MS0->S4.unitNum){
14705
14706                                     if(battleSetUp){
14707                                         battleSetUpIgnore = true;
14708                                     }else{
14709                                         trueFlag = false;
14710                                     }
14711                                 }
14712
14713                             }else if(MS0->S4.unitType == 1){
14714                                 if(objeSCSunitCnt >= MS0->S4.unitNum){
14715
14716                                     if(battleSetUp){
14717                                         battleSetUpIgnore = true;
14718                                     }else{
14719                                         trueFlag = false;
14720                                     }
14721                                 }
14722
14723                             }else if(MS0->S4.unitType == 2){
14724                                 if(objeSCSunitCnt <= MS0->S4.unitNum){
14725
14726                                     if(battleSetUp){
14727                                         battleSetUpIgnore = true;
14728                                     }else{
14729                                         trueFlag = false;
14730                                     }
14731                                 }
14732                             }
14733
14734                         }else if(MS0->S4.unitCMD == 2 && objeSCSunitCnt > 0){
14735
14736
14737                         }
14738
14739                     }else{
14740                         trueFlag = false;
14741                     }
14742                             MS0->S4.obje = MS0->S4.obje->next;
14743                         }MS0->S4.obje = objt;
14744                         MS0->S4.subj = MS0->S4.subj->next;
14745                     }MS0->S4.subj = sbjt;
14746                 }if(MS0->S4.subj && MS0->S4.build && Uselected){
14747
14748                     UNIT2 *sbjt = MS0->S4.subj;
14749                     BUILD2 *bldt = MS0->S4.build;
14750                     while(MS0->S4.subj){
14751                         while(MS0->S4.build){
14752                     if(Uselected->ix == MS0->S4.subj->x && Uselected->iy == MS0->S4.subj->y && Uselected->iz == 1 &&
14753                        BC[buildNum[Uselected->x][Uselected->y]].nameID == MS0->S4.build->C->nameID &&
14754                        Uselected->x == MS0->S4.build->x && Uselected->y == MS0->S4.build->y){
14755
14756                         if(MS0->S4.unitCMD == 0){
14757                             if(pushStanbyFlag){
14758
14759                             }else{
14760                                 trueFlag = false;
14761                             }
14762                         }else if(MS0->S4.unitCMD == 1){
14763                             if(battleSetUp){
14764                                 battleSetUpIgnore = true;
14765                             }else{
14766                                 trueFlag = false;
14767
14768                             }
14769
14770                         }else if(MS0->S4.unitCMD == 2){
14771
14772
14773                         }
14774
14775
14776                     }else{
14777                         trueFlag = false;
14778                     }
14779                         MS0->S4.build = MS0->S4.build->next;
14780                         }MS0->S4.build = bldt;
14781                         MS0->S4.subj = MS0->S4.subj->next;
14782                     }MS0->S4.subj = sbjt;
14783                 }
14784             }
14785         }
14786
14787
14788
14789
14790
14791
14792
14793
14794
14795
14796
14797
14798
14799
14800
14801
14802
14803
14804
14805
14806
14807
14808
14809
14810
14811     }
14812
14813
14814
14815
14816
14817
14818
14819
14820     branchEndFlag = true;
14821     MS0->succeessfulFlag = false;
14822     if(trueFlag){
14823         branchSuceedFlag = true;
14824         MS0->succeessfulFlag = true;
14825     }else{
14826         MS0->succeessfulFlag = false;
14827     }
14828
14829     CRMS0 = MS0;
14830     if(branchEndFlag){
14831         if(!branchSuceedFlag){
14832             MS0 = MSDPtop;
14833             while(MS0){
14834                 MS0->endFlag = false;
14835                 MS0 = MS0->next;
14836             }
14837
14838             MS0 = CRMS0;
14839             MS0->endFlag = true;
14840             MS0 = MSDPtop;
14841
14842             if([CRMS0->S4.FAILrabel isEqualToString:MS0->label] && 0){
14843                 //ここはどうやら使えない
14844                 MS0->succeessfulFlag = false;
14845                 MS0->endFlag = false;
14846             }else{
14847
14848                 while (MS0) {
14849
14850                     if(MS0->next)
14851                         if([CRMS0->S4.FAILrabel isEqualToString:MS0->next->label]){
14852
14853                             if(MS0->type == 6 && MS0->endFlag){
14854
14855                             }else{
14856                                 MS0->succeessfulFlag = true;
14857                             }
14858                             MS0->endFlag = true;
14859                             MS0 = MS0->next;
14860                             break;
14861                         }
14862                     if(MS0->type == 6 && MS0->endFlag){
14863
14864                     }else{
14865                         MS0->succeessfulFlag = true;
14866                     }
14867                     MS0->endFlag = true;
14868                     MS0 = MS0->next;
14869                 }
14870             }
14871
14872             if(!MS0){
14873                 MS0 = CRMS0;
14874                 //MS0->endFlag = true;
14875                 return MS0;
14876             }
14877
14878         }else if(branchSuceedFlag){
14879             MS0 = MSDPtop;
14880             while(MS0){
14881                 MS0->endFlag = false;
14882                 MS0 = MS0->next;
14883             }
14884
14885             MS0 = CRMS0;
14886             MS0->endFlag = true;
14887
14888             MS0 = MSDPtop;
14889
14890             if([CRMS0->S4.COMPrabel isEqualToString:MS0->label] && 0){
14891                 MS0->succeessfulFlag = false;
14892                 MS0->endFlag = false;
14893             }else{
14894
14895                 while (MS0) {
14896
14897                     if(MS0->next)
14898                         if([CRMS0->S4.COMPrabel isEqualToString:MS0->next->label]){
14899
14900                             if(MS0->type == 6 && MS0->endFlag){
14901
14902                             }else{
14903                                 MS0->succeessfulFlag = true;
14904                             }
14905                             MS0->endFlag = true;
14906                             MS0 = MS0->next;
14907                             break;
14908                         }
14909
14910                     if(MS0->type == 6 && MS0->endFlag){
14911
14912                     }else{
14913                         MS0->succeessfulFlag = true;
14914                     }
14915                     MS0->endFlag = true;
14916                     MS0 = MS0->next;
14917                 }
14918             }
14919
14920             if(!MS0){
14921                 MS0 = CRMS0;
14922                 //MS0->endFlag = true;
14923                 return MS0;
14924             }
14925         }
14926     }
14927
14928     //NSLog(@"%g", eventTime);
14929     //NSLog(@"%d", MSDPtop->succeessfulFlag);
14930     //MS0->endFlag = true;
14931
14932     MS0 = [self setEvent:MS0];
14933
14934     return MS0;
14935 }
14936
14937
14938 -(void)checkPlaceHani:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap u:(UNIT*)u scsCnt:(int*)scsCnt{
14939
14940     if(cnsPow < 0) return;
14941
14942     int i0;
14943     int *j0 = scsCnt;
14944     if(aMap[startY][startX] <= cnsPow)
14945         aMap[startY][startX] = cnsPow;
14946
14947     if(startY < 0) startY = 0;
14948     if(startX < 0) startX = 0;
14949     if(cnsPow < 0) cnsPow = 0;
14950
14951     i0 = cnsPow - 1;
14952
14953     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
14954         [self checkPlaceHani:i0 tX:startX tY:startY-1 aMap:aMap u:u scsCnt:j0];
14955
14956     i0 = cnsPow - 1;
14957     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
14958         [self checkPlaceHani:i0 tX:startX tY:startY+1 aMap:aMap u:u scsCnt:j0];
14959
14960     i0 = cnsPow - 1;
14961     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
14962         [self checkPlaceHani:i0 tX:startX-1 tY:startY aMap:aMap u:u scsCnt:j0];
14963
14964     i0 = cnsPow - 1;
14965     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
14966         [self checkPlaceHani:i0 tX:startX+1 tY:startY aMap:aMap u:u scsCnt:j0];
14967
14968
14969 }
14970
14971 -(MAPSCRIPT0*)setLabelJump:(MAPSCRIPT0*)MS0{
14972
14973     MAPSCRIPT0 *CRMS0 = MS0;
14974     MS0 = MSDPtop;
14975     while(MS0){
14976         MS0->endFlag = false;
14977         MS0 = MS0->next;
14978     }
14979     MS0 = CRMS0;
14980     MS0->endFlag = true;
14981     MS0->succeessfulFlag = true;
14982
14983     MS0 = MSDPtop;
14984
14985     if([CRMS0->labelJump isEqualToString:MS0->label]){
14986         MS0->succeessfulFlag = false;
14987         MS0->endFlag = false;
14988     }else{
14989
14990         while (MS0) {
14991
14992             if(MS0->next)
14993                 if([CRMS0->labelJump isEqualToString:MS0->next->label]){
14994                     if(MS0->type == 6 && MS0->endFlag){
14995
14996                     }else{
14997                         MS0->succeessfulFlag = true;
14998                     }
14999                     MS0->endFlag = true;
15000                     MS0 = MS0->next;
15001                     break;
15002                 }
15003             if(MS0->type == 6 && MS0->endFlag){
15004
15005             }else{
15006                 MS0->succeessfulFlag = true;
15007             }
15008             MS0->endFlag = true;
15009                 MS0 = MS0->next;
15010         }
15011     }
15012     if(!MS0){
15013         MS0 = CRMS0;
15014         return MS0;
15015     }
15016
15017     return MS0;
15018 }
15019
15020 -(MAPSCRIPT0*)setDefault:(MAPSCRIPT0*)MS0{
15021
15022     MS0->succeessfulFlag = true;
15023     MS0->endFlag = true;
15024     return MS0;
15025 }
15026
15027 -(MAPSCRIPT0*)setStatus:(MAPSCRIPT0*)MS0{
15028
15029     NSString *value = @"";
15030
15031     if(MS0->S7.valueType == 0)
15032         value = [MS0->S7.value retain];
15033     else if(MS0->S7.valueType == 1)
15034         value = [Hensuu[MS0->S7.rdm] retain];
15035
15036     if(MS0->S7.teamFlag){
15037         U = UTop;
15038         while (U) {
15039
15040             if(MS0->S7.team == U->team)
15041                 [self setStatus0:U MS0:MS0 value:value];
15042
15043             U = U->next;
15044         }U = UTop;
15045     }
15046
15047     if(MS0->S7.unitFlag){
15048         U = UTop;
15049         while (U) {
15050
15051             MAPSCRIPT7A *MS7A = MS0->S7.A;
15052             while (MS0->S7.A) {
15053
15054                 if(U->ix == MS0->S7.A->x || U->iy == MS0->S7.A->y){
15055                     [self setStatus0:U MS0:MS0 value:value];
15056                     break;
15057                 }
15058                 MS0->S7.A = MS0->S7.A->next;
15059             }MS0->S7.A = MS7A;
15060
15061             U = U->next;
15062         }U = UTop;
15063     }
15064
15065     if(MS0->S7.valueFlag){
15066         U = UTop;
15067         while (U) {
15068
15069             MAPSCRIPT7B *MS7B = MS0->S7.B;
15070             while (MS0->S7.B) {
15071
15072             if(U->ix == MS0->S7.B->x || U->iy == MS0->S7.B->y){
15073                 [self setStatus0:U MS0:MS0 value:value];
15074                 break;
15075             }
15076                 MS0->S7.B = MS0->S7.B->next;
15077             }MS0->S7.B = MS7B;
15078
15079             U = U->next;
15080         }U = UTop;
15081     }
15082
15083     MS0->succeessfulFlag = true;
15084     MS0->endFlag = true;
15085     return MS0;
15086 }
15087
15088 -(UNIT*)setStatus0:(UNIT*)U MS0:(MAPSCRIPT0*)MS0 value:(NSString*)value{
15089
15090     if(!MS0->S7.maxFlag){
15091
15092         if (!MS0->S7.percentFlag) {
15093
15094             switch (MS0->S7.type) {
15095                 case 0:
15096                     if(MS0->S7.fluctuate == 0)
15097                         U->C.S_C.HP += [value doubleValue];
15098                     else if(MS0->S7.fluctuate == 1)
15099                         U->C.S_C.HP -= [value doubleValue];
15100                     else if(MS0->S7.fluctuate == 2)
15101                         U->C.S_C.HP = [value doubleValue];
15102                     if(MS0->S7.extendFlag)
15103                     if(U->C.S_C.HP > U->C.S_M.HP)
15104                         U->C.S_C.HP = U->C.S_M.HP;
15105                     if(U->C.S_C.HP < 0)
15106                         U->C.S_C.HP = 0;
15107                     break;
15108                 case 1:
15109                     if(MS0->S7.fluctuate == 0)
15110                         U->C.S_C.MP += [value doubleValue];
15111                     else if(MS0->S7.fluctuate == 1)
15112                         U->C.S_C.MP -= [value doubleValue];
15113                     else if(MS0->S7.fluctuate == 2)
15114                         U->C.S_C.MP = [value doubleValue];
15115                     if(MS0->S7.extendFlag)
15116                     if(U->C.S_C.MP > U->C.S_M.MP)
15117                         U->C.S_C.MP = U->C.S_M.MP;
15118                     if(U->C.S_C.MP < 0)
15119                         U->C.S_C.MP = 0;
15120                     break;
15121                 case 2:
15122                     if(MS0->S7.fluctuate == 0)
15123                         U->C.S_C.WT += [value doubleValue];
15124                     else if(MS0->S7.fluctuate == 1)
15125                         U->C.S_C.WT -= [value doubleValue];
15126                     else if(MS0->S7.fluctuate == 2)
15127                         U->C.S_C.WT = [value doubleValue];
15128                     if(MS0->S7.extendFlag)
15129                     if(U->C.S_C.WT > U->C.S_M.WT)
15130                         U->C.S_C.WT = U->C.S_M.WT;
15131                     if(U->C.S_C.WT < 0)
15132                         U->C.S_C.WT = 0;
15133                     break;
15134                 case 3:
15135                     if(MS0->S7.fluctuate == 0)
15136                         U->C.S_C.STR += [value doubleValue];
15137                     else if(MS0->S7.fluctuate == 1)
15138                         U->C.S_C.STR -= [value doubleValue];
15139                     else if(MS0->S7.fluctuate == 2)
15140                         U->C.S_C.STR = [value doubleValue];
15141                     if(MS0->S7.extendFlag)
15142                     if(U->C.S_C.STR > U->C.S_M.STR)
15143                         U->C.S_C.STR = U->C.S_M.STR;
15144                     if(U->C.S_C.STR < 0)
15145                         U->C.S_C.STR = 0;
15146                     break;
15147                 case 4:
15148                     if(MS0->S7.fluctuate == 0)
15149                         U->C.S_C.VIT += [value doubleValue];
15150                     else if(MS0->S7.fluctuate == 1)
15151                         U->C.S_C.VIT -= [value doubleValue];
15152                     else if(MS0->S7.fluctuate == 2)
15153                         U->C.S_C.VIT = [value doubleValue];
15154                     if(MS0->S7.extendFlag)
15155                     if(U->C.S_C.VIT > U->C.S_M.VIT)
15156                         U->C.S_C.VIT = U->C.S_M.VIT;
15157                     if(U->C.S_C.VIT < 0)
15158                         U->C.S_C.VIT = 0;
15159                     break;
15160                 case 5:
15161                     if(MS0->S7.fluctuate == 0)
15162                         U->C.S_C.AGI += [value doubleValue];
15163                     else if(MS0->S7.fluctuate == 1)
15164                         U->C.S_C.AGI -= [value doubleValue];
15165                     else if(MS0->S7.fluctuate == 2)
15166                         U->C.S_C.AGI = [value doubleValue];
15167                     if(MS0->S7.extendFlag)
15168                     if(U->C.S_C.AGI > U->C.S_M.AGI)
15169                         U->C.S_C.AGI = U->C.S_M.AGI;
15170                     if(U->C.S_C.AGI < 0)
15171                         U->C.S_C.AGI = 0;
15172                     break;
15173                 case 6:
15174                     if(MS0->S7.fluctuate == 0)
15175                         U->C.S_C.DEX += [value doubleValue];
15176                     else if(MS0->S7.fluctuate == 1)
15177                         U->C.S_C.DEX -= [value doubleValue];
15178                     else if(MS0->S7.fluctuate == 2)
15179                         U->C.S_C.DEX = [value doubleValue];
15180                     if(MS0->S7.extendFlag)
15181                     if(U->C.S_C.DEX > U->C.S_M.DEX)
15182                         U->C.S_C.DEX = U->C.S_M.DEX;
15183                     if(U->C.S_C.DEX < 0)
15184                         U->C.S_C.DEX = 0;
15185                     break;
15186                 case 7:
15187                     if(MS0->S7.fluctuate == 0)
15188                         U->C.S_C.MEN += [value doubleValue];
15189                     else if(MS0->S7.fluctuate == 1)
15190                         U->C.S_C.MEN -= [value doubleValue];
15191                     else if(MS0->S7.fluctuate == 2)
15192                         U->C.S_C.MEN = [value doubleValue];
15193                     if(MS0->S7.extendFlag)
15194                     if(U->C.S_C.MEN > U->C.S_M.MEN)
15195                         U->C.S_C.MEN = U->C.S_M.MEN;
15196                     if(U->C.S_C.MEN < 0)
15197                         U->C.S_C.MEN = 0;
15198                     break;
15199                 case 8:
15200                     if(MS0->S7.fluctuate == 0)
15201                         U->C.S_C.INT += [value doubleValue];
15202                     else if(MS0->S7.fluctuate == 1)
15203                         U->C.S_C.INT -= [value doubleValue];
15204                     else if(MS0->S7.fluctuate == 2)
15205                         U->C.S_C.INT = [value doubleValue];
15206                     if(MS0->S7.extendFlag)
15207                     if(U->C.S_C.INT > U->C.S_M.INT)
15208                         U->C.S_C.INT = U->C.S_M.INT;
15209                     if(U->C.S_C.INT < 0)
15210                         U->C.S_C.INT = 0;
15211                     break;
15212                 case 9:
15213                     if(MS0->S7.fluctuate == 0)
15214                         U->C.S_C.LUK += [value doubleValue];
15215                     else if(MS0->S7.fluctuate == 1)
15216                         U->C.S_C.LUK -= [value doubleValue];
15217                     else if(MS0->S7.fluctuate == 2)
15218                         U->C.S_C.LUK = [value doubleValue];
15219                     if(MS0->S7.extendFlag)
15220                     if(U->C.S_C.LUK > U->C.S_M.LUK)
15221                         U->C.S_C.LUK = U->C.S_M.LUK;
15222                     if(U->C.S_C.LUK < 0)
15223                         U->C.S_C.LUK = 0;
15224                     break;
15225                 case 10:
15226                     if(MS0->S7.fluctuate == 0)
15227                         U->C.S_C.MOV += [value doubleValue];
15228                     else if(MS0->S7.fluctuate == 1)
15229                         U->C.S_C.MOV -= [value doubleValue];
15230                     else if(MS0->S7.fluctuate == 2)
15231                         U->C.S_C.MOV = [value doubleValue];
15232                     if(MS0->S7.extendFlag)
15233                     if(U->C.S_C.MOV > U->C.S_M.MOV)
15234                         U->C.S_C.MOV = U->C.S_M.MOV;
15235                     if(U->C.S_C.MOV < 0)
15236                         U->C.S_C.MOV = 0;
15237                     break;
15238                 case 11:
15239                     if(MS0->S7.fluctuate == 0)
15240                         U->C.S_C.MEL += [value doubleValue];
15241                     else if(MS0->S7.fluctuate == 1)
15242                         U->C.S_C.MEL -= [value doubleValue];
15243                     else if(MS0->S7.fluctuate == 2)
15244                         U->C.S_C.MEL = [value doubleValue];
15245                     if(MS0->S7.extendFlag)
15246                     if(U->C.S_C.MEL > U->C.S_M.MEL)
15247                         U->C.S_C.MEL = U->C.S_M.MEL;
15248                     if(U->C.S_C.MEL < 0)
15249                         U->C.S_C.MEL = 0;
15250                     break;
15251                 case 12:
15252                     if(MS0->S7.fluctuate == 0)
15253                         U->C.S_C.MIS += [value doubleValue];
15254                     else if(MS0->S7.fluctuate == 1)
15255                         U->C.S_C.MIS -= [value doubleValue];
15256                     else if(MS0->S7.fluctuate == 2)
15257                         U->C.S_C.MIS = [value doubleValue];
15258                     if(MS0->S7.extendFlag)
15259                     if(U->C.S_C.MIS > U->C.S_M.MIS)
15260                         U->C.S_C.MIS = U->C.S_M.MIS;
15261                     if(U->C.S_C.MIS < 0)
15262                         U->C.S_C.MIS = 0;
15263                     break;
15264                 case 13:
15265                     if(MS0->S7.fluctuate == 0)
15266                         U->C.S_C.HIT += [value doubleValue];
15267                     else if(MS0->S7.fluctuate == 1)
15268                         U->C.S_C.HIT -= [value doubleValue];
15269                     else if(MS0->S7.fluctuate == 2)
15270                         U->C.S_C.HIT = [value doubleValue];
15271                     if(MS0->S7.extendFlag)
15272                     if(U->C.S_C.HIT > U->C.S_M.HIT)
15273                         U->C.S_C.HIT = U->C.S_M.HIT;
15274                     if(U->C.S_C.HIT < 0)
15275                         U->C.S_C.HIT = 0;
15276                     break;
15277                 case 14:
15278                     if(MS0->S7.fluctuate == 0)
15279                         U->C.S_C.DOD += [value doubleValue];
15280                     else if(MS0->S7.fluctuate == 1)
15281                         U->C.S_C.DOD -= [value doubleValue];
15282                     else if(MS0->S7.fluctuate == 2)
15283                         U->C.S_C.DOD = [value doubleValue];
15284                     if(MS0->S7.extendFlag)
15285                     if(U->C.S_C.DOD > U->C.S_M.DOD)
15286                         U->C.S_C.DOD = U->C.S_M.DOD;
15287                     if(U->C.S_C.DOD < 0)
15288                         U->C.S_C.DOD = 0;
15289                     break;
15290                 case 15:
15291                     if(MS0->S7.fluctuate == 0)
15292                         U->C.S_C.REA += [value doubleValue];
15293                     else if(MS0->S7.fluctuate == 1)
15294                         U->C.S_C.REA -= [value doubleValue];
15295                     else if(MS0->S7.fluctuate == 2)
15296                         U->C.S_C.REA = [value doubleValue];
15297                     if(MS0->S7.extendFlag)
15298                     if(U->C.S_C.REA > U->C.S_M.REA)
15299                         U->C.S_C.REA = U->C.S_M.REA;
15300                     if(U->C.S_C.REA < 0)
15301                         U->C.S_C.REA = 0;
15302                     break;
15303                 case 16:
15304                     if(MS0->S7.fluctuate == 0)
15305                         U->C.S_C.SKI += [value doubleValue];
15306                     else if(MS0->S7.fluctuate == 1)
15307                         U->C.S_C.SKI -= [value doubleValue];
15308                     else if(MS0->S7.fluctuate == 2)
15309                         U->C.S_C.SKI = [value doubleValue];
15310                     if(MS0->S7.extendFlag)
15311                     if(U->C.S_C.SKI > U->C.S_M.SKI)
15312                         U->C.S_C.SKI = U->C.S_M.SKI;
15313                     if(U->C.S_C.SKI < 0)
15314                         U->C.S_C.SKI = 0;
15315                     break;
15316                 case 17:
15317                     U->C.name =  [value retain];
15318                     break;
15319                 case 18:
15320                     U->C.nameNick =  [value retain];
15321                     break;
15322                 case 19:
15323                     U->C.nameClass =  [value retain];
15324                     break;
15325                 case 20:
15326                     U->C.S_C.typeMONS =  [value doubleValue];
15327                     break;
15328                 case 21:
15329                     U->C.S_C.typeMOVE =  [value doubleValue];
15330                     break;
15331                 case 22:
15332                     if(MS0->S7.fluctuate == 0)
15333                         U->C.S_C.cSupply += [value doubleValue];
15334                     else if(MS0->S7.fluctuate == 1)
15335                         U->C.S_C.cSupply -= [value doubleValue];
15336                     else if(MS0->S7.fluctuate == 2)
15337                         U->C.S_C.cSupply = [value doubleValue];
15338                     if(MS0->S7.extendFlag)
15339                     if(U->C.S_C.cSupply > U->C.S_M.cSupply)
15340                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15341                     if(U->C.S_C.cSupply < 0)
15342                         U->C.S_C.cSupply = 0;
15343                     break;
15344                 case 23:
15345                     if(MS0->S7.fluctuate == 0)
15346                         U->C.S_C.cFood += [value doubleValue];
15347                     else if(MS0->S7.fluctuate == 1)
15348                         U->C.S_C.cFood -= [value doubleValue];
15349                     else if(MS0->S7.fluctuate == 2)
15350                         U->C.S_C.cFood = [value doubleValue];
15351                     if(MS0->S7.extendFlag)
15352                     if(U->C.S_C.cFood > U->C.S_M.cFood)
15353                         U->C.S_C.cFood = U->C.S_M.cFood;
15354                     if(U->C.S_C.cFood < 0)
15355                         U->C.S_C.cFood = 0;
15356                     break;
15357                 case 24:
15358                     if(MS0->S7.fluctuate == 0)
15359                         U->C.S_C.cMoney += [value doubleValue];
15360                     else if(MS0->S7.fluctuate == 1)
15361                         U->C.S_C.cMoney -= [value doubleValue];
15362                     else if(MS0->S7.fluctuate == 2)
15363                         U->C.S_C.cMoney = [value doubleValue];
15364                     if(MS0->S7.extendFlag)
15365                     if(U->C.S_C.cMoney > U->C.S_M.cMoney)
15366                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15367                     if(U->C.S_C.cMoney < 0)
15368                         U->C.S_C.cMoney = 0;
15369                     break;
15370                 case 25:
15371                     if(MS0->S7.fluctuate == 0)
15372                         U->C.S_C.cWT += [value doubleValue];
15373                     else if(MS0->S7.fluctuate == 1)
15374                         U->C.S_C.cWT -= [value doubleValue];
15375                     else if(MS0->S7.fluctuate == 2)
15376                         U->C.S_C.cWT = [value doubleValue];
15377                     if(MS0->S7.extendFlag)
15378                         if(U->C.S_C.cWT > U->C.S_M.cWT)
15379                             U->C.S_C.cWT = U->C.S_M.cWT;
15380                     if(U->C.S_C.cWT < 0)
15381                         U->C.S_C.cWT = 0;
15382                     break;
15383                 case 26:
15384                     if(MS0->S7.fluctuate == 0)
15385                         U->C.S_C.vigor += [value doubleValue];
15386                     else if(MS0->S7.fluctuate == 1)
15387                         U->C.S_C.vigor -= [value doubleValue];
15388                     else if(MS0->S7.fluctuate == 2)
15389                         U->C.S_C.vigor = [value doubleValue];
15390                     if(MS0->S7.extendFlag)
15391                         if(U->C.S_C.vigor > U->C.S_M.vigor)
15392                             U->C.S_C.vigor = U->C.S_M.vigor;
15393                     if(U->C.S_C.vigor < 0)
15394                         U->C.S_C.vigor = 0;
15395                     break;
15396
15397                 default:
15398                     break;
15399             }
15400
15401         }else{
15402
15403             switch (MS0->S7.type) {
15404                 case 0:
15405                     if(MS0->S7.fluctuate == 0)
15406                         U->C.S_C.HP += U->C.S_M.HP*[value doubleValue]/100;
15407                     else if(MS0->S7.fluctuate == 1)
15408                         U->C.S_C.HP -= U->C.S_M.HP*[value doubleValue]/100;
15409                     else if(MS0->S7.fluctuate == 2)
15410                         U->C.S_C.HP = U->C.S_M.HP*[value doubleValue]/100;
15411                     if(MS0->S7.extendFlag)
15412                     if(U->C.S_C.HP > U->C.S_M.HP)
15413                         U->C.S_C.HP = U->C.S_M.HP;
15414                     if(U->C.S_C.HP < 0)
15415                         U->C.S_C.HP = 0;
15416                     break;
15417                 case 1:
15418                     if(MS0->S7.fluctuate == 0)
15419                         U->C.S_C.MP += U->C.S_M.MP*[value doubleValue]/100;
15420                     else if(MS0->S7.fluctuate == 1)
15421                         U->C.S_C.MP -= U->C.S_M.MP*[value doubleValue]/100;
15422                     else if(MS0->S7.fluctuate == 2)
15423                         U->C.S_C.MP = U->C.S_M.MP*[value doubleValue]/100;
15424                     if(MS0->S7.extendFlag)
15425                     if(U->C.S_C.MP > U->C.S_M.MP)
15426                         U->C.S_C.MP = U->C.S_M.MP;
15427                     if(U->C.S_C.MP < 0)
15428                         U->C.S_C.MP = 0;
15429                     break;
15430                 case 2:
15431                     if(MS0->S7.fluctuate == 0)
15432                         U->C.S_C.WT += U->C.S_M.WT*[value doubleValue]/100;
15433                     else if(MS0->S7.fluctuate == 1)
15434                         U->C.S_C.WT -= U->C.S_M.WT*[value doubleValue]/100;
15435                     else if(MS0->S7.fluctuate == 2)
15436                         U->C.S_C.MP = U->C.S_M.WT*[value doubleValue]/100;
15437                     if(MS0->S7.extendFlag)
15438                     if(U->C.S_C.WT > U->C.S_M.WT)
15439                         U->C.S_C.WT = U->C.S_M.WT;
15440                     if(U->C.S_C.WT < 0)
15441                         U->C.S_C.WT = 0;
15442                     break;
15443                 case 3:
15444                     if(MS0->S7.fluctuate == 0)
15445                         U->C.S_C.STR += U->C.S_M.STR*[value doubleValue]/100;
15446                     else if(MS0->S7.fluctuate == 1)
15447                         U->C.S_C.STR -= U->C.S_M.STR*[value doubleValue]/100;
15448                     else if(MS0->S7.fluctuate == 2)
15449                         U->C.S_C.STR = U->C.S_M.STR*[value doubleValue]/100;
15450                     if(MS0->S7.extendFlag)
15451                     if(U->C.S_C.STR > U->C.S_M.STR)
15452                         U->C.S_C.STR = U->C.S_M.STR;
15453                     if(U->C.S_C.STR < 0)
15454                         U->C.S_C.STR = 0;
15455                     break;
15456                 case 4:
15457                     if(MS0->S7.fluctuate == 0)
15458                         U->C.S_C.VIT += U->C.S_M.VIT*[value doubleValue]/100;
15459                     else if(MS0->S7.fluctuate == 1)
15460                         U->C.S_C.VIT -= U->C.S_M.VIT*[value doubleValue]/100;
15461                     else if(MS0->S7.fluctuate == 2)
15462                         U->C.S_C.VIT = U->C.S_M.VIT*[value doubleValue]/100;
15463                     if(MS0->S7.extendFlag)
15464                     if(U->C.S_C.VIT > U->C.S_M.VIT)
15465                         U->C.S_C.VIT = U->C.S_M.VIT;
15466                     if(U->C.S_C.VIT < 0)
15467                         U->C.S_C.VIT = 0;
15468                     break;
15469                 case 5:
15470                     if(MS0->S7.fluctuate == 0)
15471                         U->C.S_C.AGI += U->C.S_M.AGI*[value doubleValue]/100;
15472                     else if(MS0->S7.fluctuate == 1)
15473                         U->C.S_C.AGI -= U->C.S_M.AGI*[value doubleValue]/100;
15474                     else if(MS0->S7.fluctuate == 2)
15475                         U->C.S_C.AGI = U->C.S_M.AGI*[value doubleValue]/100;
15476                     if(MS0->S7.extendFlag)
15477                     if(U->C.S_C.AGI > U->C.S_M.AGI)
15478                         U->C.S_C.AGI = U->C.S_M.AGI;
15479                     if(U->C.S_C.AGI < 0)
15480                         U->C.S_C.AGI = 0;
15481                     break;
15482                 case 6:
15483                     if(MS0->S7.fluctuate == 0)
15484                         U->C.S_C.DEX += U->C.S_M.DEX*[value doubleValue]/100;
15485                     else if(MS0->S7.fluctuate == 1)
15486                         U->C.S_C.DEX -= U->C.S_M.DEX*[value doubleValue]/100;
15487                     else if(MS0->S7.fluctuate == 2)
15488                         U->C.S_C.DEX = U->C.S_M.DEX*[value doubleValue]/100;
15489                     if(MS0->S7.extendFlag)
15490                     if(U->C.S_C.DEX > U->C.S_M.DEX)
15491                         U->C.S_C.DEX = U->C.S_M.DEX;
15492                     if(U->C.S_C.DEX < 0)
15493                         U->C.S_C.DEX = 0;
15494                     break;
15495                 case 7:
15496                     if(MS0->S7.fluctuate == 0)
15497                         U->C.S_C.MEN += U->C.S_M.MEN*[value doubleValue]/100;
15498                     else if(MS0->S7.fluctuate == 1)
15499                         U->C.S_C.MEN -= U->C.S_M.MEN*[value doubleValue]/100;
15500                     else if(MS0->S7.fluctuate == 2)
15501                         U->C.S_C.MEN = U->C.S_M.MEN*[value doubleValue]/100;
15502                     if(MS0->S7.extendFlag)
15503                     if(U->C.S_C.MEN > U->C.S_M.MEN)
15504                         U->C.S_C.MEN = U->C.S_M.MEN;
15505                     if(U->C.S_C.MEN < 0)
15506                         U->C.S_C.MEN = 0;
15507                     break;
15508                 case 8:
15509                     if(MS0->S7.fluctuate == 0)
15510                         U->C.S_C.INT += U->C.S_M.INT*[value doubleValue]/100;
15511                     else if(MS0->S7.fluctuate == 1)
15512                         U->C.S_C.INT -= U->C.S_M.INT*[value doubleValue]/100;
15513                     else if(MS0->S7.fluctuate == 2)
15514                         U->C.S_C.INT = U->C.S_M.INT*[value doubleValue]/100;
15515                     if(MS0->S7.extendFlag)
15516                     if(U->C.S_C.INT > U->C.S_M.INT)
15517                         U->C.S_C.INT = U->C.S_M.INT;
15518                     if(U->C.S_C.INT < 0)
15519                         U->C.S_C.INT = 0;
15520                     break;
15521                 case 9:
15522                     if(MS0->S7.fluctuate == 0)
15523                         U->C.S_C.LUK += U->C.S_M.LUK*[value doubleValue]/100;
15524                     else if(MS0->S7.fluctuate == 1)
15525                         U->C.S_C.LUK -= U->C.S_M.LUK*[value doubleValue]/100;
15526                     else if(MS0->S7.fluctuate == 2)
15527                         U->C.S_C.LUK = U->C.S_M.LUK*[value doubleValue]/100;
15528                     if(MS0->S7.extendFlag)
15529                     if(U->C.S_C.LUK > U->C.S_M.LUK)
15530                         U->C.S_C.LUK = U->C.S_M.LUK;
15531                     if(U->C.S_C.LUK < 0)
15532                         U->C.S_C.LUK = 0;
15533                     break;
15534                 case 10:
15535                     if(MS0->S7.fluctuate == 0)
15536                         U->C.S_C.MOV += U->C.S_M.MOV*[value doubleValue]/100;
15537                     else if(MS0->S7.fluctuate == 1)
15538                         U->C.S_C.MOV -= U->C.S_M.MOV*[value doubleValue]/100;
15539                     else if(MS0->S7.fluctuate == 2)
15540                         U->C.S_C.MOV = U->C.S_M.MOV*[value doubleValue]/100;
15541                     if(MS0->S7.extendFlag)
15542                     if(U->C.S_C.MOV > U->C.S_M.MOV)
15543                         U->C.S_C.MOV = U->C.S_M.MOV;
15544                     if(U->C.S_C.MOV < 0)
15545                         U->C.S_C.MOV = 0;
15546                     break;
15547                 case 11:
15548                     if(MS0->S7.fluctuate == 0)
15549                         U->C.S_C.MEL += U->C.S_M.MEL*[value doubleValue]/100;
15550                     else if(MS0->S7.fluctuate == 1)
15551                         U->C.S_C.MEL -= U->C.S_M.MEL*[value doubleValue]/100;
15552                     else if(MS0->S7.fluctuate == 2)
15553                         U->C.S_C.MEL = U->C.S_M.MEL*[value doubleValue]/100;
15554                     if(MS0->S7.extendFlag)
15555                     if(U->C.S_C.MEL > U->C.S_M.MEL)
15556                         U->C.S_C.MEL = U->C.S_M.MEL;
15557                     if(U->C.S_C.MEL < 0)
15558                         U->C.S_C.MEL = 0;
15559                     break;
15560                 case 12:
15561                     if(MS0->S7.fluctuate == 0)
15562                         U->C.S_C.MIS += U->C.S_M.MIS*[value doubleValue]/100;
15563                     else if(MS0->S7.fluctuate == 1)
15564                         U->C.S_C.MIS -= U->C.S_M.MIS*[value doubleValue]/100;
15565                     else if(MS0->S7.fluctuate == 2)
15566                         U->C.S_C.MIS = U->C.S_M.MIS*[value doubleValue]/100;
15567                     if(MS0->S7.extendFlag)
15568                     if(U->C.S_C.MIS > U->C.S_M.MIS)
15569                         U->C.S_C.MIS = U->C.S_M.MIS;
15570                     if(U->C.S_C.MIS < 0)
15571                         U->C.S_C.MIS = 0;
15572                     break;
15573                 case 13:
15574                     if(MS0->S7.fluctuate == 0)
15575                         U->C.S_C.HIT += U->C.S_M.HIT*[value doubleValue]/100;
15576                     else if(MS0->S7.fluctuate == 1)
15577                         U->C.S_C.HIT -= U->C.S_M.HIT*[value doubleValue]/100;
15578                     else if(MS0->S7.fluctuate == 2)
15579                         U->C.S_C.HIT = U->C.S_M.HIT*[value doubleValue]/100;
15580                     if(MS0->S7.extendFlag)
15581                     if(U->C.S_C.HIT > U->C.S_M.HIT)
15582                         U->C.S_C.HIT = U->C.S_M.HIT;
15583                     if(U->C.S_C.HIT < 0)
15584                         U->C.S_C.HIT = 0;
15585                     break;
15586                 case 14:
15587                     if(MS0->S7.fluctuate == 0)
15588                         U->C.S_C.DOD += U->C.S_M.DOD*[value doubleValue]/100;
15589                     else if(MS0->S7.fluctuate == 1)
15590                         U->C.S_C.DOD -= U->C.S_M.DOD*[value doubleValue]/100;
15591                     else if(MS0->S7.fluctuate == 2)
15592                         U->C.S_C.DOD = U->C.S_M.DOD*[value doubleValue]/100;
15593                     if(MS0->S7.extendFlag)
15594                     if(U->C.S_C.HIT > U->C.S_M.DOD)
15595                         U->C.S_C.DOD = U->C.S_M.DOD;
15596                     if(U->C.S_C.DOD < 0)
15597                         U->C.S_C.DOD = 0;
15598                     break;
15599                 case 15:
15600                     if(MS0->S7.fluctuate == 0)
15601                         U->C.S_C.REA += U->C.S_M.REA*[value doubleValue]/100;
15602                     else if(MS0->S7.fluctuate == 1)
15603                         U->C.S_C.REA -= U->C.S_M.REA*[value doubleValue]/100;
15604                     else if(MS0->S7.fluctuate == 2)
15605                         U->C.S_C.REA = U->C.S_M.REA*[value doubleValue]/100;
15606                     if(MS0->S7.extendFlag)
15607                     if(U->C.S_C.REA > U->C.S_M.REA)
15608                         U->C.S_C.REA = U->C.S_M.REA;
15609                     if(U->C.S_C.REA < 0)
15610                         U->C.S_C.REA = 0;
15611                     break;
15612                 case 16:
15613                     if(MS0->S7.fluctuate == 0)
15614                         U->C.S_C.SKI += U->C.S_M.SKI*[value doubleValue]/100;
15615                     else if(MS0->S7.fluctuate == 1)
15616                         U->C.S_C.SKI -= U->C.S_M.SKI*[value doubleValue]/100;
15617                     else if(MS0->S7.fluctuate == 2)
15618                         U->C.S_C.SKI = U->C.S_M.SKI*[value doubleValue]/100;
15619                     if(MS0->S7.extendFlag)
15620                     if(U->C.S_C.SKI > U->C.S_M.SKI)
15621                         U->C.S_C.SKI = U->C.S_M.SKI;
15622                     if(U->C.S_C.SKI < 0)
15623                         U->C.S_C.SKI = 0;
15624                     break;
15625                 case 17:
15626                     U->C.name =  [MS0->S7.value retain];
15627                     break;
15628                 case 18:
15629                     U->C.nameNick =  [MS0->S7.value retain];
15630                     break;
15631                 case 19:
15632                     U->C.nameClass =  [MS0->S7.value retain];
15633                     break;
15634                 case 20:
15635                     U->C.S_C.typeMONS =  [MS0->S7.value doubleValue];
15636                     break;
15637                 case 21:
15638                     U->C.S_C.typeMOVE =  [MS0->S7.value doubleValue];
15639                     break;
15640                 case 22:
15641                     if(MS0->S7.fluctuate == 0)
15642                         U->C.S_C.cSupply += U->C.S_M.cSupply*[value doubleValue]/100;
15643                     else if(MS0->S7.fluctuate == 1)
15644                         U->C.S_C.cSupply -= U->C.S_M.cSupply*[value doubleValue]/100;
15645                     else if(MS0->S7.fluctuate == 2)
15646                         U->C.S_C.cSupply = U->C.S_M.cSupply*[value doubleValue]/100;
15647                     if(MS0->S7.extendFlag)
15648                     if(U->C.S_C.cSupply > U->C.S_M.cSupply)
15649                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15650                     if(U->C.S_C.cSupply < 0)
15651                         U->C.S_C.cSupply = 0;
15652                     break;
15653                 case 23:
15654                     if(MS0->S7.fluctuate == 0)
15655                         U->C.S_C.cFood += U->C.S_M.cFood*[value doubleValue]/100;
15656                     else if(MS0->S7.fluctuate == 1)
15657                         U->C.S_C.cFood -= U->C.S_M.cFood*[value doubleValue]/100;
15658                     else if(MS0->S7.fluctuate == 2)
15659                         U->C.S_C.cFood = U->C.S_M.cFood*[value doubleValue]/100;
15660                     if(MS0->S7.extendFlag)
15661                     if(U->C.S_C.cFood > U->C.S_M.cFood)
15662                         U->C.S_C.cFood = U->C.S_M.cFood;
15663                     if(U->C.S_C.cFood < 0)
15664                         U->C.S_C.cFood = 0;
15665                     break;
15666                 case 24:
15667                     if(MS0->S7.fluctuate == 0)
15668                         U->C.S_C.cMoney += U->C.S_M.cMoney*[value doubleValue]/100;
15669                     else if(MS0->S7.fluctuate == 1)
15670                         U->C.S_C.cMoney -= U->C.S_M.cMoney*[value doubleValue]/100;
15671                     else if(MS0->S7.fluctuate == 2)
15672                         U->C.S_C.cMoney = U->C.S_M.cMoney*[value doubleValue]/100;
15673                     if(MS0->S7.extendFlag)
15674                     if(U->C.S_C.cMoney > U->C.S_M.cMoney)
15675                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15676                     if(U->C.S_C.cMoney < 0)
15677                         U->C.S_C.cMoney = 0;
15678                     break;
15679                 case 25:
15680                     if(MS0->S7.fluctuate == 0)
15681                         U->C.S_C.cWT += U->C.S_M.cWT*[value doubleValue]/100;
15682                     else if(MS0->S7.fluctuate == 1)
15683                         U->C.S_C.cWT -= U->C.S_M.cWT*[value doubleValue]/100;
15684                     else if(MS0->S7.fluctuate == 2)
15685                         U->C.S_C.cWT = U->C.S_M.cWT*[value doubleValue]/100;
15686                     if(MS0->S7.extendFlag)
15687                     if(U->C.S_C.cWT > U->C.S_M.cWT)
15688                         U->C.S_C.cWT = U->C.S_M.cWT;
15689                     if(U->C.S_C.cWT < 0)
15690                         U->C.S_C.cWT = 0;
15691                     break;
15692                 case 26:
15693                     if(MS0->S7.fluctuate == 0)
15694                         U->C.S_C.vigor += U->C.S_M.vigor*[value doubleValue]/100;
15695                     else if(MS0->S7.fluctuate == 1)
15696                         U->C.S_C.vigor -= U->C.S_M.vigor*[value doubleValue]/100;
15697                     else if(MS0->S7.fluctuate == 2)
15698                         U->C.S_C.vigor = U->C.S_M.vigor*[value doubleValue]/100;
15699                     if(MS0->S7.extendFlag)
15700                         if(U->C.S_C.vigor > U->C.S_M.vigor)
15701                             U->C.S_C.vigor = U->C.S_M.vigor;
15702                     if(U->C.S_C.vigor < 0)
15703                         U->C.S_C.vigor = 0;
15704                     break;
15705                 default:
15706                     break;
15707             }
15708         }
15709
15710     }else{
15711
15712         if (!MS0->S7.percentFlag) {
15713
15714             switch (MS0->S7.type) {
15715                 case 0:
15716                     if(MS0->S7.fluctuate == 0)
15717                         U->C.S_M.HP += [value doubleValue];
15718                     else if(MS0->S7.fluctuate == 1)
15719                         U->C.S_M.HP -= [value doubleValue];
15720                     else if(MS0->S7.fluctuate == 2)
15721                         U->C.S_M.HP = [value doubleValue];
15722
15723                     if(U->C.S_M.HP < 0)
15724                         U->C.S_M.HP = 0;
15725                     if(MS0->S7.extendFlag)
15726                         U->C.S_C.HP = U->C.S_M.HP;
15727                     break;
15728                 case 1:
15729                     if(MS0->S7.fluctuate == 0)
15730                         U->C.S_M.MP += [value doubleValue];
15731                     else if(MS0->S7.fluctuate == 1)
15732                         U->C.S_M.MP -= [value doubleValue];
15733                     else if(MS0->S7.fluctuate == 2)
15734                         U->C.S_M.MP = [value doubleValue];
15735
15736                     if(U->C.S_M.MP < 0)
15737                         U->C.S_M.MP = 0;
15738                     if(MS0->S7.extendFlag)
15739                         U->C.S_C.MP = U->C.S_M.MP;
15740                     break;
15741                 case 2:
15742                     if(MS0->S7.fluctuate == 0)
15743                         U->C.S_M.WT += [value doubleValue];
15744                     else if(MS0->S7.fluctuate == 1)
15745                         U->C.S_M.WT -= [value doubleValue];
15746                     else if(MS0->S7.fluctuate == 2)
15747                         U->C.S_M.WT = [value doubleValue];
15748
15749                     if(U->C.S_M.WT < 0)
15750                         U->C.S_M.WT = 0;
15751                     if(MS0->S7.extendFlag)
15752                         U->C.S_C.WT = U->C.S_M.WT;
15753                     break;
15754                 case 3:
15755                     if(MS0->S7.fluctuate == 0)
15756                         U->C.S_M.STR += [value doubleValue];
15757                     else if(MS0->S7.fluctuate == 1)
15758                         U->C.S_M.STR -= [value doubleValue];
15759                     else if(MS0->S7.fluctuate == 2)
15760                         U->C.S_M.STR = [value doubleValue];
15761
15762                     if(U->C.S_M.STR < 0)
15763                         U->C.S_M.STR = 0;
15764                     if(MS0->S7.extendFlag)
15765                         U->C.S_C.STR = U->C.S_M.STR;
15766                     break;
15767                 case 4:
15768                     if(MS0->S7.fluctuate == 0)
15769                         U->C.S_M.VIT += [value doubleValue];
15770                     else if(MS0->S7.fluctuate == 1)
15771                         U->C.S_M.VIT -= [value doubleValue];
15772                     else if(MS0->S7.fluctuate == 2)
15773                         U->C.S_M.VIT = [value doubleValue];
15774
15775                     if(U->C.S_M.VIT < 0)
15776                         U->C.S_M.VIT = 0;
15777                     if(MS0->S7.extendFlag)
15778                         U->C.S_C.VIT = U->C.S_M.VIT;
15779                     break;
15780                 case 5:
15781                     if(MS0->S7.fluctuate == 0)
15782                         U->C.S_M.AGI += [value doubleValue];
15783                     else if(MS0->S7.fluctuate == 1)
15784                         U->C.S_M.AGI -= [value doubleValue];
15785                     else if(MS0->S7.fluctuate == 2)
15786                         U->C.S_M.AGI = [value doubleValue];
15787
15788                     if(U->C.S_M.AGI < 0)
15789                         U->C.S_M.AGI = 0;
15790                     if(MS0->S7.extendFlag)
15791                         U->C.S_C.AGI = U->C.S_M.AGI;
15792                     break;
15793                 case 6:
15794                     if(MS0->S7.fluctuate == 0)
15795                         U->C.S_M.DEX += [value doubleValue];
15796                     else if(MS0->S7.fluctuate == 1)
15797                         U->C.S_M.DEX -= [value doubleValue];
15798                     else if(MS0->S7.fluctuate == 2)
15799                         U->C.S_M.DEX = [value doubleValue];
15800
15801                     if(U->C.S_M.DEX < 0)
15802                         U->C.S_M.DEX = 0;
15803                     if(MS0->S7.extendFlag)
15804                         U->C.S_C.DEX = U->C.S_M.DEX;
15805                     break;
15806                 case 7:
15807                     if(MS0->S7.fluctuate == 0)
15808                         U->C.S_M.MEN += [value doubleValue];
15809                     else if(MS0->S7.fluctuate == 1)
15810                         U->C.S_M.MEN -= [value doubleValue];
15811                     else if(MS0->S7.fluctuate == 2)
15812                         U->C.S_M.MEN = [value doubleValue];
15813
15814                     if(U->C.S_M.MEN < 0)
15815                         U->C.S_M.MEN = 0;
15816                     if(MS0->S7.extendFlag)
15817                         U->C.S_C.MEN = U->C.S_M.MEN;
15818                     break;
15819                 case 8:
15820                     if(MS0->S7.fluctuate == 0)
15821                         U->C.S_M.INT += [value doubleValue];
15822                     else if(MS0->S7.fluctuate == 1)
15823                         U->C.S_M.INT -= [value doubleValue];
15824                     else if(MS0->S7.fluctuate == 2)
15825                         U->C.S_M.INT = [value doubleValue];
15826
15827                     if(U->C.S_M.INT < 0)
15828                         U->C.S_M.INT = 0;
15829                     if(MS0->S7.extendFlag)
15830                         U->C.S_C.INT = U->C.S_M.INT;
15831                     break;
15832                 case 9:
15833                     if(MS0->S7.fluctuate == 0)
15834                         U->C.S_M.LUK += [value doubleValue];
15835                     else if(MS0->S7.fluctuate == 1)
15836                         U->C.S_M.LUK -= [value doubleValue];
15837                     else if(MS0->S7.fluctuate == 2)
15838                         U->C.S_M.LUK = [value doubleValue];
15839
15840                     if(U->C.S_M.LUK < 0)
15841                         U->C.S_M.LUK = 0;
15842                     if(MS0->S7.extendFlag)
15843                         U->C.S_C.LUK = U->C.S_M.LUK;
15844                     break;
15845                 case 10:
15846                     if(MS0->S7.fluctuate == 0)
15847                         U->C.S_M.MOV += [value doubleValue];
15848                     else if(MS0->S7.fluctuate == 1)
15849                         U->C.S_M.MOV -= [value doubleValue];
15850                     else if(MS0->S7.fluctuate == 2)
15851                         U->C.S_M.MOV = [value doubleValue];
15852
15853                     if(U->C.S_M.MOV < 0)
15854                         U->C.S_M.MOV = 0;
15855                     if(MS0->S7.extendFlag)
15856                         U->C.S_C.MOV = U->C.S_M.MOV;
15857                     break;
15858                 case 11:
15859                     if(MS0->S7.fluctuate == 0)
15860                         U->C.S_M.MEL += [value doubleValue];
15861                     else if(MS0->S7.fluctuate == 1)
15862                         U->C.S_M.MEL -= [value doubleValue];
15863                     else if(MS0->S7.fluctuate == 2)
15864                         U->C.S_M.MEL = [value doubleValue];
15865
15866                     if(U->C.S_M.MEL < 0)
15867                         U->C.S_M.MEL = 0;
15868                     if(MS0->S7.extendFlag)
15869                         U->C.S_C.MEL = U->C.S_M.MEL;
15870                     break;
15871                 case 12:
15872                     if(MS0->S7.fluctuate == 0)
15873                         U->C.S_M.MIS += [value doubleValue];
15874                     else if(MS0->S7.fluctuate == 1)
15875                         U->C.S_M.MIS -= [value doubleValue];
15876                     else if(MS0->S7.fluctuate == 2)
15877                         U->C.S_M.MIS = [value doubleValue];
15878
15879                     if(U->C.S_M.MIS < 0)
15880                         U->C.S_M.MIS = 0;
15881                     if(MS0->S7.extendFlag)
15882                         U->C.S_C.MIS = U->C.S_M.MIS;
15883
15884                     break;
15885                 case 13:
15886                     if(MS0->S7.fluctuate == 0)
15887                         U->C.S_M.HIT += [value doubleValue];
15888                     else if(MS0->S7.fluctuate == 1)
15889                         U->C.S_M.HIT -= [value doubleValue];
15890                     else if(MS0->S7.fluctuate == 2)
15891                         U->C.S_M.HIT = [value doubleValue];
15892
15893                     if(U->C.S_M.HIT < 0)
15894                         U->C.S_M.HIT = 0;
15895                     if(MS0->S7.extendFlag)
15896                         U->C.S_C.HIT = U->C.S_M.HIT;
15897                     break;
15898                 case 14:
15899                     if(MS0->S7.fluctuate == 0)
15900                         U->C.S_M.DOD += [value doubleValue];
15901                     else if(MS0->S7.fluctuate == 1)
15902                         U->C.S_M.DOD -= [value doubleValue];
15903                     else if(MS0->S7.fluctuate == 2)
15904                         U->C.S_M.DOD = [value doubleValue];
15905
15906                     if(U->C.S_M.DOD < 0)
15907                         U->C.S_M.DOD = 0;
15908                     if(MS0->S7.extendFlag)
15909                         U->C.S_C.DOD = U->C.S_M.DOD;
15910                     break;
15911                 case 15:
15912                     if(MS0->S7.fluctuate == 0)
15913                         U->C.S_M.REA += [value doubleValue];
15914                     else if(MS0->S7.fluctuate == 1)
15915                         U->C.S_M.REA -= [value doubleValue];
15916                     else if(MS0->S7.fluctuate == 2)
15917                         U->C.S_M.REA = [value doubleValue];
15918
15919                     if(U->C.S_M.REA < 0)
15920                         U->C.S_M.REA = 0;
15921                     if(MS0->S7.extendFlag)
15922                         U->C.S_C.REA = U->C.S_M.REA;
15923                     break;
15924                 case 16:
15925                     if(MS0->S7.fluctuate == 0)
15926                         U->C.S_M.SKI += [value doubleValue];
15927                     else if(MS0->S7.fluctuate == 1)
15928                         U->C.S_M.SKI -= [value doubleValue];
15929                     else if(MS0->S7.fluctuate == 2)
15930                         U->C.S_M.SKI = [value doubleValue];
15931
15932                     if(U->C.S_M.SKI < 0)
15933                         U->C.S_M.SKI = 0;
15934                     if(MS0->S7.extendFlag)
15935                         U->C.S_C.SKI = U->C.S_M.SKI;
15936                     break;
15937                 case 17:
15938                     U->C.name =  [value retain];
15939                     break;
15940                 case 18:
15941                     U->C.nameNick =  [value retain];
15942                     break;
15943                 case 19:
15944                     U->C.nameClass =  [value retain];
15945                     break;
15946                 case 20:
15947                     U->C.S_C.typeMONS =  [value doubleValue];
15948                     break;
15949                 case 21:
15950                     U->C.S_C.typeMOVE =  [value doubleValue];
15951                     break;
15952                 case 22:
15953                     if(MS0->S7.fluctuate == 0)
15954                         U->C.S_M.cSupply += [value doubleValue];
15955                     else if(MS0->S7.fluctuate == 1)
15956                         U->C.S_M.cSupply -= [value doubleValue];
15957                     else if(MS0->S7.fluctuate == 2)
15958                         U->C.S_M.cSupply = [value doubleValue];
15959
15960                     if(U->C.S_M.cSupply < 0)
15961                         U->C.S_M.cSupply = 0;
15962                     if(MS0->S7.extendFlag)
15963                         U->C.S_C.cSupply = U->C.S_M.cSupply;
15964                     break;
15965                 case 23:
15966                     if(MS0->S7.fluctuate == 0)
15967                         U->C.S_M.cFood += [value doubleValue];
15968                     else if(MS0->S7.fluctuate == 1)
15969                         U->C.S_M.cFood -= [value doubleValue];
15970                     else if(MS0->S7.fluctuate == 2)
15971                         U->C.S_M.cFood = [value doubleValue];
15972
15973                     if(U->C.S_M.cFood < 0)
15974                         U->C.S_M.cFood = 0;
15975                     if(MS0->S7.extendFlag)
15976                         U->C.S_C.cFood = U->C.S_M.cFood;
15977                     break;
15978                 case 24:
15979                     if(MS0->S7.fluctuate == 0)
15980                         U->C.S_M.cMoney += [value doubleValue];
15981                     else if(MS0->S7.fluctuate == 1)
15982                         U->C.S_M.cMoney -= [value doubleValue];
15983                     else if(MS0->S7.fluctuate == 2)
15984                         U->C.S_M.cMoney = [value doubleValue];
15985                     if(U->C.S_M.cMoney < 0)
15986                         U->C.S_M.cMoney = 0;
15987                     if(MS0->S7.extendFlag)
15988                         U->C.S_C.cMoney = U->C.S_M.cMoney;
15989                     break;
15990                 case 25:
15991                     if(MS0->S7.fluctuate == 0)
15992                         U->C.S_M.cWT += [value doubleValue];
15993                     else if(MS0->S7.fluctuate == 1)
15994                         U->C.S_M.cWT -= [value doubleValue];
15995                     else if(MS0->S7.fluctuate == 2)
15996                         U->C.S_M.cWT = [value doubleValue];
15997                     if(U->C.S_M.cWT < 0)
15998                         U->C.S_M.cWT = 0;
15999                     if(MS0->S7.extendFlag)
16000                         U->C.S_C.cWT = U->C.S_M.cWT;
16001                     break;
16002                 case 26:
16003                     if(MS0->S7.fluctuate == 0)
16004                         U->C.S_M.vigor += [value doubleValue];
16005                     else if(MS0->S7.fluctuate == 1)
16006                         U->C.S_M.vigor -= [value doubleValue];
16007                     else if(MS0->S7.fluctuate == 2)
16008                         U->C.S_M.vigor = [value doubleValue];
16009                     if(U->C.S_M.vigor < 0)
16010                         U->C.S_M.vigor = 0;
16011                     if(MS0->S7.extendFlag)
16012                         U->C.S_C.vigor = U->C.S_M.vigor;
16013                     break;
16014
16015                 default:
16016                     break;
16017             }
16018
16019         }else{
16020
16021             switch (MS0->S7.type) {
16022                 case 0:
16023                     if(MS0->S7.fluctuate == 0)
16024                         U->C.S_M.HP += U->C.S_M.HP*[value doubleValue]/100;
16025                     else if(MS0->S7.fluctuate == 1)
16026                         U->C.S_M.HP -= U->C.S_M.HP*[value doubleValue]/100;
16027                     else if(MS0->S7.fluctuate == 2)
16028                         U->C.S_M.HP = U->C.S_M.HP*[value doubleValue]/100;
16029
16030                     if(U->C.S_M.HP < 0)
16031                         U->C.S_M.HP = 0;
16032                     if(MS0->S7.extendFlag)
16033                         U->C.S_C.HP = U->C.S_M.HP;
16034                     break;
16035                 case 1:
16036                     if(MS0->S7.fluctuate == 0)
16037                         U->C.S_M.MP += U->C.S_M.MP*[value doubleValue]/100;
16038                     else if(MS0->S7.fluctuate == 1)
16039                         U->C.S_M.MP -= U->C.S_M.MP*[value doubleValue]/100;
16040                     else if(MS0->S7.fluctuate == 2)
16041                         U->C.S_M.MP = U->C.S_M.MP*[value doubleValue]/100;
16042
16043                     if(U->C.S_M.MP < 0)
16044                         U->C.S_M.MP = 0;
16045                     if(MS0->S7.extendFlag)
16046                         U->C.S_C.MP = U->C.S_M.MP;
16047                     break;
16048                 case 2:
16049                     if(MS0->S7.fluctuate == 0)
16050                         U->C.S_M.WT += U->C.S_M.WT*[value doubleValue]/100;
16051                     else if(MS0->S7.fluctuate == 1)
16052                         U->C.S_M.WT -= U->C.S_M.WT*[value doubleValue]/100;
16053                     else if(MS0->S7.fluctuate == 2)
16054                         U->C.S_M.MP = U->C.S_M.WT*[value doubleValue]/100;
16055
16056                     if(U->C.S_M.WT < 0)
16057                         U->C.S_M.WT = 0;
16058                     if(MS0->S7.extendFlag)
16059                         U->C.S_C.WT = U->C.S_M.WT;
16060                     break;
16061                 case 3:
16062                     if(MS0->S7.fluctuate == 0)
16063                         U->C.S_M.STR += U->C.S_M.STR*[value doubleValue]/100;
16064                     else if(MS0->S7.fluctuate == 1)
16065                         U->C.S_M.STR -= U->C.S_M.STR*[value doubleValue]/100;
16066                     else if(MS0->S7.fluctuate == 2)
16067                         U->C.S_M.STR = U->C.S_M.STR*[value doubleValue]/100;
16068
16069                     if(U->C.S_M.STR < 0)
16070                         U->C.S_M.STR = 0;
16071                     if(MS0->S7.extendFlag)
16072                         U->C.S_C.STR = U->C.S_M.STR;
16073                     break;
16074                 case 4:
16075                     if(MS0->S7.fluctuate == 0)
16076                         U->C.S_M.VIT += U->C.S_M.VIT*[value doubleValue]/100;
16077                     else if(MS0->S7.fluctuate == 1)
16078                         U->C.S_M.VIT -= U->C.S_M.VIT*[value doubleValue]/100;
16079                     else if(MS0->S7.fluctuate == 2)
16080                         U->C.S_M.VIT = U->C.S_M.VIT*[value doubleValue]/100;
16081
16082                     if(U->C.S_M.VIT < 0)
16083                         U->C.S_M.VIT = 0;
16084                     if(MS0->S7.extendFlag)
16085                         U->C.S_C.VIT = U->C.S_M.VIT;
16086                     break;
16087                 case 5:
16088                     if(MS0->S7.fluctuate == 0)
16089                         U->C.S_M.AGI += U->C.S_M.AGI*[value doubleValue]/100;
16090                     else if(MS0->S7.fluctuate == 1)
16091                         U->C.S_M.AGI -= U->C.S_M.AGI*[value doubleValue]/100;
16092                     else if(MS0->S7.fluctuate == 2)
16093                         U->C.S_M.AGI = U->C.S_M.AGI*[value doubleValue]/100;
16094
16095                     if(U->C.S_M.AGI < 0)
16096                         U->C.S_M.AGI = 0;
16097                     if(MS0->S7.extendFlag)
16098                         U->C.S_C.AGI = U->C.S_M.AGI;
16099                     break;
16100                 case 6:
16101                     if(MS0->S7.fluctuate == 0)
16102                         U->C.S_M.DEX += U->C.S_M.DEX*[value doubleValue]/100;
16103                     else if(MS0->S7.fluctuate == 1)
16104                         U->C.S_M.DEX -= U->C.S_M.DEX*[value doubleValue]/100;
16105                     else if(MS0->S7.fluctuate == 2)
16106                         U->C.S_M.DEX = U->C.S_M.DEX*[value doubleValue]/100;
16107
16108                     if(U->C.S_M.DEX < 0)
16109                         U->C.S_M.DEX = 0;
16110                     if(MS0->S7.extendFlag)
16111                         U->C.S_C.DEX = U->C.S_M.DEX;
16112                     break;
16113                 case 7:
16114                     if(MS0->S7.fluctuate == 0)
16115                         U->C.S_M.MEN += U->C.S_M.MEN*[value doubleValue]/100;
16116                     else if(MS0->S7.fluctuate == 1)
16117                         U->C.S_M.MEN -= U->C.S_M.MEN*[value doubleValue]/100;
16118                     else if(MS0->S7.fluctuate == 2)
16119                         U->C.S_M.MEN = U->C.S_M.MEN*[value doubleValue]/100;
16120
16121                     if(U->C.S_M.MEN < 0)
16122                         U->C.S_M.MEN = 0;
16123                     if(MS0->S7.extendFlag)
16124                         U->C.S_C.MEN = U->C.S_M.MEN;
16125                     break;
16126                 case 8:
16127                     if(MS0->S7.fluctuate == 0)
16128                         U->C.S_M.INT += U->C.S_M.INT*[value doubleValue]/100;
16129                     else if(MS0->S7.fluctuate == 1)
16130                         U->C.S_M.INT -= U->C.S_M.INT*[value doubleValue]/100;
16131                     else if(MS0->S7.fluctuate == 2)
16132                         U->C.S_M.INT = U->C.S_M.INT*[value doubleValue]/100;
16133
16134                     if(U->C.S_M.INT < 0)
16135                         U->C.S_M.INT = 0;
16136                     if(MS0->S7.extendFlag)
16137                         U->C.S_C.INT = U->C.S_M.INT;
16138                     break;
16139                 case 9:
16140                     if(MS0->S7.fluctuate == 0)
16141                         U->C.S_M.LUK += U->C.S_M.LUK*[value doubleValue]/100;
16142                     else if(MS0->S7.fluctuate == 1)
16143                         U->C.S_M.LUK -= U->C.S_M.LUK*[value doubleValue]/100;
16144                     else if(MS0->S7.fluctuate == 2)
16145                         U->C.S_M.LUK = U->C.S_M.LUK*[value doubleValue]/100;
16146
16147                     if(U->C.S_M.LUK < 0)
16148                         U->C.S_M.LUK = 0;
16149                     if(MS0->S7.extendFlag)
16150                         U->C.S_C.LUK = U->C.S_M.LUK;
16151                     break;
16152                 case 10:
16153                     if(MS0->S7.fluctuate == 0)
16154                         U->C.S_M.MOV += U->C.S_M.MOV*[value doubleValue]/100;
16155                     else if(MS0->S7.fluctuate == 1)
16156                         U->C.S_M.MOV -= U->C.S_M.MOV*[value doubleValue]/100;
16157                     else if(MS0->S7.fluctuate == 2)
16158                         U->C.S_M.MOV = U->C.S_M.MOV*[value doubleValue]/100;
16159
16160                     if(U->C.S_M.MOV < 0)
16161                         U->C.S_M.MOV = 0;
16162                     if(MS0->S7.extendFlag)
16163                         U->C.S_C.MOV = U->C.S_M.MOV;
16164                     break;
16165                 case 11:
16166                     if(MS0->S7.fluctuate == 0)
16167                         U->C.S_M.MEL += U->C.S_M.MEL*[value doubleValue]/100;
16168                     else if(MS0->S7.fluctuate == 1)
16169                         U->C.S_M.MEL -= U->C.S_M.MEL*[value doubleValue]/100;
16170                     else if(MS0->S7.fluctuate == 2)
16171                         U->C.S_M.MEL = U->C.S_M.MEL*[value doubleValue]/100;
16172
16173                     if(U->C.S_C.MEL < 0)
16174                         U->C.S_M.MEL = 0;
16175                     if(MS0->S7.extendFlag)
16176                         U->C.S_C.MEL = U->C.S_M.MEL;
16177                     break;
16178                 case 12:
16179                     if(MS0->S7.fluctuate == 0)
16180                         U->C.S_C.MIS += U->C.S_M.MIS*[value doubleValue]/100;
16181                     else if(MS0->S7.fluctuate == 1)
16182                         U->C.S_C.MIS -= U->C.S_M.MIS*[value doubleValue]/100;
16183                     else if(MS0->S7.fluctuate == 2)
16184                         U->C.S_C.MIS = U->C.S_M.MIS*[value doubleValue]/100;
16185
16186                     if(U->C.S_C.MIS < 0)
16187                         U->C.S_C.MIS = 0;
16188                     if(MS0->S7.extendFlag)
16189                         U->C.S_C.MIS = U->C.S_M.MIS;
16190                     break;
16191                 case 13:
16192                     if(MS0->S7.fluctuate == 0)
16193                         U->C.S_M.HIT += U->C.S_M.HIT*[value doubleValue]/100;
16194                     else if(MS0->S7.fluctuate == 1)
16195                         U->C.S_M.HIT -= U->C.S_M.HIT*[value doubleValue]/100;
16196                     else if(MS0->S7.fluctuate == 2)
16197                         U->C.S_M.HIT = U->C.S_M.HIT*[value doubleValue]/100;
16198
16199                     if(U->C.S_M.HIT < 0)
16200                         U->C.S_M.HIT = 0;
16201                     if(MS0->S7.extendFlag)
16202                         U->C.S_C.HIT = U->C.S_M.HIT;
16203                     break;
16204                 case 14:
16205                     if(MS0->S7.fluctuate == 0)
16206                         U->C.S_M.DOD += U->C.S_M.DOD*[value doubleValue]/100;
16207                     else if(MS0->S7.fluctuate == 1)
16208                         U->C.S_M.DOD -= U->C.S_M.DOD*[value doubleValue]/100;
16209                     else if(MS0->S7.fluctuate == 2)
16210                         U->C.S_M.DOD = U->C.S_M.DOD*[value doubleValue]/100;
16211
16212                     if(U->C.S_M.DOD < 0)
16213                         U->C.S_M.DOD = 0;
16214                     if(MS0->S7.extendFlag)
16215                         U->C.S_C.DOD = U->C.S_M.DOD;
16216                     break;
16217                 case 15:
16218                     if(MS0->S7.fluctuate == 0)
16219                         U->C.S_M.REA += U->C.S_M.REA*[value doubleValue]/100;
16220                     else if(MS0->S7.fluctuate == 1)
16221                         U->C.S_M.REA -= U->C.S_M.REA*[value doubleValue]/100;
16222                     else if(MS0->S7.fluctuate == 2)
16223                         U->C.S_M.REA = U->C.S_M.REA*[value doubleValue]/100;
16224
16225                     if(U->C.S_M.REA < 0)
16226                         U->C.S_M.REA = 0;
16227                     if(MS0->S7.extendFlag)
16228                         U->C.S_C.REA = U->C.S_M.REA;
16229                     break;
16230                 case 16:
16231                     if(MS0->S7.fluctuate == 0)
16232                         U->C.S_M.SKI += U->C.S_M.SKI*[value doubleValue]/100;
16233                     else if(MS0->S7.fluctuate == 1)
16234                         U->C.S_M.SKI -= U->C.S_M.SKI*[value doubleValue]/100;
16235                     else if(MS0->S7.fluctuate == 2)
16236                         U->C.S_M.SKI = U->C.S_M.SKI*[value doubleValue]/100;
16237
16238                     if(U->C.S_M.SKI < 0)
16239                         U->C.S_M.SKI = 0;
16240                     if(MS0->S7.extendFlag)
16241                         U->C.S_C.SKI = U->C.S_M.SKI;
16242                     break;
16243                 case 17:
16244                     U->C.name =  [MS0->S7.value retain];
16245                     break;
16246                 case 18:
16247                     U->C.nameNick =  [MS0->S7.value retain];
16248                     break;
16249                 case 19:
16250                     U->C.nameClass =  [MS0->S7.value retain];
16251                     break;
16252                 case 20:
16253                     U->C.S_C.typeMONS =  [MS0->S7.value doubleValue];
16254                     break;
16255                 case 21:
16256                     U->C.S_C.typeMOVE =  [MS0->S7.value doubleValue];
16257                     break;
16258                 case 22:
16259                     if(MS0->S7.fluctuate == 0)
16260                         U->C.S_M.cSupply += U->C.S_M.cSupply*[value doubleValue]/100;
16261                     else if(MS0->S7.fluctuate == 1)
16262                         U->C.S_M.cSupply -= U->C.S_M.cSupply*[value doubleValue]/100;
16263                     else if(MS0->S7.fluctuate == 2)
16264                         U->C.S_M.cSupply = U->C.S_M.cSupply*[value doubleValue]/100;
16265
16266                     if(U->C.S_M.cSupply < 0)
16267                         U->C.S_M.cSupply = 0;
16268                     if(MS0->S7.extendFlag)
16269                         U->C.S_C.cSupply = U->C.S_M.cSupply;
16270                     break;
16271                 case 23:
16272                     if(MS0->S7.fluctuate == 0)
16273                         U->C.S_M.cFood += U->C.S_M.cFood*[value doubleValue]/100;
16274                     else if(MS0->S7.fluctuate == 1)
16275                         U->C.S_M.cFood -= U->C.S_M.cFood*[value doubleValue]/100;
16276                     else if(MS0->S7.fluctuate == 2)
16277                         U->C.S_M.cFood = U->C.S_M.cFood*[value doubleValue]/100;
16278
16279
16280                     if(U->C.S_M.cFood < 0)
16281                         U->C.S_M.cFood = 0;
16282                     if(MS0->S7.extendFlag)
16283                         U->C.S_C.cFood = U->C.S_M.cFood;
16284                     break;
16285                 case 24:
16286                     if(MS0->S7.fluctuate == 0)
16287                         U->C.S_M.cMoney += U->C.S_M.cMoney*[value doubleValue]/100;
16288                     else if(MS0->S7.fluctuate == 1)
16289                         U->C.S_M.cMoney -= U->C.S_M.cMoney*[value doubleValue]/100;
16290                     else if(MS0->S7.fluctuate == 2)
16291                         U->C.S_M.cMoney = U->C.S_M.cMoney*[value doubleValue]/100;
16292
16293                     if(U->C.S_M.cMoney < 0)
16294                         U->C.S_M.cMoney = 0;
16295                     if(MS0->S7.extendFlag)
16296                         U->C.S_C.cMoney = U->C.S_M.cMoney;
16297                     break;
16298                 case 25:
16299                     if(MS0->S7.fluctuate == 0)
16300                         U->C.S_M.cWT += U->C.S_M.cWT*[value doubleValue]/100;
16301                     else if(MS0->S7.fluctuate == 1)
16302                         U->C.S_M.cWT -= U->C.S_M.cWT*[value doubleValue]/100;
16303                     else if(MS0->S7.fluctuate == 2)
16304                         U->C.S_M.cWT = U->C.S_M.cWT*[value doubleValue]/100;
16305
16306                     if(U->C.S_M.cWT < 0)
16307                         U->C.S_M.cWT = 0;
16308                     if(MS0->S7.extendFlag)
16309                         U->C.S_C.cWT = U->C.S_M.cWT;
16310                     break;
16311                 case 26:
16312                     if(MS0->S7.fluctuate == 0)
16313                         U->C.S_M.vigor += U->C.S_M.vigor*[value doubleValue]/100;
16314                     else if(MS0->S7.fluctuate == 1)
16315                         U->C.S_M.vigor -= U->C.S_M.vigor*[value doubleValue]/100;
16316                     else if(MS0->S7.fluctuate == 2)
16317                         U->C.S_M.vigor = U->C.S_M.vigor*[value doubleValue]/100;
16318
16319                     if(U->C.S_M.vigor < 0)
16320                         U->C.S_M.vigor = 0;
16321                     if(MS0->S7.extendFlag)
16322                         U->C.S_C.vigor = U->C.S_M.vigor;
16323                     break;
16324
16325                 default:
16326                     break;
16327             }
16328         }
16329     }
16330
16331     return U;
16332 }
16333
16334
16335 -(MAPSCRIPT0*)setResource:(MAPSCRIPT0*)MS0{
16336
16337     if(MS0->S6.team == 0){
16338
16339         if(MS0->S6.RCsupply){
16340             if(MS0->S6.RCsupplyS){
16341                 if(MS0->S6.RCsupplyAdd)
16342                     P[0].resource += MS0->S6.RCsupplyValue;
16343                 else
16344                     P[0].resource -= MS0->S6.RCsupplyValue;
16345             }else{
16346                 if(MS0->S6.RCsupplyAdd)
16347                     P[0].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16348                 else
16349                     P[0].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16350             }
16351         }
16352         if(MS0->S6.RCfood){
16353             if(MS0->S6.RCfoodS){
16354                 if(MS0->S6.RCfoodAdd)
16355                     P[0].food += MS0->S6.RCfoodValue;
16356                 else
16357                     P[0].food -= MS0->S6.RCfoodValue;
16358             }else{
16359                 if(MS0->S6.RCfoodAdd)
16360                     P[0].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16361                 else
16362                     P[0].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16363             }
16364         }
16365         if(MS0->S6.RCmoney){
16366             if(MS0->S6.RCmoneyS){
16367                 if(MS0->S6.RCmoneyAdd)
16368                     P[0].money += MS0->S6.RCmoneyValue;
16369                 else
16370                     P[0].money -= MS0->S6.RCmoneyValue;
16371             }else{
16372                 if(MS0->S6.RCmoneyAdd)
16373                     P[0].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16374                 else
16375                     P[0].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16376             }
16377         }
16378
16379     }else if(MS0->S6.team == 1){
16380         if(MS0->S6.RCsupply){
16381         if(MS0->S6.RCsupplyS){
16382             if(MS0->S6.RCsupplyAdd)
16383                 P[1].resource += MS0->S6.RCsupplyValue;
16384             else
16385                 P[1].resource -= MS0->S6.RCsupplyValue;
16386         }else{
16387             if(MS0->S6.RCsupplyAdd)
16388                 P[1].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16389             else
16390                 P[1].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16391         }
16392         }
16393     if(MS0->S6.RCfood){
16394         if(MS0->S6.RCfoodS){
16395             if(MS0->S6.RCfoodAdd)
16396                 P[1].food += MS0->S6.RCfoodValue;
16397             else
16398                 P[1].food -= MS0->S6.RCfoodValue;
16399         }else{
16400             if(MS0->S6.RCfoodAdd)
16401                 P[1].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16402             else
16403                 P[1].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16404         }
16405     }
16406     if(MS0->S6.RCmoney){
16407         if(MS0->S6.RCmoneyS){
16408             if(MS0->S6.RCmoneyAdd)
16409                 P[1].money += MS0->S6.RCmoneyValue;
16410             else
16411                 P[1].money -= MS0->S6.RCmoneyValue;
16412         }else{
16413             if(MS0->S6.RCmoneyAdd)
16414                 P[1].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16415             else
16416                 P[1].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16417         }
16418     }
16419     }else if(MS0->S6.team == 2){
16420         if(MS0->S6.RCsupply){
16421         if(MS0->S6.RCsupplyS){
16422             if(MS0->S6.RCsupplyAdd)
16423                 P[2].resource += MS0->S6.RCsupplyValue;
16424             else
16425                 P[2].resource -= MS0->S6.RCsupplyValue;
16426         }else{
16427             if(MS0->S6.RCsupplyAdd)
16428                 P[2].resource += [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16429             else
16430                 P[2].resource -= [Hensuu[MS0->S6.RCsupplySelect-1] intValue];
16431         }
16432         }
16433
16434     if(MS0->S6.RCfood){
16435         if(MS0->S6.RCfoodS){
16436             if(MS0->S6.RCfoodAdd)
16437                 P[2].food += MS0->S6.RCfoodValue;
16438             else
16439                 P[2].food -= MS0->S6.RCfoodValue;
16440         }else{
16441             if(MS0->S6.RCfoodAdd)
16442                 P[2].food += [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16443             else
16444                 P[2].food -= [Hensuu[MS0->S6.RCfoodSelect-1] intValue];
16445         }
16446     }
16447     if(MS0->S6.RCmoney){
16448         if(MS0->S6.RCmoneyS){
16449             if(MS0->S6.RCmoneyAdd)
16450                 P[2].money += MS0->S6.RCmoneyValue;
16451             else
16452                 P[2].money -= MS0->S6.RCmoneyValue;
16453         }else{
16454             if(MS0->S6.RCmoneyAdd)
16455                 P[2].money += [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16456             else
16457                 P[2].money -= [Hensuu[MS0->S6.RCmoneySelect-1] intValue];
16458         }
16459     }
16460     }
16461
16462     if(P[0].resource < 0) P[0].resource = 0;
16463     if(P[1].resource < 0) P[1].resource = 0;
16464     if(P[2].resource < 0) P[2].resource = 0;
16465
16466     if(P[0].food < 0) P[0].food = 0;
16467     if(P[1].food < 0) P[1].food = 0;
16468     if(P[2].food < 0) P[2].food = 0;
16469
16470     if(P[0].money < 0) P[0].money = 0;
16471     if(P[1].money < 0) P[1].money = 0;
16472     if(P[2].money < 0) P[2].money = 0;
16473
16474     MS0->succeessfulFlag = true;
16475     MS0->endFlag = true;
16476     return MS0;
16477 }
16478
16479 -(MAPSCRIPT0*)setLabel:(MAPSCRIPT0*)MS0{
16480
16481     //NSLog(@"%d", MSDP0top->succeessfulFlag);
16482     MS0->succeessfulFlag = true;
16483     MS0->endFlag = true;
16484     return MS0;
16485 }
16486
16487 -(MAPSCRIPT0*)setComment:(MAPSCRIPT0*)MS0{
16488
16489     MS0->succeessfulFlag = true;
16490     MS0->endFlag = true;
16491     return MS0;
16492 }
16493
16494
16495 -(MAPSCRIPT0*)setSelection:(MAPSCRIPT0*)MS0{
16496
16497     static bool initFlag = false;
16498
16499     if(!initFlag){
16500         initFlag = true;
16501
16502         MAPSCRIPT2 *MS2top = MS0->S2;
16503
16504         slctPoint.x = [mapWindow frame].origin.x + 100;
16505         slctPoint.y = [mapWindow frame].origin.y + 300;
16506
16507         [slctBtn1 setHidden:YES];
16508         [slctBtn2 setHidden:YES];
16509         [slctBtn3 setHidden:YES];
16510         [slctBtn4 setHidden:YES];
16511         [slctBtn5 setHidden:YES];
16512         [slctBtn6 setHidden:YES];
16513         [slctBtn7 setHidden:YES];
16514         [slctBtn8 setHidden:YES];
16515         [slctBtn9 setHidden:YES];
16516
16517         for(int i = 1;MS0->S2;i++){
16518
16519             if(i == 1){
16520                 [slctBtn1 setTitle:MS0->S2->selection];
16521                 [slctBtn1 setHidden:NO];
16522                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 60) display:YES];
16523             }
16524             if(i == 2){
16525                 [slctBtn2 setTitle:MS0->S2->selection];
16526                 [slctBtn2 setHidden:NO];
16527                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 90) display:YES];
16528             }
16529             if(i == 3){
16530                 [slctBtn3 setTitle:MS0->S2->selection];
16531                 [slctBtn3 setHidden:NO];
16532                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 120) display:YES];
16533             }
16534
16535             if(i == 4){
16536                 [slctBtn4 setTitle:MS0->S2->selection];
16537                 [slctBtn4 setHidden:NO];
16538                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 150) display:YES];
16539             }
16540             if(i == 5){
16541                 [slctBtn5 setTitle:MS0->S2->selection];
16542                 [slctBtn5 setHidden:NO];
16543                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 180) display:YES];
16544             }
16545             if(i == 6){
16546                 [slctBtn6 setTitle:MS0->S2->selection];
16547                 [slctBtn6 setHidden:NO];
16548                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 210) display:YES];
16549             }
16550             if(i == 7){
16551                 [slctBtn7 setTitle:MS0->S2->selection];
16552                 [slctBtn7 setHidden:NO];
16553                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 240) display:YES];
16554             }
16555             if(i == 8){
16556                 [slctBtn8 setTitle:MS0->S2->selection];
16557                 [slctBtn8 setHidden:NO];
16558                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 270) display:YES];
16559             }
16560             if(i == 9){
16561                 [slctBtn9 setTitle:MS0->S2->selection];
16562                 [slctBtn9 setHidden:NO];
16563                 [selectionWindow setFrame:NSMakeRect(slctPoint.x, slctPoint.y, 400, 300) display:YES];
16564             }
16565             slctBtnNum = i;
16566             if(slctBtnNum > 9)
16567                 slctBtnNum = 9;
16568             MS0->S2 = MS0->S2->next;
16569         }
16570         MS0->S2 = MS2top;
16571
16572
16573
16574         [selectionWindow makeKeyAndOrderFront:nil];
16575     }
16576
16577
16578     if(slctedBtnNum > 0){
16579         MAPSCRIPT0 *CRMS0 = MS0;
16580
16581         MS0 = MSDPtop;
16582         while(MS0){
16583             MS0->endFlag = false;
16584             MS0 = MS0->next;
16585         }MS0 = CRMS0;
16586
16587         MAPSCRIPT2 *MS2top = MS0->S2;
16588         MAPSCRIPT2 *CRMS2;
16589
16590         for(int i = 1;i < slctedBtnNum;i++){
16591             MS0->S2 = MS0->S2->next;
16592         }
16593             CRMS2 = MS0->S2;
16594
16595         MS0->S2 = MS2top;
16596
16597         MS0 = MSDPtop;
16598         if([CRMS2->labelJump isEqualToString:MS0->label]){
16599             MS0->endFlag = false;
16600         }else{
16601
16602             while (MS0) {
16603
16604                 if(MS0->next)
16605                     if([CRMS2->labelJump isEqualToString:MS0->next->label]){
16606                         if(MS0->type == 6 && MS0->endFlag){
16607
16608                         }else{
16609                             MS0->succeessfulFlag = true;
16610                         }
16611                         MS0->endFlag = true;
16612                         MS0 = MS0->next;
16613                         break;
16614                     }
16615                 if(MS0->type == 6 && MS0->endFlag){
16616
16617                 }else{
16618                     MS0->succeessfulFlag = true;
16619                 }
16620                 MS0->endFlag = true;
16621                 MS0 = MS0->next;
16622             }
16623         }
16624         if(!MS0){
16625             MS0 = CRMS0;
16626             return MS0;
16627         }
16628
16629         MS0->endFlag = true;
16630         MS0->succeessfulFlag = true;
16631         initFlag = false;
16632         slctedBtnNum = 0;
16633         }
16634
16635     return MS0;
16636 }
16637
16638 -(MAPSCRIPT0*)setAppearance:(MAPSCRIPT0*)MS0{
16639
16640     MS3T = MS0->S3;
16641     while(MS0->S3){
16642         int x, y;
16643         UNITCHIP u;
16644         u = MS0->S3->U;
16645         x = MS0->S3->x;
16646         y = MS0->S3->y;
16647
16648         if(unitNum[x][y] == -1){
16649
16650             if(MS0->S3->flag){
16651
16652
16653             }else{
16654                 unitTeam[x][y] = MS0->S3->team;
16655                 unitNum[x][y] = u.chipNumb;
16656                 loadNum[x][y] = u.chipNumb;
16657                 [self addAppearanceStatus:u x:x y:y];
16658             }
16659         }else{
16660
16661             if(MS0->S3->flag){
16662
16663
16664             }else{
16665                 int *p = calloc(1, sizeof(int));
16666                 int *o = calloc(1, sizeof(int));
16667                 appearanceSAIKIflag = false;
16668                 wtflag = 0;
16669
16670                 for (int i = 0;i < 1002;i++) {
16671                     for (int k = 0;k < 1002;k++) {
16672                         apprR[i][k] = 0;
16673                     }
16674                 }
16675
16676                 [self checkAppearanceRange:5 tX:y tY:x aMap:apprR];
16677
16678                 int postInt = 0;
16679                 for (int i = 0;i < 1002;i++) {
16680                     for (int k = 0;k < 1002;k++) {
16681                         if(apprR[i][k] > postInt && unitNum[i][k] == -1){
16682                             postInt = apprR[i][k];
16683                             *p = i;
16684                             *o = k;
16685                         }
16686                     }
16687                 }
16688
16689                 if(*p > 0 && *o >0){
16690                     x = *p;
16691                     y = *o;
16692                     unitTeam[x][y] = MS0->S3->team;
16693                     unitNum[x][y] = u.chipNumb;
16694                     loadNum[x][y] = u.chipNumb;
16695                     [self addAppearanceStatus:u x:x y:y];
16696                 }else{
16697                     MS0->succeessfulFlag = false;
16698                     MS0->endFlag = true;
16699                     MS0->S3 = MS3T;
16700                     return MS0;
16701                 }
16702             }
16703         }
16704         MS0->S3 = MS0->S3->next;
16705     }MS0->S3 = MS3T;
16706     unitColorInitFlag = true;
16707
16708     MS0->succeessfulFlag = true;
16709     MS0->endFlag = true;
16710     return MS0;
16711 }
16712
16713 -(MAPSCRIPT0*)setDissappearance:(MAPSCRIPT0*)MS0{
16714
16715     MS5T = MS0->S5;
16716     while(MS0->S5){
16717         int x, y;
16718         UNITCHIP u;
16719         u = MS0->S5->U;
16720         x = MS0->S5->x;
16721         y = MS0->S5->y;
16722
16723         if(1){
16724
16725
16726             if(MS0->S5->unitNum >= 0){
16727                 unitNum[x][y] = -1;
16728                 unitTeam[x][y] = -1;
16729                 unitNum[x][y] = -1;
16730                 loadNum[x][y] = -1;
16731
16732                 U = UTop;
16733                 while(U){
16734                     if(U->ix == x && U->iy == y)
16735                         break;
16736                     U = U->next;
16737                 }
16738                 if(U)
16739                     U->dead = true;
16740
16741                 U = UTop;
16742
16743             }else{
16744                 MS0->succeessfulFlag = false;
16745                 MS0->endFlag = true;
16746                 MS0->S5 = MS5T;
16747                 return MS0;
16748             }
16749
16750         }
16751         MS0->S5 = MS0->S5->next;
16752     }MS0->S5 = MS5T;
16753     unitColorInitFlag = true;
16754
16755     MS0->succeessfulFlag = true;
16756     MS0->endFlag = true;
16757     return MS0;
16758 }
16759
16760
16761 -(void)checkAppearanceRange:(int)cnsPow tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap{
16762
16763     if(cnsPow < 0) return;
16764
16765     int i0;
16766     if(aMap[startY][startX] <= cnsPow)
16767         aMap[startY][startX] = cnsPow;
16768
16769     if(startY < 0) startY = 0;
16770     if(startX < 0) startX = 0;
16771     if(cnsPow < 0) cnsPow = 0;
16772
16773     i0 = cnsPow - 1;
16774
16775     if(aMap[startY-1][startX] >= 0 && cnsPow > 0)
16776         [self checkAppearanceRange:i0 tX:startX tY:startY-1 aMap:aMap];
16777
16778     i0 = cnsPow - 1;
16779     if(aMap[startY+1][startX] >= 0 && cnsPow > 0)
16780         [self checkAppearanceRange:i0 tX:startX tY:startY+1 aMap:aMap];
16781
16782     i0 = cnsPow - 1;
16783     if(aMap[startY][startX-1] >= 0 && cnsPow > 0)
16784         [self checkAppearanceRange:i0 tX:startX-1 tY:startY aMap:aMap];
16785
16786     i0 = cnsPow - 1;
16787     if(aMap[startY][startX+1] >= 0 && cnsPow > 0)
16788         [self checkAppearanceRange:i0 tX:startX+1 tY:startY aMap:aMap];
16789
16790 }
16791
16792 -(void)addAppearanceStatus:(UNITCHIP)u x:(int)x y:(int)y{
16793     registerNum++;
16794
16795     int omgCnt = 0;
16796     U = UTop;
16797     while (U->next) {omgCnt++;
16798         U = U->next;
16799     }
16800     U->next = calloc(1, sizeof(UNIT));
16801     U = U->next;
16802     U->next = NULL;
16803     if(omgCnt == 0) U = UTop;
16804     U->number = registerNum;
16805     U->chipNumber = -1;
16806     U->chipNumberL = -1;
16807     U->C.chipNumb = -1;
16808     U->CL.chipNumb = -1;
16809
16810     U->x = x;
16811     U->y = y;
16812
16813     U->C = u;
16814     if(unitTeam[x][y] == 0 || unitTeam[x][y] == 1){
16815         U->team = 0;
16816         if(unitTeam[x][y] == 1){
16817             U->joinArmyFromNext = true;
16818             U->persuasion = true;
16819         }
16820         if(MF[MFselectedRow+1].MS.playerSet1 == 2)
16821             U->CPU = true;
16822
16823     }
16824     if(unitTeam[x][y] == 2 || unitTeam[x][y] == 3){
16825         U->team = 2;
16826         if(unitTeam[x][y] == 3){
16827             U->joinArmyFromNext = true;
16828             U->persuasion = true;
16829         }
16830         if(MF[MFselectedRow+1].MS.playerSet2 == 2)
16831             U->CPU = true;
16832
16833     }
16834     if(unitTeam[x][y] == 4 || unitTeam[x][y] == 5){
16835         U->team = 1;
16836         if(unitTeam[x][y] == 5){
16837             U->joinArmyFromNext = true;
16838             U->persuasion = true;
16839         }
16840         U->CPU = true;
16841     }
16842     if(unitTeam[x][y] == -1){
16843         U->team = -1;
16844         if(unitTeam[x][y] == 0){
16845             U->joinArmyFromNext = false;
16846             U->persuasion = true;
16847         }
16848         U->CPU = true;
16849     }
16850     unitNum[x][y] = u.chipNumb;
16851     [self SetUnitStatus:unitNum[x][y]];
16852
16853     for(int i = 0;i < UCN;i++){
16854         if([U->C.nameID isEqualToString:UC[i].nameID])
16855             U->chipNumber = i;
16856     }
16857     for(int i = 0;i < LCN;i++){
16858         if([U->CL.nameID isEqualToString:LC[i].nameID])
16859             U->chipNumberL = i;
16860     }
16861     for(int i = 0;i < UCN;i++){
16862         if([U->C.nameID isEqualToString:UC[i].nameID])
16863             U->C.chipNumb = i;
16864     }
16865     for(int i = 0;i < LCN;i++){
16866         if([U->CL.nameID isEqualToString:LC[i].nameID])
16867             U->CL.chipNumb = i;
16868     }
16869
16870     registerNum++;
16871     U = UTop;
16872
16873 }
16874
16875
16876 -(MAPSCRIPT0*)setWait:(MAPSCRIPT0*)MS0{
16877
16878     static bool waitin = false;
16879
16880     if(!waitin){
16881         waitinTime = 0;
16882         waitinTime = MS0->wait;
16883
16884         waitin = true;
16885     }
16886
16887     waitSwtichFlag = true;
16888
16889     if(waitAllOverFlag){
16890         MS0->succeessfulFlag = true;
16891         MS0->endFlag = true;
16892         waitAllOverFlag = false;
16893         waitSwtichFlag = false;
16894         waitin = false;
16895         waitx10flag = false;
16896         waitinTime = 0;
16897     }
16898
16899     return MS0;
16900 }
16901
16902 -(MAPSCRIPT0*)setBGM:(MAPSCRIPT0*)MS0{
16903
16904     if(BGMsub)
16905         BGMsub = NULL;
16906
16907     BGMsub = [MS0->BGM.snd retain];
16908
16909     [BGMsub setLoops:NO];
16910     [BGMsub play];
16911
16912     MS0->succeessfulFlag = true;
16913     MS0->endFlag = true;
16914
16915     return MS0;
16916 }
16917
16918 -(MAPSCRIPT0*)setSE:(MAPSCRIPT0*)MS0{
16919
16920     if(SEsub)
16921         [SEsub stop];
16922     SEsub = [MS0->SE.snd retain];
16923
16924     [SEsub play];
16925
16926     MS0->succeessfulFlag = true;
16927     MS0->endFlag = true;
16928
16929     return MS0;
16930 }
16931
16932 -(MAPSCRIPT0*)setTitleBack:(MAPSCRIPT0*)MS0{
16933
16934     backTitleFlag = true;
16935     battleBegin = false;
16936
16937     MS0->succeessfulFlag = true;
16938     MS0->endFlag = true;
16939
16940     return MS0;
16941 }
16942
16943 -(MAPSCRIPT0*)setStageClear:(MAPSCRIPT0*)MS0{
16944
16945     stageClearFlag = true;
16946
16947     if(MS0->sc.edcdFlag)
16948         stageClearFlag2 = true;
16949     battleBegin = false;
16950
16951     MS0->succeessfulFlag = true;
16952     MS0->endFlag = true;
16953
16954     return MS0;
16955 }
16956
16957 -(MAPSCRIPT0*)setGameOver:(MAPSCRIPT0*)MS0{
16958
16959     gaov.img = MS0->gaov.img;
16960
16961     gameOverFlag = true;
16962     battleBegin = false;
16963
16964     MS0->succeessfulFlag = true;
16965     MS0->endFlag = true;
16966
16967     return MS0;
16968 }
16969
16970 -(IBAction)gameOverSubmit:(id)sender{
16971
16972
16973     gaov.img = nil;
16974
16975     [BGMsub stop];
16976     BGMsub = NULL;
16977
16978     [GameOverWindow close];
16979     [titleWindow makeKeyAndOrderFront:nil];
16980
16981 }
16982
16983 -(IBAction)battleReadyUpStartBtn:(id)sender{
16984
16985
16986     P[0].resource = [battleReadyUpSupply1 intValue];
16987     P[0].food = [battleReadyUpFood1 intValue];
16988     P[0].money = [battleReadyUpMoney1 intValue];
16989
16990     P[1].resource = [battleReadyUpSupply2 intValue];
16991     P[1].food = [battleReadyUpFood2 intValue];
16992     P[1].money = [battleReadyUpMoney2 intValue];
16993
16994     setBattleModeFlag = false;
16995     [bsWindow close];
16996
16997 }
16998
16999 -(IBAction)battleReadyUpState1:(id)sender{
17000     retardhelp1 = true;
17001 }
17002 -(IBAction)battleReadyUpState2:(id)sender{
17003     retardhelp2 = true;
17004 }
17005
17006
17007
17008
17009
17010
17011
17012 -(IBAction)selectionBtn1:(id)sender{
17013     slctedBtnNum = 1;
17014     [selectionWindow close];
17015 }
17016 -(IBAction)selectionBtn2:(id)sender{
17017     slctedBtnNum = 2;
17018     [selectionWindow close];
17019 }
17020 -(IBAction)selectionBtn3:(id)sender{
17021     slctedBtnNum = 3;
17022     [selectionWindow close];
17023 }
17024 -(IBAction)selectionBtn4:(id)sender{
17025     slctedBtnNum = 4;
17026     [selectionWindow close];
17027 }
17028 -(IBAction)selectionBtn5:(id)sender{
17029     slctedBtnNum = 5;
17030     [selectionWindow close];
17031 }
17032 -(IBAction)selectionBtn6:(id)sender{
17033     slctedBtnNum = 6;
17034     [selectionWindow close];
17035 }
17036 -(IBAction)selectionBtn7:(id)sender{
17037     slctedBtnNum = 7;
17038     [selectionWindow close];
17039 }
17040 -(IBAction)selectionBtn8:(id)sender{
17041     slctedBtnNum = 8;
17042     [selectionWindow close];
17043 }
17044 -(IBAction)selectionBtn9:(id)sender{
17045     slctedBtnNum = 9;
17046     [selectionWindow close];
17047 }
17048
17049
17050
17051 -(void)HensuuLoad{
17052
17053     NSString *directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
17054     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
17055
17056
17057     NSData *InitialData = [NSData dataWithContentsOfFile:@"data/Others/var.txt"];
17058     NSString *pathVar = @"data/Others/var.txt";
17059     NSString *fileData = @"";
17060
17061     if(!InitialData){
17062         [[NSFileManager defaultManager] createFileAtPath:pathVar contents:nil attributes:nil];
17063     }
17064
17065     HensuuNum = 0;
17066     fileData = [NSString stringWithContentsOfFile:pathVar encoding:NSUTF8StringEncoding error:nil];
17067     NSArray *fileDataArray = [fileData componentsSeparatedByString:@"\n"];
17068
17069     for(int i = 0;i < [fileDataArray count];i++){
17070
17071         NSArray *item = [[fileDataArray objectAtIndex:i] componentsSeparatedByString:@","];
17072
17073         Hensuu[i] = [[item objectAtIndex:1] retain];
17074         HensuuName[i] = [[item objectAtIndex:2] retain];
17075         HensuuNum++;
17076     }
17077
17078
17079 }
17080
17081
17082 -(void)displaySideMenu{
17083
17084     [FSMenu setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - FSMenu.frame.size.width/2,
17085                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - FSMenu.frame.size.height/2)];
17086     [menuPanel close];
17087     moveFlag = false;
17088     attackFlag = false;
17089     summonFlag = false;
17090     menuDisplayFlag = false;
17091     [FSMenu makeKeyAndOrderFront:nil];
17092
17093     coolTime = true;
17094 }
17095
17096 -(IBAction)FSVsave:(id)sender{
17097
17098     [saveGamePanel setFrameOrigin:NSMakePoint([fsWindow frame].origin.x + [fsWindow frame].size.width/2 - saveGamePanel.frame.size.width/2,
17099                                        [fsWindow frame].origin.y + [fsWindow frame].size.height/2 - saveGamePanel.frame.size.height/2)];
17100
17101     [self saveGameDataDatViewImage];
17102
17103     [saveGameTF setStringValue:@""];
17104
17105     [saveGamePanel makeKeyAndOrderFront:nil];
17106
17107 }
17108
17109 -(IBAction)FSVtitle:(id)sender{
17110
17111     stopByFSVmenuFlag = false;
17112     [BGMsub stop];
17113     BGMsub = NULL;
17114     if(titleBGM) [titleBGM play];
17115
17116     [titleWindow makeKeyAndOrderFront:nil];
17117     [fsWindow close];
17118     [FSMenu close];
17119
17120     esSceneProc = 0;
17121
17122
17123     endGameCondition = false;
17124     initMapFlag = false;
17125     TeamCountFlag = false;
17126     initStatusFlag = false;
17127     battleBegin = false;
17128     startES = false;
17129
17130     cpuModeMOVEflag = false;
17131     cpuModeATTACKflag = false;
17132
17133     redWinFlag = false;
17134     blueWinFlag = false;
17135     cpuAImodeflag = false;
17136     cpuTurnEndFlag = true;
17137     backTitleFlag = false;
17138     backTitleFlag2 = true;
17139     waitSwtichFlag = false;
17140     battleReadyUpFlag = false;
17141     setBattleModeFlag = false;
17142     mapChipDataLoadProc = 0;
17143
17144     wtRdy = false;
17145     wtRdy2 = false;
17146
17147     Uselected = NULL;
17148
17149 }
17150 -(IBAction)FSVcancel:(id)sender{
17151
17152     stopByFSVmenuFlag = false;
17153     coolTime = false;
17154     [FSMenu close];
17155
17156 }
17157
17158
17159 -(void)displaySaveFileDialog{
17160
17161     [saveDataList initFileDirectory];
17162     [self initSaveFileInputList];
17163     [saveFileDialog makeKeyAndOrderFront:nil];
17164 }
17165
17166
17167 -(IBAction)saveFileInputSubmit:(id)sender{
17168
17169     if([saveFileInputTF stringValue] == nil || [[saveFileInputTF stringValue] isEqualToString:@""]){
17170         return;
17171     }
17172
17173     saveFileNameSDL = [[saveFileInputTF stringValue] retain];
17174     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
17175     [saveDataList saveSaveList];
17176     [levelList saveLevelList];
17177
17178     [titleWindow makeKeyAndOrderFront:nil];
17179     [saveFileInputPanel close];
17180 }
17181 -(IBAction)saveFileInputCancel:(id)sender{
17182
17183
17184     [titleWindow makeKeyAndOrderFront:nil];
17185     [saveFileInputPanel close];
17186 }
17187
17188 -(IBAction)saveFileDialogSubmit:(id)sender{
17189
17190     saveFileFlag = true;
17191     [saveFileInputPanel makeKeyAndOrderFront:nil];
17192     [fsWindow close];
17193     [saveFileDialog close];
17194
17195 }
17196 -(IBAction)saveFileDialogCancel:(id)sender{
17197
17198     saveFileNameSDL = [@"preset.txt" retain];
17199     SC[storyNumb].saveFileName = [saveFileNameSDL retain];
17200     [saveDataList saveSaveList];
17201
17202     saveFileFlag = true;
17203     [titleWindow makeKeyAndOrderFront:nil];
17204
17205     [fsWindow close];
17206     [saveFileDialog close];
17207
17208 }
17209
17210 -(void)initSaveFileInputList{
17211
17212     [self willChangeValueForKey:@"saveFileInputListMA"];
17213     [saveFileInputListMA removeAllObjects];
17214     [self didChangeValueForKey:@"saveFileInputListMA"];
17215
17216
17217     for(int i = 1;i <= saveNumb;i++){
17218
17219
17220         NSMutableDictionary* dict = [NSMutableDictionary new];
17221         [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
17222         [self willChangeValueForKey:@"saveFileInputListMA"];
17223         [saveFileInputListMA addObject:dict];
17224         [self didChangeValueForKey:@"saveFileInputListMA"];
17225     }
17226
17227 }
17228
17229 -(void)initLoadFileOutputList{
17230
17231     [self willChangeValueForKey:@"loadFileOutputListMA"];
17232     [loadFileOutputListMA removeAllObjects];
17233     [self didChangeValueForKey:@"loadFileOutputListMA"];
17234
17235
17236     for(int i = 1;i <= saveNumb;i++){
17237
17238
17239         if([SC[storyNumb].name isEqualToString:SDL[i].levelName]){
17240             NSMutableDictionary* dict = [NSMutableDictionary new];
17241             [dict setValue:[NSString stringWithFormat:@"%@", SDL[i].name] forKey:@"name"];
17242             [self willChangeValueForKey:@"loadFileOutputListMA"];
17243             [loadFileOutputListMA addObject:dict];
17244             [self didChangeValueForKey:@"loadFileOutputListMA"];
17245         }
17246     }
17247
17248     LFOLrow = -1;
17249     [loadFileOutputListAC setSelectionIndex:9999];
17250
17251     [loadFileOutputTF setStringValue:[NSString stringWithFormat:@""]];
17252
17253     [loadFileOutputPanel makeKeyAndOrderFront:nil];
17254
17255 }
17256
17257 -(IBAction)loadFileOutputSubmit:(id)sender{
17258
17259     if(LFOLrow < 0)
17260         return;
17261
17262     SC[storyNumb].saveFileName = [SDL[SDLrow+1].name retain];
17263     SC[storyNumb].CrntLevelName = [SDL[SDLrow+1].levelName retain];
17264     SC[storyNumb].scenarioNumbCrnt[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbCrnt];
17265     SC[storyNumb].scenarioNumbNext[scenarioNumb] = [NSString stringWithFormat:@"%d", SDL[SDLrow+1].scenarioNumbNext];
17266
17267     [levelList saveLevelList];
17268     [scenarioList initFileDirectory];
17269     [mapEditor initFileDirectoryOthers];
17270     [scenarioList setScenarioList:selectNumb];
17271
17272     [loadFileOutputPanel close];
17273 }
17274
17275 -(void)initFileOutPutListSet{
17276
17277     SC[storyNumb].saveFileName = NULL;
17278
17279     [levelList saveLevelList];
17280     [scenarioList setScenarioList:selectNumb];
17281 }
17282
17283 -(IBAction)loadFileOutputCancel:(id)sender{
17284
17285     [loadFileOutputPanel close];
17286 }
17287
17288
17289
17290
17291
17292
17293
17294
17295 -(IBAction)saveGameSubmit:(id)sender{
17296
17297     if([[saveGameTF stringValue] isEqualToString:@""])
17298         return;
17299
17300     sdd.name = [[saveGameTF stringValue] retain];
17301     datFilePath = calloc(255, sizeof(char));
17302     strcpy(datFilePath, [sdd.name UTF8String]);
17303
17304     [self saveGameDataDatViewImage];
17305     [self saveGameDataDat];
17306     [saveDataList initSaveList];
17307
17308     [saveGamePanel close];
17309
17310 }
17311
17312 -(void)saveGameDataDatViewImage{
17313
17314     NSString *directoryPath;
17315
17316     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
17317     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
17318
17319     [fieldView lockFocus];
17320     NSBitmapImageRep* rep = [fieldView bitmapImageRepForCachingDisplayInRect:fieldView.bounds];
17321     [fieldView cacheDisplayInRect:fieldView.bounds toBitmapImageRep:rep];
17322     [fieldView unlockFocus];
17323
17324     NSMutableData* data = [rep representationUsingType:NSPNGFileType properties:nil];
17325     sdd.img = [[[NSImage alloc] initWithData:data] retain];
17326
17327     [saveGameIV setImage:sdd.img];
17328     [saveGameIV setImageScaling:NSScaleToFit];
17329
17330
17331     NSString *path = @"SaveData/";
17332
17333     NSArray *ary = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:nil];
17334
17335     [SAV removeAllObjects];
17336     for(NSString *name in ary){
17337
17338         NSArray *arr = [name componentsSeparatedByString:@".sav"];
17339
17340         if([arr count] > 1){
17341             [SAV addObject:name];
17342         }
17343     }
17344
17345     [self willChangeValueForKey:@"saveGameListMA"];
17346     [saveGameListMA removeAllObjects];
17347     [self didChangeValueForKey:@"saveGameListMA"];
17348
17349     for(int i = 0;i < [SAV count];i++){
17350
17351         NSMutableDictionary* dict = [NSMutableDictionary new];
17352         [dict setValue:[NSString stringWithFormat:@"%@", SAV[i]] forKey:@"name"];
17353
17354         [self willChangeValueForKey:@"saveGameListMA"];
17355         [saveGameListMA addObject:dict];
17356         [self didChangeValueForKey:@"saveGameListMA"];
17357
17358     }
17359
17360     [saveGameListAC setSelectionIndex:9999];
17361
17362 }
17363
17364 -(void)loadGameDataDat{
17365
17366     if(!datFilePath)
17367         return;
17368
17369
17370
17371     [self loadStruct];
17372
17373
17374     NSString *directoryPath;
17375     directoryPath = [[[NSBundle mainBundle] bundlePath] stringByDeletingLastPathComponent];
17376     [[NSFileManager defaultManager] changeCurrentDirectoryPath:directoryPath];
17377
17378
17379     NSString *path = @"SaveData/";
17380     path = [path stringByAppendingString:SAV[SDLrow]];
17381
17382     NSData *data = [[NSData alloc] initWithContentsOfFile:path];
17383
17384     MFselectedRow = sdd2[datRow].MFselectedRow;
17385     MF[MFselectedRow+1].fileName = sdd2[datRow].mapfileName;
17386
17387     storyNumb = sdd2[datRow].storyNumb;
17388     scenarioNumb = sdd2[datRow].scenarioNumb;
17389
17390     SC[storyNumb].name = sdd2[datRow].levelName;
17391     SC[storyNumb].nameMAP[scenarioNumb] = sdd2[datRow].scenarioName;
17392
17393     posX = sdd2[datRow].posX;
17394     posX = sdd2[datRow].posY;
17395
17396     chipHeight = sdd2[datRow].chipHeight;
17397     chipWidth = sdd2[datRow].chipWidth;
17398     eSlctX = sdd2[datRow].eSlctX;
17399     eSlctY = sdd2[datRow].eSlctY;
17400
17401     registerNum = sdd2[datRow].registerNum;
17402     registerNumB = sdd2[datRow].registerNumB;
17403
17404     esSceneProc = sdd2[datRow].esSceneProc;
17405
17406     endGameCondition = sdd2[datRow].endGameCondition;
17407     initMapFlag = sdd2[datRow].initMapFlag;
17408     TeamCountFlag = sdd2[datRow].TeamCountFlag;
17409     initStatusFlag = sdd2[datRow].initStatusFlag;
17410     battleBegin = sdd2[datRow].battleBegin;
17411     startES = sdd2[datRow].startES;
17412
17413     cpuAImodeflag = sdd2[datRow].cpuAImodeflag;
17414     cpuTurnEndFlag = sdd2[datRow].cpuTurnEndFlag;
17415     cpuModeMOVEflag = sdd2[datRow].cpuModeMOVEflag;
17416     cpuModeATTACKflag = sdd2[datRow].cpuModeATTACKflag;
17417     waitSwtichFlag = sdd2[datRow].waitSwtichFlag;
17418     battleReadyUpFlag = sdd2[datRow].battleReadyUpFlag;
17419     setBattleModeFlag = sdd2[datRow].setBattleModeFlag;
17420
17421     wtRdy = sdd2[datRow].wtRdy;
17422     wtRdy2 = sdd2[datRow].wtRdy2;
17423     wtRdy3 = sdd2[datRow].wtRdy3;
17424
17425     wtMovedFlag = sdd2[datRow].wtMovedFlag;
17426     wtAttackedFlag = sdd2[datRow].wtAttackedFlag;
17427     unitMoveEndFlag = sdd2[datRow].unitMoveEndFlag;
17428     battleSetUp = sdd2[datRow].battleSetUp;
17429     pushStanbyFlag = sdd2[datRow].pushStanbyFlag;
17430     battleEndFlag = sdd2[datRow].battleEndFlag;
17431     wtUnitNum = sdd2[datRow].wtUnitNum;
17432     messageDialog = sdd2[datRow].messageDialog;
17433
17434 /*
17435     for(int i = 0;i < 1002;i++){
17436         for(int j = 0;j < 1002;j++){
17437             chipNum[i][j] = sdd2[datRow].chipNum[i][j];
17438         }
17439     }
17440
17441     for(int i = 0;i < 1002;i++){
17442         for(int j = 0;j < 1002;j++){
17443             buildNum[i][j] = sdd2[datRow].buildNum[i][j];
17444         }
17445     }
17446
17447     for(int i = 0;i < 1002;i++){
17448         for(int j = 0;j < 1002;j++){
17449             unitNum[i][j] = sdd2[datRow].unitNum[i][j];
17450         }
17451     }
17452
17453     for(int i = 0;i < 1002;i++){
17454         for(int j = 0;j < 1002;j++){
17455             loadNum[i][j] = sdd2[datRow].loadNum[i][j];
17456         }
17457     }
17458
17459     for(int i = 0;i < 1002;i++){
17460         for(int j = 0;j < 1002;j++){
17461             buildTeam[i][j] = sdd2[datRow].buildTeam[i][j];
17462         }
17463     }
17464
17465     for(int i = 0;i < 1002;i++){
17466         for(int j = 0;j < 1002;j++){
17467             unitTeam[i][j] = sdd2[datRow].unitTeam[i][j];
17468         }
17469     }
17470 */
17471
17472     P[0] = sdd2[datRow].P[0];
17473     P[1] = sdd2[datRow].P[1];
17474     P[2] = sdd2[datRow].P[2];
17475
17476     for(int i = 0;i < 9999;i++)
17477         Suicchi[i] = sdd2[datRow].Suicchi[i];
17478
17479     sdd.HensuuNum = HensuuNum;
17480     for(int i = 0;i < 65000;i++)
17481         Hensuu[i] = [sdd2[datRow].Hensuu[i] retain];
17482     for(int i = 0;i < 65000;i++)
17483         HensuuName[i] = [sdd2[datRow].HensuuName[i] retain];
17484
17485     MF[MFselectedRow+1].MS = sdd2[datRow].MS;
17486     MF[MFselectedRow+1].MS.D = sdd2[datRow].MS.D;
17487
17488     /*
17489      UTop = sdd.UTop;
17490      BTop = sdd.BTop;
17491
17492
17493      Uselected = sdd.Uselected;
17494      unitBreak = sdd.unitBreak;
17495      Utarget = sdd.Utarget;
17496
17497      */
17498
17499     //NSLog(@"%d", MF[MFselectedRow+1].MS.playerSet1);
17500 }
17501
17502 -(void)saveGameDataDat{
17503     //おまんこ
17504
17505
17506     sdd.name = [[saveGameTF stringValue] retain];
17507
17508     sdd.MFselectedRow = MFselectedRow;
17509     sdd.storyNumb = storyNumb;
17510     sdd.scenarioNumb = scenarioNumb;
17511
17512     sdd.mapfileName = [MF[MFselectedRow+1].fileName retain];
17513     sdd.levelName = [SC[storyNumb].name retain];
17514     sdd.scenarioName = [SC[storyNumb].nameMAP[scenarioNumb] retain];
17515
17516     sdd.posX = posX;
17517     sdd.posX = posY;
17518
17519     sdd.chipHeight = chipHeight;
17520     sdd.chipWidth = chipWidth;
17521     sdd.eSlctX = eSlctX;
17522     sdd.eSlctY = eSlctY;
17523
17524     sdd.registerNum = registerNum;
17525     sdd.registerNumB = registerNumB;
17526
17527     sdd.esSceneProc = esSceneProc;
17528
17529     sdd.endGameCondition = endGameCondition;
17530     sdd.initMapFlag = initMapFlag;
17531     sdd.TeamCountFlag = TeamCountFlag;
17532     sdd.initStatusFlag = initStatusFlag;
17533     sdd.battleBegin = battleBegin;
17534     sdd.startES = startES;
17535
17536     sdd.cpuModeMOVEflag = cpuModeMOVEflag;
17537     sdd.cpuModeATTACKflag = cpuModeATTACKflag;
17538
17539     sdd.cpuAImodeflag = cpuAImodeflag;
17540     sdd.cpuTurnEndFlag = cpuTurnEndFlag;
17541     sdd.waitSwtichFlag = waitSwtichFlag;
17542     sdd.battleReadyUpFlag = battleReadyUpFlag;
17543     sdd.setBattleModeFlag = setBattleModeFlag;
17544
17545
17546     sdd.wtRdy = wtRdy;
17547     sdd.wtRdy2 = wtRdy2;
17548     sdd.wtRdy3 = wtRdy3;
17549
17550
17551     sdd.wtMovedFlag = wtMovedFlag;
17552     sdd.wtAttackedFlag = wtAttackedFlag;
17553     sdd.unitMoveEndFlag = unitMoveEndFlag;
17554     sdd.battleSetUp = battleSetUp;
17555     sdd.pushStanbyFlag = pushStanbyFlag;
17556     sdd.battleEndFlag = battleEndFlag;
17557     sdd.wtUnitNum = wtUnitNum;
17558     sdd.messageDialog = messageDialog;
17559
17560     /*
17561     for(int i = 0;i < 1002;i++){
17562         for(int j = 0;j < 1002;j++){
17563             sdd.chipNum[i][j] = chipNum[i][j];
17564         }
17565     }
17566
17567     for(int i = 0;i < 1002;i++){
17568         for(int j = 0;j < 1002;j++){
17569             sdd.buildNum[i][j] = buildNum[i][j];
17570         }
17571     }
17572
17573     for(int i = 0;i < 1002;i++){
17574         for(int j = 0;j < 1002;j++){
17575             sdd.unitNum[i][j] = unitNum[i][j];
17576         }
17577     }
17578
17579     for(int i = 0;i < 1002;i++){
17580         for(int j = 0;j < 1002;j++){
17581             sdd.loadNum[i][j] = loadNum[i][j];
17582         }
17583     }
17584
17585     for(int i = 0;i < 1002;i++){
17586         for(int j = 0;j < 1002;j++){
17587             sdd.buildTeam[i][j] = buildTeam[i][j];
17588         }
17589     }
17590
17591     for(int i = 0;i < 1002;i++){
17592         for(int j = 0;j < 1002;j++){
17593             sdd.unitTeam[i][j] = unitTeam[i][j];
17594         }
17595     }
17596     */
17597
17598     U = UTop;
17599     int r = 0;
17600     while(U && r < registerNum){
17601         sdd.dU[r].CPU = U->CPU;
17602         sdd.dU[r].number = U->number;
17603         sdd.dU[r].team = U->team;
17604         sdd.dU[r].chipNumber = U->chipNumber;
17605         sdd.dU[r].chipNumberL = U->chipNumberL;
17606
17607         sdd.dU[r].x = U->x;
17608         sdd.dU[r].y = U->y;
17609         sdd.dU[r].z = U->z;
17610
17611         sdd.dU[r].ix = U->ix;
17612         sdd.dU[r].iy = U->iy;
17613         sdd.dU[r].iz = U->iz;
17614
17615         sdd.dU[r].dead = U->dead;
17616
17617         sdd.dU[r].loadChipFlag = U->loadChipFlag;
17618
17619         sdd.dU[r].unControlable = U->unControlable;
17620         sdd.dU[r].joinArmyFromNext = U->joinArmyFromNext;
17621         sdd.dU[r].persuasion = U->persuasion;
17622
17623         sdd.dU[r].targType1L = U->targType1L;
17624         sdd.dU[r].targType2L = U->targType2L;
17625         sdd.dU[r].targType1D = U->targType1D;
17626         sdd.dU[r].targType2D = U->targType2D;
17627
17628         sdd.dU[r].army = U->army;
17629         sdd.dU[r].img = [U->img retain];
17630
17631         sdd.dU[r].C.chipNumb = U->C.chipNumb;
17632         sdd.dU[r].C.name = [U->C.name retain];
17633         sdd.dU[r].C.nameNick = [U->C.nameNick retain];
17634         sdd.dU[r].C.nameClass = [U->C.nameClass retain];
17635         sdd.dU[r].C.nameID = [U->C.nameID retain];
17636
17637         sdd.dU[r].C.R_C = U->C.R_C;
17638         sdd.dU[r].C.S_C = U->C.S_C;
17639
17640         U = U->next;
17641         r++;
17642     }U = UTop;
17643
17644     B = BTop;
17645     r = 0;
17646     while(B && r < registerNumB){
17647         sdd.dB[r].number = B->number;
17648         sdd.dB[r].team = B->team;
17649         sdd.dB[r].chipNumber = B->chipNumber;
17650         sdd.dB[r].makeLv = B->makeLv;
17651
17652         sdd.dB[r].x = B->x;
17653         sdd.dB[r].y = B->y;
17654         sdd.dB[r].z = B->z;
17655
17656         sdd.dB[r].dead = B->dead;
17657
17658         sdd.dB[r].img = [B->img retain];
17659         sdd.dB[r].C.chipNumb = B->C.chipNumb;
17660         sdd.dB[r].C.name = [B->C.name retain];
17661         sdd.dB[r].C.nameID = [B->C.nameID retain];
17662         sdd.dB[r].C.S_C = B->C.S_C;
17663
17664         B = B->next;
17665         r++;
17666     }B = BTop;
17667
17668     sdd.P[0] = P[0];
17669     sdd.P[1] = P[1];
17670     sdd.P[2] = P[2];
17671
17672
17673     for(int i = 0;i < 9999;i++)
17674         sdd.Suicchi[i] = Suicchi[i];
17675
17676     sdd.HensuuNum = HensuuNum;
17677     for(int i = 0;i < 65000;i++)
17678         sdd.Hensuu[i] = [Hensuu[i] retain];
17679     for(int i = 0;i < 65000;i++)
17680         sdd.HensuuName[i] = [HensuuName[i] retain];
17681
17682     MAPSCRIPT MS = MF[MFselectedRow+1].MS;
17683
17684      sdd.MS = MS;
17685
17686     [self saveStruct];
17687 }
17688
17689 -(NSData *)sddToNSData:(NSString *) path{
17690
17691     /*
17692     NSData *archivedData = [NSKeyedArchiver archivedDataWithRootObject:sdd];
17693
17694     [archivedData writeToFile:path atomically:YES];
17695
17696     return archivedData;
17697     */
17698
17699
17700 }
17701
17702 -(IBAction)saveGameCancel:(id)sender{
17703
17704     [saveGamePanel close];
17705
17706 }
17707
17708 @end
17709
17710
17711
17712
17713
17714 @implementation FieldSceneEF
17715
17716
17717 -(BOOL)isFlipped{
17718     return YES;
17719 }
17720
17721 - (id)initWithFrame:(NSRect)frame
17722 {
17723     self = [super initWithFrame:frame];
17724     if (self) {
17725         // Initialization code here.
17726         time  = [NSTimer
17727                  scheduledTimerWithTimeInterval:0.015
17728                  target:self
17729                  selector:@selector(EventLoopBV:)
17730                  userInfo:nil
17731                  repeats:YES
17732                  ];
17733     }
17734
17735     return self;
17736 }
17737
17738 -(void)scrollWheel:(NSEvent *)theEvent{
17739
17740     theEvent = NULL;
17741
17742 }
17743
17744 -(void)EventLoopBV:(NSTimer*)timer{
17745
17746     [battleView setNeedsDisplay:YES];
17747
17748     static int aniFrame = 0;
17749
17750     if(animationFlag3){
17751         aniFrame = 0;
17752         aniFrameCnt = 0;
17753         return;
17754     }
17755
17756     if(!animationFlag1 && !animationFlag2){
17757         aniFrame = 0;
17758         aniFrameCnt = 0;
17759         return;
17760     }
17761
17762     U = effCun;
17763
17764     if(animationFlag1)
17765         U->C.A = attackCR;
17766     if(animationFlag2)
17767         U->C.A = attackCR2;
17768
17769     static bool pussyMikoto = false;
17770
17771     if(aniFrame == 0){
17772
17773         ani = U->C.A->AN.ANI;
17774         ANI *aniTop = ani;
17775
17776         for (int i = 0; i < aniFrameCnt;i++) {
17777             ani = ani->next;
17778         }
17779
17780         if(ani->snd){
17781             [ani->snd setCurrentTime:0];
17782             [ani->snd play];
17783             ani->snd.loops = NO;
17784         }
17785         if(!ani->next){
17786             pussyMikoto = true;
17787         }
17788         ani = aniTop;
17789
17790         U->C.A->AN.ANI = ani;
17791     }
17792
17793     if(aniFrame < U->C.A->AN.frame){
17794         aniFrame++;
17795     }else{
17796         aniFrame = 0;
17797         aniFrameCnt++;
17798         if(pussyMikoto){
17799             pussyMikoto = false;
17800             animationFlag3 = true;
17801         }
17802     }
17803
17804
17805
17806
17807
17808     [self setNeedsDisplay:YES];
17809
17810
17811 }
17812
17813 -(void)DrawImage:(NSImage*)image x:(float)x y:(float)y a:(float)a{
17814     NSRect frRect;
17815     frRect.size.height = image.size.height;
17816     frRect.size.width = image.size.width;
17817
17818     frRect.origin.x = 0;
17819     frRect.origin.y = 0;
17820
17821     NSRect drRect;
17822     drRect.origin.x = x;
17823     drRect.origin.y = y;
17824     drRect.size.height = image.size.height;
17825     drRect.size.width = image.size.width;
17826
17827     [image drawInRect:drRect fromRect:frRect operation:NSCompositeSourceOver fraction:a respectFlipped:YES hints:nil];
17828
17829 }
17830
17831 - (void)drawRect:(NSRect)dirtyRect
17832 {
17833     // Drawing code here.
17834     if(animationFlag3) return;
17835
17836
17837
17838
17839     if(animationFlag1 || animationFlag2){
17840         U = effCun;
17841
17842         if(animationFlag1)
17843                 U->C.A = attackCR;
17844         if(animationFlag2)
17845             U->C.A = attackCR2;
17846
17847     ani = U->C.A->AN.ANI;
17848
17849     ANI *aniTop = ani;
17850
17851
17852     for (int i = 0; i < aniFrameCnt;i++) {
17853         ani = ani->next;
17854     }
17855         if(!ani)
17856         {
17857             ani = aniTop;
17858             return;
17859         }
17860     [self DrawImage:ani->img x:ani->x + ani->ax y:ani->y + ani->ay a:1.0f];
17861     ani = aniTop;
17862     }
17863
17864
17865
17866
17867 }
17868
17869
17870
17871
17872
17873
17874
17875
17876
17877
17878 @end
17879
17880
17881
17882
17883
17884
17885
17886
17887