I did a ton of tilebased stuff in the past, so i can share my ideas how i implemented them. So here we go:
In a few of my game prototypes i used one texture tile sheet for each style. The outside of such sheets had a one pixel transparent space/border around the entire image and one pixel transparent border around each tile, so that every tile inside has two pixels of space between. This border/space gets really important when you use them in your shaders, like for example doing color corrections, doing blending etc. Without border you may get bleeding or other weird artifacts
Also the tile sheet should be a power of two dimension, like for example 256x512 or 256x256 or 512x512, etc. This makes the computing of the UV´s much easier.
For environment tiles i used at least 5 layers - each layer had a fixed tile size of 32x32. The first layer was a background layer used for filling background tiles, like gras, sky, etc. The second layer was another background layer used for more detailed backgrounds, like floors, trees, window, flowers, signs, etc.
The next two layers was used for solid tiles only, meaning that it had some sort of collision/boundary. Each tile had a reference to a geometrical collision shape (rectangle, circle, polygon, etc). If you need pixel perfect collision, i highly recommend reading the "Sonic Physics Guide". If you need physics in your game, you should convert your solid tiles into connected line segments - making it very robust and fast for physics system such as Box2D. But computing these line segments from solid tiles are nasty and not that easy, but i did that in the past and released a public domain library:
https://github.com/f1nalspace/final_game_tech/blob/master/demos/FTT_TileTracingDemo/ftt_tiletracingdemo.cpp https://github.com/f1nalspace/final_game_tech/blob/master/final_tiletrace.hpp
The last layer was used for entities placed on tile boundaries, such as start-positions, savepoints, enemies, traps, liquid, etc.
If you dont have much experience with programming, i highly recommend using the "TileD" editor which is super easy to use, with a fine and simple file format. Of course if you want, you can always write a editor yourself. Its not that hard and the only thing you need to know how to convert your mouse coordinates inside tile coordinates and vice versa + a sort of camera movement to navigate through your worlds. Of course if you use unity 3d or unreal engine, you should use their built-in tile editor ;)
Now regarding rendering. Start of simple and draw each tile in the slowest possible way - make it functional first. You will see that you can draw thousands of tiles, without doing any kind of optimizations. These days, most graphics card can handle that. The only thing i would recommend to optimize are to only show the tiles visible on the screen and skip the tile which are outside.
The order of drawing is back-to-front, so you draw the background layers first, then the solid layers and then the entities.
Later on you may consider creating a batched sprite render, so you can render all tiles with just a couple of draw calls. Its as simple as a defining a vertex buffer, push vertices on for each tile and then issue a draw call for one tilesheet.
So thats a rough idea how i implemented tile based stuff successfully. If you have more questions, feel free to ask.
