Nested Query Blocks to load data into UITableView

Here's what you could try to do:

-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];

    PFQuery *gameQuery = [PFQuery queryWithClassName:@"Game"];
    [gameQuery whereKey:@"players" equalTo:[PFUser currentUser]];
    [gameQuery orderByDescending:@"createdAt"];

    [gameQuery findObjectsInBackgroundWithBlock:^(NSArray *objects, NSError *error){

        @synchronized(self.allGames) {
            self.allGames = [NSArray arrayWithObjects: [NSMutableArray array], [NSMutableArray array], [NSMutableArray array], nil];
            // These two instance variables contain values used in asynchronous blocks, to know how much responses are still expected
            self.expectedNbGames = [objects count];
            self.fetchedNbGames = 0;
        }

        for(PFObject *object in objects)
        {
            if([object objectForKey:@"isOver"] == [NSNumber numberWithBool:YES])
            {
                @synchronized(self.allGames) {
                    [((NSMutableArray *)self.allGames[2]) addObject:object];
                    self.fetchedNbGames++;
                }
            }

            else
            {
                PFRelation *relation = [object relationForKey:@"whoseTurn"];
                PFQuery *relQuery = [relation query];
                [relQuery findObjectsInBackgroundWithBlock:^(NSArray *userObjects, NSError *error1){

                    NSMutableArray *arr = [NSMutableArray array];
                    for(PFUser *user in userObjects)
                    {
                        [arr addObject:user.objectId];
                    }

                    @synchronized(self.allGames) {
                        if([arr containsObject:[PFUser currentUser].objectId])
                        {
                            [((NSMutableArray *)self.allGames[0]) addObject:object];
                        }

                        else
                            [((NSMutableArray *)self.allGames[1]) addObject:object];
                        }

                        self.fetchedNbGames++;
                        if (self.fetchedNbGames == self.expectedNbGames)
                        {
                            // We have now received the last expected response, it's time to sort everything again in descending order based on the "createdAt" value
                            NSSortDescriptor *dateDescriptor = [NSSortDescriptor sortDescriptorWithKey:@"createdAt" ascending:NO];
                            NSArray *sortDescriptors = [NSArray arrayWithObject:dateDescriptor];
                            // self.allGames[0] is already sorted anyway because it's been left untouched from the initial PFQuery
                            self.allGames[1] = [self.allGames[1] sortedArrayUsingDescriptors:sortDescriptors];
                            self.allGames[2] = [self.allGames[2] sortedArrayUsingDescriptors:sortDescriptors];
                            // And... reload one last time!
                            dispatch_async(dispatch_get_main_queue(), ^{
                                [self.tableView reloadData];
                            });
                        }
                    }

                    dispatch_async(dispatch_get_main_queue(), ^{
                        [self.tableView reloadData];
                    });
                }];
            }

        }

        [self.tableView reloadData];
    }];
}

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    @synchronized(self.allGames) {
        return [self.allGames count];
    }
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    @synchronized(self.allGames) {
        return [[self.allGames objectAtIndex:section] count];
    }
}

- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *MyIdentifier = @"MyIdentifier";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:MyIdentifier];

    if (cell == nil)
    {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
                                       reuseIdentifier:MyIdentifier];
    }

    @synchronized(self.allGames) {
        PFObject *object = self.allGames[indexPath.section][indexPath.row];
        cell.textLabel.text = [object objectForKey:@"numPlayers"];
    }

    return cell;
}

The @synchronized() construct is used to ensure thread-safety, because you will be accessing (both reading and writing) the sell.allGames array from different threads (the main thread, but also asynchronous blocks coming from Parse replies).

Note that we're dispatching the reloadData multiple times from the asynchronous blocks because there is currently no way in your code to know when all the blocks have finished running. We need to dispatch this call on the main thread, because it will trigger UI updates, and those always have to be done on the main thread.

See if this works, and maybe you'll be able to improve it a little bit using properties for example (to avoid writing @synchronized() every time you're using self.allGames).

UPDATE: I've improved my answer by providing a way to re-sort everything after all responses have been received. This process involves the creation of two new instance variables (integers named fetchedNbGames and expectedNbGames) that have to be updated and compared to each other after every response received from Parse. Once all responses have been received, the results array can be re-sorted (it might have been disordered because of requests being sent and handled asynchronously) and the table view refreshed again.

This is untested and there is probably a lot of room for improvements, but it's up to you to tune it to your needs, you get the basic idea.

Also see this other SO thread for a more visual explanation of your problem related to threading and asynchronous calls.