<?xml version="1.0" encoding="utf-8"?><rss version="2.0"><channel>
<title>Idea.informer.com RSS - The TilemapKit Roadmap is yours!</title>
<link>http://idea.informer.com</link>
<language>en</language>
<copyright>UserIdea.com</copyright>
<item>
<title>TK: optionally RLE compress tile arrays</title>
<pubDate>Sat, 31 Oct 2015 16:08:54 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=98941</link>
<description><![CDATA[Some maps may have tile layers that are mostly empty or have large areas of the same tile. Such tile arrays could benefit from RLE (run-length encoding) compression, trading some runtime performance for less memory usage.

This should be a layer property in Tiled that turns this setting on/off per tile layer, since certain tile layers may actually use more memory than without compression.
]]></description>
</item>
<item>
<title>TK: 3D Tilemap renderer, extrude tiles into 3rd dimension</title>
<pubDate>Fri, 09 Oct 2015 13:14:45 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=98335</link>
<description><![CDATA[Port TilemapKit to a SceneKit/Cocos2d-x 3D renderer to render tilemaps in 3D. Tiles are extruded to 3D shapes with configurable "extrusion depth" and textures (defaults to using tile texture for all faces).

The cuboids use the tile graphics as texture for all sides, with optionally being able to use different textures for top and bottom (or any) faces.

The first versions will focus on orthogonal maps as they benefit the most from 3D extrusion.

This would allow for 3D world space for games that essentially still have 2D gameplay, ie platformers (Duke Nukem Manhatten Story comes to mind).

I estimate this task would take about 2 weeks.


PS: this would also pave way for a voxel renderer for game characters which could also be extruded from 2D images and an (optional) heightmap image. Just another idea I've been contemplating like so many others. ;)
]]></description>
</item>
<item>
<title>TK: get object(s) whose shape contains point</title>
<pubDate>Sat, 26 Sep 2015 12:15:05 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=98056</link>
<description><![CDATA[TKMap(Node) should have these methods:

-(TKObject*) objectAt:(CGPoint)locationInMap;
-(NSArray*) objectsAt:(CGPoint)locationInMap;

Returning the object(s) whose shape (rectangle, polygon, ellipse) contains the point (in the map's coordinate space). This allows for touch/click detection of objects as well as triggering game events when the location is a position of a character on the map (ie player walks over polygon object which emits a sound effect).
]]></description>
</item>
<item>
<title>TK: Port TilemapKit to C#, support MonoGame</title>
<pubDate>Fri, 11 Sep 2015 11:48:29 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97688</link>
<description><![CDATA[Port the model classes to C# and rewrite the renderer in C# for use with MonoGame.

Integrate it into Content Pipeline and ensure compatibility with the most popular platforms.


As a side-effect, this would also make the Unity port more viable: http://tilemapkit.idea.informer.com/proj/?ia=97656]]></description>
</item>
<item>
<title>TK: Port TilemapKit to C#, support Unity (2D)</title>
<pubDate>Wed, 09 Sep 2015 11:45:19 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97656</link>
<description><![CDATA[TilemapKit is currently written in Objective-C and in the process of being ported to C++ / Cocos2D-X.

If you would love to have TilemapKit available for Unity, please vote for it!


TilemapKit for Unity would work similar to "Tiled to Unity" (except that it'll draw 2D tiles, not tile-able 3D models) and would have far more features than "UniTMX". With TilemapKit you'll get the same map as you see in Tiled right into Unity, including "tile to screen" conversion and back.

In addition, Pathfinding support seems absolutely feasible, both Unity's built-in and Aron Granberg's A* Pathfinding Project.


As a side-effect, this would also make the MonoGame port more viable: http://tilemapkit.idea.informer.com/proj/tilemapkit?ia=97688]]></description>
</item>
<item>
<title>Integrate Collision Detection</title>
<pubDate>Sun, 06 Sep 2015 09:47:46 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97579</link>
<description><![CDATA[Every platform game needs to know, when dynamic sprites collide with the background. To do this Tiled allows to define a collision layer per tile in a tile set. It would be very helpful to activate physics collision detection per tile by the Tilekit API. To do that, it would be sufficient to give access to a physicsbody template for each tile in the tileset and copy it to the physicsbody of the sprite, rendering the tile on the screen.]]></description>
</item>
<item>
<title>Sell a low-cost binary framework (no source code)</title>
<pubDate>Fri, 04 Sep 2015 10:59:40 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97527</link>
<description><![CDATA[Is TilemapKit source code too costly for you? If so, please vote on this idea!

Binary frameworks with precompiled code could be offered for a lower cost. The price range would be $20-$35.


=== Possibly Omitted Features ===

There are several things that could be omitted in the binary frameworks to keep the source code versions more enticing. 

- Framework could support only specific map types - ie 3 editions available, each only supports either Ortho, Iso, or Hex maps - you would purchase only one map type, or pay double and get all 3 map types.
- Framework could be built in Debug configuration - ie compiler optimized code would be limited to source code editions (performance would roughly be 1-15% less)
- Framework could exclude the GameplayKit features (graph creation)

If you have a strong preference or additional suggestions, please leave a comment, thank you!

--- Notes ---

- Any binary framework for Cocos2D would have a specific version of the cocos2d source code already built into it. Meaning: you would not be able to modify or debug Cocos2D code when using TilemapKit.framework.
- This task does *not* include / extend to a Cocos2D-X binary framework.

=== Vote Goal ===

Once this task reaches 100 votes the binary builds will be released within 2 weeks. 

Share the link to speed things up! ;)]]></description>
</item>
<item>
<title>TKProperties: allow default values in code</title>
<pubDate>Thu, 27 Aug 2015 10:33:55 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97345</link>
<description><![CDATA[Extend the TKProperties interface in a way that allows setting the defaults in code:
 
Existing: -(BOOL) boolForKey:(nonnull NSString*)key; // defaults to NO
Wishlist: -(BOOL) boolForKey:(nonnull NSString*)key withDefaultValue:(BOOL) value;]]></description>
</item>
<item>
<title>TileSplitter: extract tiles from tileset image</title>
<pubDate>Wed, 26 Aug 2015 10:20:41 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97322</link>
<description><![CDATA[You may know the problem: you found a really nice tileset, but it comes as a pre-made tileset image (atlas). But you'd really like to (or need to):

- re-arrange the tiles to have the layout fit your needs (or any logic at all)
- only use some of the tiles, not all of them
- figure out what the tileset image's grid size, spacing and margin actually are
- have all the tiles as individual files, for whatever reason (ie using Tiled's image collection tileset and packing the tileset with the tool of your choice)

With TileSplitter you would have a tool that allows you to load a tileset (atlas) image and experiment with spacing, margin and grid size until it seems about right, then extract the tiles as individual, sequentially numbered images. You could also extract the same image multiple times with different settings in case the tiles aren't all aligned on the same grid (yeah, apparently some artists do not understand the whole purpose of aligning tiles on the same grid).

The problem with existing tools that do this are:

- they were not made for tilemap tiles but rather tiling website images
- they may have worked once before, but they are now dysfunctional and abandoned projects
- they are command-line only tools that are hard to understand and you can't modify them because they were written in one of those really, really weird languages like Ruby or Perl
- they are inflexible, don't allow to specify (important or any) parameters
- they may only read from proprietary map or "game making tool" formats
- they output in an unusable format (gif, bmp, jpg, tiff, proprietary) that would (at best) require additional conversion
- some cost a lot more for what they're worth (ie 40$ and more)  -- TileSplitter is intended to be bundled with TilemapKit

Estimate: 2 weeks (OS X app with GUI)]]></description>
</item>
<item>
<title>TK: Automatic Draw Order for Maps &quot;with depth&quot;</title>
<pubDate>Thu, 13 Aug 2015 15:51:21 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=97005</link>
<description><![CDATA[Idea based on this forum post: http://forum.tilemapkit.com/t/understanding-the-basics-how-to-work-with-sprites-and-faux-3d/52

There should be a mode where the draw order of tiles and any node on tile/object layers depends on their y coordinate. This ensures that for maps with "pseudo depth" (example: http://www.twinfinite.net/wp-content/uploads/2015/03/ultima-online-shack.jpg) the tiles and figures correctly clip. 

For instance a player can walk up to the front of a house or chair and will be drawn entirely in front of it. Then he moves to the backside of the house or chair and is partially (or completely) hidden by the object.

This may require a different rendering mode that disregards Tiled's layers, and instead assumes all tiles to be on the same layer with layers for rendering. Then the z order of tiles isn't constricted to a particular layer (the chair would be a problem, because a player character might not be on the same layer as the chair, thus the player would always be either in front of or behind the chair regardless of the y coord).

It was also suggested to have a custom z order per tile, but Tiled doesn't allow properties per tile coord, only properties for each tile. So that probably won't help, but technically it would be trivial to implement in the renderer. So perhaps we need to consider the idea of having a separate (non-visible) z order layer whose only use is to flag tiles that should "move one layer up/down" based on a reference node's y coord.

Okay, clearly this needs more thought put into it. :)
The request should be clear but the (best) solution isn't. Not yet.

Estimate: 5 days, due to likely adding a new rendering mode and additional testing.
]]></description>
</item>
<item>
<title>GameplayKit: Agents/Steering bevahior without iOS9</title>
<pubDate>Wed, 12 Aug 2015 10:18:18 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=96964</link>
<description><![CDATA[Make it possible to deploy on older iOS versions ]]></description>
</item>
<item>
<title>TK: TextureAtlas support for Image Collection Tilesets</title>
<pubDate>Tue, 04 Aug 2015 19:18:10 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=96755</link>
<description><![CDATA[Currently "Collection of Images" Tilesets are already supported, but only using individual images.

However it's possible to use image collections and then pack them in an atlas, effectively indexing tile images by name rather than GID and offset within texture.

Details here:
http://forum.mapeditor.org/t/best-way-to-use-tiled-with-texture-packer-custom-game-engine/361

This should be straightforward except for the tile texture caching and lookup algorithms, they may need a different "mode" and the use of texture rects would not be necessary.

Estimate: 1-3 days.
]]></description>
</item>
<item>
<title>TK: Individual tileOverlap per Layer</title>
<pubDate>Fri, 31 Jul 2015 13:18:17 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=96677</link>
<description><![CDATA[When using a special layer with only black, half transparent tiles (e.g. to darken specific tiles with a fog of war), using the TKMap.tileOverlap = 0.25 setting re-introduces the dreaded black lines, since on the junctions in between the tiles the fog-of-war-tile gets drawn twice. 

If this option could be switched on on a per layer basis, one could profit from it for the solid ground tiles, but ignore it for layers with half-transparent tiles. Not sure, if this would improve the rendering, though, as this may introduce other problems.]]></description>
</item>
<item>
<title>TK: Port TilemapKit to C++, support Cocos2D-X v3.x</title>
<pubDate>Fri, 24 Jul 2015 16:54:51 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=96551</link>
<description><![CDATA[UPDATE: Early access version available at 33% off until October 30th: 
   https://tilemapkit.com/downloads/tilemapkit-cocos2d-x-source/

Port TilemapKit to C++ and make it compatible with Cocos2D-X and Android development. For other platforms besides Android we would need a volunteer to test TilemapKit with.

The C++ port will replace the Objective-C TMX model classes (TKMap, TKLayer, TKTileset etc - not the nodes) while providing API compatibility through Objective-C wrapper classes. Basically existing Objective-C code is refactored into a C++ class while the original interface just forwards calls to the corresponding C++ class. Overall this should increase performance slightly even for ObjC users.

If this idea is implemented, TilemapKit will require Cocos2D-X v3.x and will be ported to the latest stable v3.x available at the time. Then it can be tested and fixed to be backwards compatibility with earlier v3.x versions as far back as ... is both reasonable and relatively effortless (no promises, except for being reasonable that is).

Note: Unless it happens "automagically", the porting effort described here would not extend to supporting the Lua, Javascript and C# versions / scripting interfaces provided by Cocos2D-X, nor will it include testing other frameworks Cocos2D-X is embedded in (Marmalade), nor will it work with web platforms. Desktop platform support depends on demand and ease of adaptation, so that's a conservative "maybe".

Lastly, and most likely, the Cocos2D-X port will only be available as source code license (no binary framework).]]></description>
</item>
<item>
<title>TK: enumerate tiles in rectangle or radius (or all tiles)</title>
<pubDate>Fri, 24 Jul 2015 11:18:51 -0400</pubDate>
<link>http://tilemapkit.idea.informer.com/proj/?ia=96547</link>
<description><![CDATA[Provide a safe way to enumerate tile GIDs in the C memory buffer. Most likely by implementing a version of enumerateTilesUsingBlock - although enumerating all tiles would be nice to be able to do with fast enumeration as well, it couldn't provide the tile's coordinates.

[tileLayer enumerateTilesUsingBlock:^(void)(TKTileGID tile, TKPoint coord) {
}];

[tileLayer enumerateTilesInRadius:10 center:TKPointMake(44, 17) usingBlock:^(void)(TKTileGID tile, TKPoint coord) {
}];

[tileLayer enumerateTilesInRectangle:CGRectMake(-5, -5, 10, 10)  center:TKPointMake(44, 17) usingBlock:^(void)(TKTileGID tile, TKPoint coord) {
}];]]></description>
</item>
</channel></rss>