Question

Currently writing a roguelike to learn more about Objective-C/Cocoa. I’m really enjoying it so far and I’ve learned tons.

This code moves the origin of the view’s bounds, so that it follows the player as he moves. The code works perfect, I was just asking if there was a better way than using four for‘s.

I’ve also seen in some cases that it’s better to do things separately instead of all in one, especially where drawing and nsbezierpath is concerned, why is that?

Edit: People were having trouble figuring out exactly what I’m doing, so I’m going to break it down as much as I can.

The view is a 30×30 grid (0-29,0-29) of tiles, 20×20 each. The map can be as big or small as needs to be.

First, you get the [player_ location], along with the origin of the bounds for the view. It’s divided by 20 because the tile size is 20, so when it’s at (1,2), it’s actually at (20,40). The only reason I do this is to make it easier to manipulate (It’s easier to count in units of 1 as opposed to 20). The four for‘s go through and check that the [player_ location] is within 15 tiles of the center (bounds + 15) of the view. If the player is moving towards one of the edges of the screen, and bounds.x/y + 30 is less than the height of the current map/width, it moves the origin so that the player is still centered and displayed on the map.

The code works perfect, and I moved the setbounds to after the for‘s happen, and there’s only one. It isn’t being left in drawRect, I just had it here to try and figure out what I needed to do. It’s now in it’s own place and is only called when the player actually moves.

Here’s the new code:

- (void)keepViewCentered
{
    NSPoint pl = [player_ location];
    NSPoint ll;
    NSPoint location = [self bounds].origin;
    ll.x = location.x / 20;
    ll.y = location.y / 20;
    for ( pl.y = [player_ location].y; pl.y >= ll.y + 15 && ll.y + 30 < [currentMap_ height]; ll.y++ )
    {
        location.y = ll.y * 20;
    }
    for ( pl.x = [player_ location].x; pl.x >= ll.x + 15 && ll.x + 30 < [currentMap_ width]; ll.x++ )
    {
        location.x = ll.x * 20;
    }
    for ( pl.y = [player_ location].y; pl.y <= ll.y + 15 && ll.y >= 0; ll.y-- )
    {
        location.y = ll.y * 20;
    }
    for ( pl.x = [player_ location].x; pl.x <= ll.x + 15 && ll.x >= 0; ll.x-- )
    {
        location.x = ll.x * 20;
    }
    [self setBoundsOrigin: location];
}

Here are pictures of it in action!

Figure 1: This is the player at 1,1. Nothing special.
http://sneakyness.com/stackoverflow/SRLbounds1.png

Figure 2: The 3 gold pieces represent how far the player can move before the view’s bounds.origin will move to stay centered on the player. Although irrelevant, notice that the player cannot actually see the gold. Turns out programming field of vision is a field of much debate and there are several different algorithms you can use, none of which don’t have downsides, or have been ported to Objective-C. Currently it’s just a square. See through walls and everything.
http://sneakyness.com/stackoverflow/SRLbounds2.png

Figure 3: The view with a different bounds.origin, centered on the player.
http://sneakyness.com/stackoverflow/SRLbounds3.png

Answer 1

It’s now in it’s own place and is only called when the player actually moves.

Yay!

I was just asking if there was a better way than using four for‘s.

Here’s my suggestion:

1. Set the lower-left to the player’s location minus 15.

   ll.x = [player_ location].x - 15.0;
   ll.y = [player_ location].y - 15.0;

2. Make sure that it does not exceed the bounds of the view.

   if (ll.x < 0.0)
       ll.x = 0.0;
   if (ll.y < 0.0)
       ll.y = 0.0;
   if (ll.x > [currentMap_ width] - 30.0)
       ll.x = [currentMap_ width] - 30.0;
   if (ll.y > [currentMap_ height] - 30.0)
       ll.y = [currentMap_ height] - 30.0;

3. Multiply by your tile size and set as the new bounds origin.
   location.x = ll.x * 20.0;
   location.y = ll.y * 20.0;
   [self setBoundsOrigin: location];

I also suggest that you not hard-code the tile size and player sight range.

For the tile size, you may prefer to give your view a couple of properties expressing width and height in tiles, then using the CTM to scale to (widthInPoints / widthInTiles), (heightInPoints / heightInTiles). Then you can let the user resize your window to change the tile size.

For the player’s sight range (currently 30 tiles square), you may want to make this a property of the player, so that it can change with skill stats, items equipped, and the effects of potions, monster attacks, and wraths of the gods. One caveat: If the player’s sight range can become longer than the game window will fit (especially vertically), you’ll want to add a check for that to the above code, and handle it by putting the player dead-center and possibly zooming out.