Alltaken, your additions look great! (and it makes my puny little house look like a small shed

) There are some issues given your ideas on reflections. Another issue will be shadows, but I'll get to that later.
Defintions
- Vector Is a mathematical construct which indicates a certain direction in space. An objects speed can be indicated by a vector showing the relative velocities in x, y and z.
- Normal The normal of a point on a surface is a vector which points completely away from the surface. For example, the normal of the xy-plane points upwards along the z-axis.
The problem with making a colourcode for each normal of a surface with
reflection is that it does not take in account the height or depth (depending on how you look at it). Lets place a simple cube on one of the tiles.
To make matters easier to talk about, let the x-axis of this cube be the ne-sw direction and the y-axis the ne-se direction. The z-axis is just the normal-vector of the ground. Point (0, 0, 0) is thus the bottom-northern corner of the cube.
Now, in our projection of this cube the point on the 'sprite' plane we draw for (0, 0, 0) could also be the point we would draw for (1, 1, 1). There is nothing that would tell us something about the depth of this specific point. Lets now consider the plane given by the points (0,1,0), (0,1,1), (1,1,0), (1,1,1). This is the eastern plane of the cube, standing upwards. According to the specification you gave, this plane should get a colourcode to signify that the normal of the plane is in the direction of the y-axis. Now, if we want to draw the pixel for point (1, 1, 1) (which is on this plane) we need to consider points of the neighboring tile. However, at what height? There is nothing that tells us wether we should draw the bottom part or the top part. Points (1, 1, 1) and (0, 0, 0) were not discernable, remember?
As a possible solution one could use a set of discrete values, say, from 0-255 to indicate the height of each pixel in the beforementioned plane. With this height, we can deduce that the pixel we draw for (1, 1, 1) is indeed (1, 1, 1). With the colourcode we can deduce that the normal of this pixel is towards the y-axis and thus we can draw a perfect reflection.
This however poses two other problems: first of all, it won't allow to make reflections higher than 255 (unless we use more bits for the height, which is not advicable). The solution to this problem is easy. We know that the depth of each pixel cannot be more than 32 (unless we allow overhangs). Thus, we do not encode height, but encode the depth and from there calculate the (x, y, z) values.
If this is all giberish for you: imagine a simple skyscraper with all glass windows. The designer had the urge to place all the windows in a sort of checker-like pattern. The 'black' windows being deeper into the building than the 'white' ones. Now, it is easy to see that the image of the projection will also be distorted.
Another big problem is speed: all the tiles now make each other 'dirty' when something happens to them. For example, when a bus drives before a building with reflections. Everytime the bus moves, the building (or part thereof) needs to be redrawn. Experience should show how well this can be tackled.
Now the problem of
shadows. In essence, shadows can only be drawn on simple surfaces on the xy-plane. When we get curves, stuff will mess up. Also, there should be a seperate shadow layer in the drawing routines to handle this stuff. It would more or less go like:
1. Draw ground tiles, water tiles, roads, railroads and building foundations
2. Draw shadows of buildings and moving objects on ground tiles.
3. Draw reflections of buildings and moving objects on water tiles
4. Draw buildings and moving objects
5. Draw reflections of tiles, shadows, buildings and objects on buildings and objects.
However, it would look very strange when a moving object passes a shadow. We could colourize the moving object down when it passes a shadow, but projecting a real shadow is impossible (or nearly impossible).
All of this should be thought of very hard. If any of you know a game-developer, ask him what he or she thinks. It's hard but not impossible what we want to do.
Ok, enough for now, need to go to work
