A tilemap setup for the sparrow framework

sample_map_data.csv

SXCompiledTileMap.h

#import <Foundation/Foundation.h>
#import "Sparrow.h"
#import "SPCompiledSprite.h"
#import "SXTilemap.h"

#define SX_COMPILED_TILEMAP_RENDER_COMPLETE_EVENT @"renderComplete" 

@interface SXCompiledTileMap : SXTilemap {
	int quadrantsX;
	int quadrantsY;
	int quadrantWidth;
	int quadrantHeight;
	NSMutableDictionary *quadrants;
	NSMutableArray *imagePool;
	
	BOOL hasCompiled;
	
	int indexX;
	int indexY;
}

@property(nonatomic, readonly) BOOL hasCompiled;

- (void)drawQuadrantAtX:(int)xPos andY:(int)yPos;
- (void)showRelavantQuadrants;
- (void)showQuad:(SPCompiledSprite*)quad atX:(int)xPos andY:(int)yPos;
- (void)prerenderTick:(SPEnterFrameEvent*)event;

@end

SXCompiledTileMap.m

#import "SXCompiledTileMap.h"

@implementation SXCompiledTileMap

@synthesize hasCompiled;

- (id)initWithViewportSize:(CGSize)vpSize CSVData:(NSString *)csvData tileSize:(CGSize)tileSize andTileImage:(UIImage *)tileImage{
	self = [super initWithViewportSize:vpSize CSVData:csvData tileSize:tileSize andTileImage:tileImage];
	hasCompiled = NO;
	quadrants = [[NSMutableDictionary alloc] initWithCapacity:30];
	return self;
}

