/*!
* \brief
* Load image file (8-bit BMP or PNG)
*
* \param filename
* File name with the image
*
* \returns
* Handler to the loaded image or NULL if error
*
* \see
* TLN_DeleteBitmap()
*/
TLN_Bitmap TLN_LoadBitmap (char *filename)
{
TLN_Bitmap bitmap;
if (!CheckFile (filename))
{
TLN_SetLastError (TLN_ERR_FILE_NOT_FOUND);
return NULL;
}
/* try png, else bmp*/
bitmap = LoadPNG (filename);
if (bitmap == NULL)
bitmap = LoadBMP (filename);
/* bitmap loaded */
if (bitmap)
{
/* accept only 8 bpp */
int bpp = TLN_GetBitmapDepth (bitmap);
if (bpp == 8)
TLN_SetLastError (TLN_ERR_OK);
else
{
TLN_DeleteBitmap (bitmap);
bitmap = NULL;
}
}
if (!bitmap)
TLN_SetLastError (TLN_ERR_WRONG_FORMAT);
return bitmap;
}
static void SetScene (int pos)
{
char filename[32];
Timeline* timeline;
maxpal = 0;
if (background)
TLN_DeleteBitmap (background);
sprintf (filename, "%s.PNG", scenes[pos].bitmap);
background = TLN_LoadBitmap (filename);
TLN_SetBGBitmap (background);
TLN_SetBGPalette (palette);
if (sp)
TLN_DeleteSequencePack (sp);
sprintf (filename, "%s.SQX", scenes[pos].sequence);
sp = TLN_LoadSequencePack (filename);
maxpal = 0;
timeline = scenes[pos].timeline;
while (timeline->palette)
{
TLN_Palette palette;
if (palettes[maxpal].palette)
TLN_DeletePalette (palettes[maxpal].palette);
sprintf(filename, "%s.ACT", timeline->palette);
palettes[maxpal].palette = TLN_LoadPalette (filename);
palettes[maxpal].sequence = TLN_FindSequence (sp, timeline->palette);
palettes[maxpal].time = timeline->seconds*MAX_TIME/86400;
/* remap: patch errors in original LBMs */
palette = palettes[maxpal].palette;
if (pos == 12)
TLN_SetPaletteColor (palette, 0, 0,0,0);
else if (pos == 13 || pos == 14)
TLN_SetPaletteColor (palette, 252, 11,11,11);
else if (pos == 15 || pos == 16 || pos == 17)
{
TLN_SetPaletteColor (palette, 0, 11,11,11);
TLN_SetPaletteColor (palette, 254, 0,0,0);
}
maxpal++;
timeline++;
}
frame = 18000*MAX_TIME/86400;;
pal = 0;
TLN_DisableAnimation (0);
}
JNIEXPORT jboolean JNICALL Java_Tilengine_DeleteBitmap (JNIEnv* env, jobject thisobj, jint bitmap)
{
return TLN_DeleteBitmap ((TLN_Bitmap)bitmap);
}
int main (int argc, char* argv[])
{
TLN_Init (640,480,0,0,1);
TLN_CreateWindow (NULL, CWF_VSYNC);
TLN_EnableBlur (true);
TLN_SetLoadPath ("cycles");
palette = TLN_CreatePalette (256);
palette_int = TLN_CreatePalette (256);
SetScene (pos);
while (TLN_ProcessWindow ())
{
if (TLN_GetInput (INPUT_LEFT))
{
if (dec == false)
{
dec = true;
pos = (pos - 1 + MAX_SCENE) % MAX_SCENE;
SetScene (pos);
}
}
else
dec = false;
if (TLN_GetInput (INPUT_RIGHT))
{
if (inc == false)
{
inc = true;
pos = (pos + 1) % MAX_SCENE;
SetScene (pos);
}
}
else
inc = false;
/* update palette */
if (!(frame & 0x01))
{
TLN_Palette pal1, pal2;
int t = frame % MAX_TIME;
int idx1 = FindTimeIndex (t);
int idx2 = (idx1 + 1) % maxpal;
int t1 = palettes[idx1].time;
int t2 = palettes[idx2].time;
if (t1 > t2)
{
t2 += MAX_TIME;
if (t < t1)
t += MAX_TIME;
}
t -= t1;
t2 -= t1;
pal1 = palettes[idx1].palette;
pal2 = palettes[idx2].palette;
TLN_MixPalettes (pal1, pal2, palette_int, t*255/t2); /* rescale t2 to 255 */
SetPalette (idx1);
}
TLN_DrawFrame (frame);
frame++;
}
TLN_DeleteBitmap (background);
TLN_DeletePalette (palette);
TLN_DeletePalette (palette_int);
TLN_DeleteWindow ();
TLN_Deinit ();
return 0;
}
/*!
* \brief
* Loads a tileset from a Tiled .tsx file
*
* \param filename
* TSX file to load
*
* \returns
* Reference to the newly loaded tileset or NULL if error
*
* \remarks
* An associated palette is also created, it can be obtained calling TLN_GetTilesetPalette()
*/
TLN_Tileset TLN_LoadTileset (char *filename)
{
SimpleXmlParser parser;
size_t size;
BYTE *data;
TLN_Tileset tileset;
TLN_Bitmap bitmap;
int htiles, vtiles;
int x,y,dx,dy;
int id;
int pitch;
/* load file */
data = LoadFile (filename, &size);
if (!data)
return NULL;
/* parse */
memset (&loader, 0, sizeof(loader));
parser = simpleXmlCreateParser (data, (long)size);
if (parser != NULL)
{
if (simpleXmlParse(parser, handler) != 0)
{
printf("parse error on line %li:\n%s\n",
simpleXmlGetLineNumber(parser), simpleXmlGetErrorDescription(parser));
free (data);
return NULL;
}
}
free (data);
/* check filename */
if (!loader.source[0])
return NULL;
/* load picture */
bitmap = TLN_LoadBitmap (loader.source);
if (!bitmap)
return NULL;
/* create tileset */
dx = loader.tilewidth + loader.spacing;
dy = loader.tileheight + loader.spacing;
htiles = (TLN_GetBitmapWidth(bitmap) - loader.margin*2 + loader.spacing) / dx;
vtiles = (TLN_GetBitmapHeight(bitmap) - loader.margin*2 + loader.spacing) / dy;
tileset = TLN_CreateTileset (htiles*vtiles, loader.tilewidth, loader.tileheight, TLN_ClonePalette(TLN_GetBitmapPalette(bitmap)));
pitch = TLN_GetBitmapPitch (bitmap);
/* load tiles */
for (id=1, y=0; y<vtiles; y++)
{
for (x=0; x<htiles; x++, id++)
{
BYTE *srcptr = TLN_GetBitmapPtr (bitmap, loader.margin + x*dx, loader.margin + y*dy);
TLN_SetTilesetPixels (tileset, id, srcptr, pitch);
}
}
TLN_DeleteBitmap (bitmap);
return tileset;
}
/*!
* \brief
* Loads a spriteset from a png/txt file pair
*
* \param name
* Base name of the files containing the spriteset
*
* \returns
* Reference to the newly loaded spriteset or NULL if error
*
* \remarks
* The spriteset comes in a pair of files called name.png and name.txt. The png file contains
* the spriteset, whereas the txt contains the coordinates of the rectangles that define individual sprites.
* These files can be created wit the spritesheet packer tool (http://spritesheetpacker.codeplex.com/)
* \remarks
* An associated palette is also created, it can be obtained calling TLN_GetSpritesetPalette()
*/
TLN_Spriteset TLN_LoadSpriteset (const char* name)
{
FILE *pf;
char filename[64];
char line[64];
int entries = 0;
TLN_Bitmap bitmap;
TLN_Spriteset spriteset;
TLN_Rect *rects, *rect;
int c;
/* load png file */
sprintf (filename, "%s.png", name);
bitmap = TLN_LoadBitmap (filename);
if (!bitmap)
return NULL;
/* load txt file */
sprintf (filename, "%s.txt", name);
pf = FileOpen (filename);
if (!pf)
{
TLN_DeleteBitmap (bitmap);
TLN_SetLastError (TLN_ERR_FILE_NOT_FOUND);
return NULL;
}
/* count lines */
while (fgets (line, 64, pf))
entries++;
rects = malloc (sizeof(TLN_Rect)*entries);
if (!rects)
{
TLN_DeleteBitmap (bitmap);
TLN_SetLastError (TLN_ERR_OUT_OF_MEMORY);
fclose (pf);
return NULL;
}
/* read entries */
fseek (pf, 0, SEEK_SET);
for (c=0; c<entries; c++)
{
char* equals;
char imagename[64];
/* lee linea */
fgets (line, 64, pf);
rect = &rects[c];
/* formato SpriteSheetPacker: name = x y w h */
equals = strchr (line, '=');
if (equals != NULL)
{
sscanf (line, "%s = %d %d %d %d", imagename, &rect->x, &rect->y, &rect->w, &rect->h);
continue;
}
/* formato Leshy SpriteSheet Tool csv: name,x,y,w,h */
equals = strchr (line, ',');
if (equals != NULL)
{
char* del = line;
while (*del)
{
if (*del == ',')
*del = ' ';
del++;
}
sscanf (line, "%s %d %d %d %d", imagename, &rect->x, &rect->y, &rect->w, &rect->h);
continue;
}
}
fclose (pf);
/* create */
spriteset = TLN_CreateSpriteset (
entries,
rects,
TLN_GetBitmapPtr (bitmap, 0,0),
TLN_GetBitmapWidth (bitmap),
TLN_GetBitmapHeight (bitmap),
TLN_GetBitmapPitch (bitmap),
TLN_ClonePalette(TLN_GetBitmapPalette(bitmap))
);
/* free resources */
free (rects);
TLN_DeleteBitmap (bitmap);
if (spriteset)
TLN_SetLastError (TLN_ERR_OK);
else
TLN_SetLastError (TLN_ERR_OUT_OF_MEMORY);
return spriteset;
}
