29 @end

    29 @end

    30 

    30 

    31 @implementation MapPreviewButtonView

    31 @implementation MapPreviewButtonView

    32 @synthesize delegate;

    32 @synthesize delegate;

    33 

    33 

    35     if ((self = [super initWithFrame:frame])) {

    35     if ((self = [super initWithFrame:frame])) {

    36         delegate = nil;

    36         delegate = nil;

    37         self.backgroundColor = [UIColor whiteColor];

    37         self.backgroundColor = [UIColor whiteColor];

    38         self.layer.cornerRadius = 12;

    38         self.layer.cornerRadius = 12;

    39     }

    39     }

    40     return self;

    40     return self;

    41 }

    41 }

    42 

    42 

    48 #pragma mark -

    43 #pragma mark -

    49 #pragma mark image wrappers

    44 #pragma mark image wrappers

    51     [self setImage:[image makeRoundCornersOfSize:CGSizeMake(12, 12)] forState:controlState];

    46     [self setImage:[image makeRoundCornersOfSize:CGSizeMake(12, 12)] forState:controlState];

    52 }

    47 }

    53 

    48 

    55     [self setImageRounded:image forState:UIControlStateNormal];

    50     [self setImageRounded:image forState:UIControlStateNormal];

    56 }

    51 }

    57 

    52 

    58 #pragma mark -

    53 #pragma mark -

    59 #pragma mark preview

    54 #pragma mark preview

    62 

    57 

    63     SDLNet_TCP_Send(csd, &length, 1);

    58     SDLNet_TCP_Send(csd, &length, 1);

    64     return SDLNet_TCP_Send(csd, [string UTF8String], length);

    59     return SDLNet_TCP_Send(csd, [string UTF8String], length);

    65 }

    60 }

    66 

    61 

    68     IPaddress ip;

    63     IPaddress ip;

    69     BOOL serverQuit = NO;

    64     BOOL serverQuit = NO;

    70     uint8_t packedMap[128*32];

    65     uint8_t packedMap[128*32];

    71     self.port = [HWUtils randomPort];

    66     self.port = [HWUtils randomPort];

    72 

    67 

    96                                           @"--internal",

    91                                           @"--internal",

    97                                           @"--port", ipcString,

    92                                           @"--port", ipcString,

    98                                           @"--user-prefix", documentsDirectory,

    93                                           @"--user-prefix", documentsDirectory,

    99                                           @"--landpreview",

    94                                           @"--landpreview",

   100                                           nil];

    95                                           nil];

   102         

    96         

   103         int argc = [gameParameters count];

    97         int argc = [gameParameters count];

   104         const char **argv = (const char **)malloc(sizeof(const char*)*argc);

    98         const char **argv = (const char **)malloc(sizeof(const char*)*argc);

   105         for (int i = 0; i < argc; i++)

    99         for (int i = 0; i < argc; i++)

   106             argv[i] = strdup([[gameParameters objectAtIndex:i] UTF8String]);

   100             argv[i] = strdup([[gameParameters objectAtIndex:i] UTF8String]);

   108         

   101         

   109         RunEngine(argc, argv);

   102         RunEngine(argc, argv);

   110         

   103         

   111         // cleanup

   104         // cleanup

   112         for (int i = 0; i < argc; i++)

   105         for (int i = 0; i < argc; i++)

   152         }

   145         }

   153     }

   146     }

   154     return;

   147     return;

   155 }

   148 }

   156 

   149 

   158     @autoreleasepool {

   151     @autoreleasepool {

   159     

   152     

   160     uint8_t unpackedMap[128*32*8];

   153     uint8_t unpackedMap[128*32*8];

   161     [self engineProtocol:unpackedMap];

   154     [self engineProtocol:unpackedMap];

   162 

   155 

   172 

   165 

   173     // all these are performed on the main thread to prevent a leak

   166     // all these are performed on the main thread to prevent a leak

   174     [self performSelectorOnMainThread:@selector(setImageRounded:)

   167     [self performSelectorOnMainThread:@selector(setImageRounded:)

   175                            withObject:previewImage

   168                            withObject:previewImage

   176                         waitUntilDone:NO];

   169                         waitUntilDone:NO];

   178     [self performSelectorOnMainThread:@selector(setLabelText:)

   170     [self performSelectorOnMainThread:@selector(setLabelText:)

   179                            withObject:[NSString stringWithFormat:@"%ld", (long)maxHogs]

   171                            withObject:[NSString stringWithFormat:@"%ld", (long)maxHogs]

   180                         waitUntilDone:NO];

   172                         waitUntilDone:NO];

   181     [self performSelectorOnMainThread:@selector(turnOnWidgets)

   173     [self performSelectorOnMainThread:@selector(turnOnWidgets)

   182                            withObject:nil

   174                            withObject:nil

   186                         waitUntilDone:NO];

   178                         waitUntilDone:NO];

   187     

   179     

   188     }

   180     }

   189 }

   181 }

   190 

   182 

   192     // remove the current preview and title

   184     // remove the current preview and title

   193     [self setImage:nil forState:UIControlStateNormal];

   185     [self setImage:nil forState:UIControlStateNormal];

   194     [self setTitle:nil forState:UIControlStateNormal];

   186     [self setTitle:nil forState:UIControlStateNormal];

   195 

   187 

   196     // don't display preview on slower device, too slow and memory hog

   188     // don't display preview on slower device, too slow and memory hog

   203                                               initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];

   195                                               initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];

   204         indicator.center = CGPointMake(self.bounds.size.width / 2, self.bounds.size.height / 2);

   196         indicator.center = CGPointMake(self.bounds.size.width / 2, self.bounds.size.height / 2);

   205         indicator.tag = INDICATOR_TAG;

   197         indicator.tag = INDICATOR_TAG;

   206         [indicator startAnimating];

   198         [indicator startAnimating];

   207         [self addSubview:indicator];

   199         [self addSubview:indicator];

   209 

   200 

   210         // let's draw in a separate thread so the gui can work; at the end it restore other widgets

   201         // let's draw in a separate thread so the gui can work; at the end it restore other widgets

   211         [NSThread detachNewThreadSelector:@selector(drawingThread) toTarget:self withObject:nil];

   202         [NSThread detachNewThreadSelector:@selector(drawingThread) toTarget:self withObject:nil];

   212     }

   203     }

   213 }

   204 }

   214 

   205 

   216     UIImage *image = [[UIImage alloc] initWithContentsOfFile:filePath];

   207     UIImage *image = [[UIImage alloc] initWithContentsOfFile:filePath];

   217     [self setImageRounded:image forState:UIControlStateNormal];

   208     [self setImageRounded:image forState:UIControlStateNormal];

   218     self.backgroundColor = [UIColor whiteColor];

   209     self.backgroundColor = [UIColor whiteColor];

   219     self.layer.cornerRadius = 12;

   210     self.layer.cornerRadius = 12;

   224     UIActivityIndicatorView *indicator = (UIActivityIndicatorView *)[self viewWithTag:INDICATOR_TAG];

   214     UIActivityIndicatorView *indicator = (UIActivityIndicatorView *)[self viewWithTag:INDICATOR_TAG];

   225     if (indicator) {

   215     if (indicator) {

   226         [indicator stopAnimating];

   216         [indicator stopAnimating];

   227         [indicator removeFromSuperview];

   217         [indicator removeFromSuperview];

   228     }

   218     }

   229 }

   219 }

   230 

   220 

   231 #pragma mark -

   221 #pragma mark -

   232 #pragma mark delegate

   222 #pragma mark delegate

   234     if ([self.delegate respondsToSelector:@selector(turnOnWidgets)])

   224     if ([self.delegate respondsToSelector:@selector(turnOnWidgets)])

   235         [self.delegate turnOnWidgets];

   225         [self.delegate turnOnWidgets];

   236 }

   226 }

   237 

   227 

   239     if ([self.delegate respondsToSelector:@selector(setMaxLabelText:)])

   229     if ([self.delegate respondsToSelector:@selector(setMaxLabelText:)])

   240         [self.delegate setMaxLabelText:string];

   230         [self.delegate setMaxLabelText:string];

   241 }

   231 }

   242 

   232 

   244     if ([self.delegate respondsToSelector:@selector(getDataForEngine)])

   234     if ([self.delegate respondsToSelector:@selector(getDataForEngine)])

   245         return [self.delegate getDataForEngine];

   235         return [self.delegate getDataForEngine];

   246     return nil;

   236     return nil;

   247 }

   237 }

   248 

   238