- (void)updateData{
	[super updateData];
	
	hasCompiled = NO;
	
	quadrantsX = ceil(mapWidth/floor(viewportWidth/tileWidth));
	quadrantsY = ceil(mapHeight/floor(viewportHeight/tileHeight));
	quadrantWidth = floor(viewportWidth/tileWidth);
	quadrantHeight = floor(viewportHeight/tileHeight);
	
	if(!imagePool){
		imagePool = [[NSMutableArray alloc] initWithCapacity:quadrantWidth * quadrantHeight];
	}
	
	int yy, xx;
	
	indexX = 0;
	indexY = 0;
	
	SPImage *img;
	for(yy=0; yy<quadrantHeight; yy++){
		for(xx=0; xx<quadrantWidth; xx++){
			img = [[SPImage alloc] initWithWidth:tileWidth height:tileHeight];
			[imagePool addObject:img];
		}
	}
	[self addEventListener:@selector(prerenderTick:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
}

- (void)prerenderTick:(SPEnterFrameEvent*)event{
	[self drawQuadrantAtX:indexX andY:indexY];
	if(indexX < quadrantsX){
		indexX += 1;
	}else{
		indexX = 0;
		indexY += 1;
	}
	if(indexX >= quadrantsX && indexY >= quadrantsY){
		hasCompiled = YES;
		[self dispatchEvent:[SPEvent eventWithType:SX_COMPILED_TILEMAP_RENDER_COMPLETE_EVENT]];
		[self removeEventListener:@selector(prerenderTick:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
		[self showRelavantQuadrants];
	}
}

- (void)updatePosition{
	[super updatePosition];
	if(!hasCompiled) return;
	[self showRelavantQuadrants];
}

- (void)showRelavantQuadrants{
	int quadX = floor(camera.x/viewportWidth);
	int quadY = floor(camera.y/viewportHeight);
	
	NSString *quadId0 = [NSString stringWithFormat:@"%d_%d", quadX, quadY];
	NSString *quadId1 = [NSString stringWithFormat:@"%d_%d", quadX + 1, quadY];
	NSString *quadId2 = [NSString stringWithFormat:@"%d_%d", quadX + 1, quadY + 1];
	NSString *quadId3 = [NSString stringWithFormat:@"%d_%d", quadX, quadY + 1];
	
	SPCompiledSprite *spr;

	
	float xPos;
	float yPos;
	
	while([self numChildren] > 0){
		[self removeChildAtIndex:0];
	}
	
	spr = [quadrants objectForKey:quadId0];
	xPos = ((quadX * quadrantWidth) * tileWidth) - camera.x;
	yPos = ((quadY * quadrantHeight) * tileHeight) - camera.y;
	[self showQuad:spr atX:xPos andY:yPos];
	
	spr = [quadrants objectForKey:quadId1];
	xPos += (quadrantWidth * tileWidth);
	[self showQuad:spr atX:xPos andY:yPos];
	
	spr = [quadrants objectForKey:quadId2];
	yPos += (quadrantHeight * tileHeight);
	[self showQuad:spr atX:xPos andY:yPos];
	
	spr = [quadrants objectForKey:quadId3];
	xPos -= (quadrantWidth * tileWidth);
	[self showQuad:spr atX:xPos andY:yPos];
	
}

- (void)showQuad:(SPCompiledSprite*)quad atX:(int)xPos andY:(int)yPos{
	if(quad){
		quad.x = xPos;
		quad.y = yPos;
		[self addChild:quad];
	}
}

- (void)drawQuadrantAtX:(int)xPos andY:(int)yPos{
	int startX, startY, endX, endY;
	
	startX = xPos * quadrantWidth;
	startY = yPos * quadrantHeight;
	endX = startX + quadrantWidth;
	endY = startY + quadrantHeight;
	
	if(startX > mapWidth) return;
	if(startY > mapHeight) return;
	if(endX > mapWidth) endX = mapWidth;
	if(endY > mapHeight) endY = mapHeight;

	SPCompiledSprite *quad = [[[SPCompiledSprite alloc] init] autorelease];
	NSString *quadId = [NSString stringWithFormat:@"%d_%d", xPos, yPos];
	[quadrants setObject:quad forKey:quadId];
	
	int tileIndex;
	int *pixels = [data mutableBytes];
	
	float xOffset = 0;
	float yOffset = 0;
	
	int i = 0;
	
	for(int yy=startY; yy<endY; yy++){
		for(int xx=startX; xx<endX; xx++){
			tileIndex = (yy * mapWidth) + xx;
			SPImage *img = [imagePool objectAtIndex:i];
			img.texture = [[tiles objectAtIndex:pixels[tileIndex]] texture];
			img.x = xOffset;
			img.y = yOffset;
			[quad addChild:img];
			xOffset += tileWidth;
			i ++;
		}
		xOffset = 0;
		yOffset += tileHeight;
	}
	[quad compile];
	
	while([quad numChildren] > 0){
		[quad removeChildAtIndex:0];
	}
}

- (void)dealloc{
	if(!hasCompiled && [self hasEventListenerForType:SX_COMPILED_TILEMAP_RENDER_COMPLETE_EVENT]){
		[self removeEventListener:@selector(prerenderTick:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
	}
	[quadrants removeAllObjects];
	[quadrants release];
	while([self numChildren] > 0) {
		[self removeChildAtIndex:0];
	}
	[super dealloc];
}



@end

SXTilemap.h

#import <Foundation/Foundation.h>
#import "Sparrow.h"

@interface SXTilemap : SPSprite{
	NSMutableData *data;
	NSMutableArray *tiles;
	
	int tileWidth;
	int tileHeight;
	int mapWidth;
	int mapHeight;
	
	int viewportWidth;
	int viewportHeight;
	
	BOOL hasData;
	BOOL hasTileImage;
	
	SPPoint *camera;
	SPPoint *oldCam;
	
	BOOL flagForRefresh;
	
	BOOL updating;
}

@property (nonatomic, assign) int tileWidth;
@property (nonatomic, assign) int tileHeight;
@property (nonatomic, assign) int mapWidth;
@property (nonatomic, assign) int mapHeight;
@property (nonatomic, retain) NSMutableData *data;
@property (nonatomic, retain) NSMutableArray *tiles;
@property (nonatomic, retain) SPPoint *camera;

- (id)initWithViewportSize:(CGSize)vpSize CSVData:(NSString*)csvData tileSize:(CGSize)tileSize andTileImage:(UIImage*)tileImage;
- (void)createFromCSV:(NSString*)csvData;
- (void)createTilesFromImage:(UIImage*)img;
- (void)changeTileId:(int)tileId forX:(int)xPos andY:(int)yPos;

- (BOOL)mapReady;

- (void)updatePosition;
- (void)updateData;
- (void)update:(SPEnterFrameEvent*)event;
- (void)startUpdates;
- (void)stopUpdates;

@end

SXTilemap.m

#import "SXTilemap.h"

// internal methods
@interface SXTilemap()
- (void)initVars;
@end

@implementation SXTilemap

@synthesize mapWidth;
@synthesize mapHeight;
@synthesize tileWidth;
@synthesize tileHeight;
@synthesize data;
@synthesize tiles;
@synthesize camera;

- (id)init{
    self = [super init];
	[self initVars];
    return self;
}

- (void)initVars{
	self.data = [[[NSMutableData alloc] init] autorelease];
	self.camera = [[[SPPoint alloc] initWithX:0 y:0] autorelease];
	self.tiles = [[[NSMutableArray alloc] init] autorelease];
	oldCam = [[SPPoint alloc] initWithX:0 y:0];
	tileWidth = 16;
	tileHeight = 16;
	viewportWidth = 320;
	viewportHeight = 480;
}

- (id)initWithViewportSize:(CGSize)vpSize CSVData:(NSString*)csvData tileSize:(CGSize)tileSize andTileImage:(UIImage*)tileImage{
	self = [super init];
	[self initVars];
	tileWidth = tileSize.width;
	tileHeight = tileSize.height;
	viewportWidth = vpSize.width;
	viewportHeight = vpSize.height;
	[self createFromCSV:csvData];
	[self createTilesFromImage:tileImage];
	return self;
}

- (void)createFromCSV:(NSString*)csvData{
	csvData = [csvData stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceCharacterSet]]; // trim whitespace
	NSArray *rows = [csvData componentsSeparatedByString:@"\n"];
	mapHeight = [rows count];
	mapWidth = [[[rows objectAtIndex:0] componentsSeparatedByString:@","] count];
	
	int amount = ((mapWidth) * (mapHeight)) + mapWidth;
	[data setLength:amount*sizeof(int)];
	
	int *pixels = [data mutableBytes];
	
	hasData = YES;
	
	NSArray *colData;
	int i = 0;
	for(NSString *row in rows){
		colData = [row componentsSeparatedByString:@","];
		for(NSString *val in colData){
			pixels[i] = [val intValue];
			i++;
		}
	}
	hasData = YES;
	if([self mapReady]){
		[self startUpdates];
		flagForRefresh = YES;
	}
}
	   
- (void)createTilesFromImage:(UIImage*)img{
   int amount = floor(img.size.width/tileWidth);
   if(tiles.count > 0){
	   [tiles removeAllObjects];
   }
   SPTexture *tilesTexture = [[SPTexture alloc] initWithContentsOfImage:img];
   for(int i=0; i<amount; i++){
	   SPRectangle *rect = [[SPRectangle alloc] initWithX:i*(tileWidth) y:0 width:tileWidth height:tileHeight];
	   SPSubTexture *tileTexture = [[SPSubTexture alloc] initWithRegion:rect ofTexture:tilesTexture];
	   SPImage *tileImage = [[SPImage alloc] initWithTexture:tileTexture];
	   [tiles addObject:tileImage];
	   [rect release];
	   [tileTexture release];
	   [tileImage release];
   }
   [tilesTexture release];
   hasTileImage = YES;
	if([self mapReady]){
		[self startUpdates];
		flagForRefresh = YES;
	}
}

- (BOOL)mapReady{
	return hasData && hasTileImage;
}

- (void)startUpdates{
	if(!updating){
		[self addEventListener:@selector(update:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
		updating = YES;
	}
}

- (void)stopUpdates{
	if(updating){
		[self removeEventListener:@selector(update:) atObject:self forType:SP_EVENT_TYPE_ENTER_FRAME];
		updating = NO;
	}
}

- (void)updatePosition{
	// override for scrolling
}

- (void)updateData{
	// override for when overalldata has been changed
}

- (void)update:(SPEnterFrameEvent*)event{
	if(oldCam.x != camera.x || oldCam.y != camera.y){
		if(!flagForRefresh){
			[self updatePosition];
			oldCam.x = camera.x;
			oldCam.y = camera.y;
		}
	}
	if(flagForRefresh){
		[self updateData];
		flagForRefresh = NO;
	}
}

- (void)changeTileId:(int)tileId forX:(int)xPos andY:(int)yPos{
	int *pixels = [data mutableBytes];
	int tileIndex = (yPos * mapWidth) + xPos;
	pixels[tileIndex] = tileId;
}

- (void)dealloc{
	self.camera = nil;
	self.tiles = nil;
	self.data = nil;
	[oldCam release];
	[self stopUpdates];
    [super dealloc];
}

@end

Here's a modified version of SXTilemap's createTilesFromImage: method that allows you to use an image with a grid of tiles (not just a horizontal strip):

- (void)createTilesFromImage:(UIImage*)img{
    int tilesWide = floor(img.size.width/tileWidth);
    int tilesHigh = floor(img.size.height/tileHeight);

    if(tiles.count > 0){
        [tiles removeAllObjects];
    }

    SPTexture *tilesTexture = [[SPTexture alloc] initWithContentsOfImage:img];
    for (int yy=0; yy<tilesHigh; yy++) {
        for (int xx=0;xx<tilesWide; xx++) {
            SPRectangle *rect = [[SPRectangle alloc] initWithX:xx*tileWidth y:yy*tileHeight width:tileWidth height:tileHeight];
            SPSubTexture *tileTexture = [[SPSubTexture alloc] initWithRegion:rect ofTexture:tilesTexture];
            SPImage *tileImage = [[SPImage alloc] initWithTexture:tileTexture];
            [tiles addObject:tileImage];
            [rect release];
            [tileTexture release];
            [tileImage release];
        }
    }
    [tilesTexture release];

    hasTileImage = YES;
    if([self mapReady]){
        [self startUpdates];
        flagForRefresh = YES;
    }
}

That's awesome thanks for posting that. Sent from my mobile device.

…

On Jan 12, 2012, at 9:09 PM, shauninman ***@***.*** wrote: Here's a modified version of `SXTilemap`'s `createTilesFromImage:` method that allows you to use an image with a grid of tiles (not just a horizontal strip): - (void)createTilesFromImage:(UIImage*)img{ int tilesWide = floor(img.size.width/tileWidth); int tilesHigh = floor(img.size.height/tileHeight); if(tiles.count > 0){ [tiles removeAllObjects]; } SPTexture _tilesTexture = [[SPTexture alloc] initWithContentsOfImage:img]; for (int yy=0; yy<tilesHigh; yy++) { for (int xx=0;xx<tilesWide; xx++) { SPRectangle *rect = [[SPRectangle alloc] initWithX:xx_tileWidth y:yy*tileHeight width:tileWidth height:tileHeight]; SPSubTexture *tileTexture = [[SPSubTexture alloc] initWithRegion:rect ofTexture:tilesTexture]; SPImage *tileImage = [[SPImage alloc] initWithTexture:tileTexture]; [tiles addObject:tileImage]; [rect release]; [tileTexture release]; [tileImage release]; } } [tilesTexture release]; hasTileImage = YES; if([self mapReady]){ [self startUpdates]; flagForRefresh = YES; } } --- Reply to this email directly or view it on GitHub: https://gist.github.com/896866