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 30x30 grid (0-29,0-29) of tiles, 20x20 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.
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.
Figure 3: The view with a different bounds.origin, centered on the player.
