The problem is the land looks flat because of the lack of shading (or pillow shading to use an 'art' term). If you added a simple lighting effect based on the bump map effect it should look a lot better.

Making some simple lighting would be easy - just calculate the dot product between the slope and the sun direction. Remember that unless you want to treat sun as a directional light, you'll need to calculate the direction of the sun at each point. In OL terms, but can be used anywhere: (~ is normalization)

Vec2D lightDir = ~( point - sunPos );
float lightIntensity = -( lightDir * slopeNormal );
if( lightIntensity < 0.0 ) {
  lightIntensity = 0.0;
}

Well, they both look a bit unrealistic...

Well, if you think of the vector as a 1D vector, then yes.

That's the normal of the slope of the hill at the processed point. You could calculate it by finding 3 points around the point and calculating the normal with them.

Okay, I tried to draw out some numbers to see if I could make some sense of them. I'm going wrong in the logic, so feel free to inform me where and/or what I'm doing wrong. (This is the first time I've used any vector math in any thing other than a classroom that was poorly taught [even the teacher was falling asleep as he lectured]).

Okay, let's get some concrete numbers to work with:

                V2
                *
             (100,101,52)

   V1                          V3
   *            *              *                                            *
(99,100,48)  (100,100,50)  (101,100,49)                                 (200,200)

Assume the above dots are nodes in the graph where the parenthesis gives (x,y,z) where z is the height of that node. The (200,200) is the location of the sun. Let's say we are calculating the light at point (100,100,50). You said pick three points to calculate the normal. Should I take the cross product of these three locations? I searched for a quick refresh session on cross and dot products that led to this:

GameDev.net - Vectors and Planes

It says I only need two vectors on a plane to find the normal vector? And if I should take the cross product of three vectors, should I take the cross product on V1 and V2 to find a new Vc to cross product with V3?

Whatever the case, I'll try to step through your procedure anyway.

//from graph above
lightDir = ~(point - sunPos)
         = ~((100,100) - (200,200))
         = ~(-100,-100)
         = (-1,-1)

Assuming the sun is always higher, the lightDir vector would be (-1,-1,-1)

//from graph above
slopeNormal = V1 X V2 X V3
    V1 X V2 = {(100 * 52) - (48 * 101),
               (99 * 52) - (48 * 100),
               (99 * 101) - (100 * 100)}
            = {5200 - 4848, 5148 - 4800, 9999 - 10000}
            = {352, 348, -1}
    V1XV2 X V3 = {(348 * 49) - (-1 * 100),
                  (352 * 49) - (-1 * 101),
                  (352 * 100) - (348 * 101)}
               = {17052 - -100, 17248 - -101, 35200 - 35148}
               = {16952, 17349, 52}
               = slopeNormal

Phew, I know this can't be right, but I'm gonna keep pluggin' numbers...

//Now for the dot product (assuming GameDev's code section of the dot product is correct
lightIntensity = -(lightDir * slopeNormal)
               = -((-1,-1,-1) * (16952,17349,52))
               = -((16952 * -1) + (17349 * -1) + (52 * -1)) 
               = -(-16952 - 17349 - 52)
               = -(34353) = -34353

So might lightIntensity came out to -34353. I plugged these numbers because I wanted to show that I am trying to figure this out without you babying me all the way, but I just haven't done enough of this kind of math to know the logistics of it. It's definitely a lot more complicated than my "the intensity of a pixel is it's height in proportion to the Max_Height * sunlight where sunlight = ((m * distance_from_sun) + b) / 100"

See, I told you, now I've spent too much time on this subject when I could've have been making progress. (although, thanks are in order)

I'm getting the unit vector mixed up with normalization. What exactly does normalization do?

According to the graph above, I can't imagine that to be true, unless there were some higher heights from 101 to 200, but that wouldn't make sense either, considering the formula doesn't look at any of those coordinates.

Another problem I have is this formula doesn't seem to take into affect how bright the light source is. Lastly, if 34353 was the intensity, I can't just multiply that with whatever color the ground is, it was produce some monstrous number, unless, that's what suppose to happen.

Hmmm, okay, if I take the (-100,-100) and normalize it, I get approx. (.71, .71). Would the Z still be -1? Or am I suppose to do the dot product with a 2 dimension vector and 3 dimension vector(which I thought I couldn't do)?

[edit] - typo

[edit] - If I move the sun to (101,101), I will get the same lightDir (as one would expect) and therefore, the exact same lightIntensity as if the sun were at (200,200), that can't be right...

I wouldn't be trying out these numbers if I thought this was all bogus, and I know you know what you are talking about, I'm just trying to get a good grasp of it myself.

No, I never normalized the final value from the cross products, which is indeed a "d'oh" moment, considering the name, slopeNormal. But let me make sure, do I have to take the cross product of three vectors? Does it matter which three vectors I choose? And is there a method for doing the cross product on three vectors at the same time, or do I have to do it like I did above?

That's what I wanted to hear.

Hmmm...something isn't working right. I've spent the past few hours making sure everything is as posted, but without a proper understanding of what's going on, I can't seem to tweak it right.

The Cross Product makes sense to me, but what is the Dot Product producing? Anyways, here's some results of the new code (keep in mind the moon is still trying to shade the right side). The first image is the normal (except for the far left side of the screen, which has already started converting to the other formulas).

The second screen is the result from the code posted below.

http://comp.uark.edu/~spsilve/terrain10a.JPG
http://comp.uark.edu/~spsilve/terrain10b.JPG

Code that is being used:

Any ideas? (And yes, I know that the DotProduct and whatnot functions are already written somewhere and there probably was no need to rewrite them. Oh well).

[EDIT - Food for thought]
From the pictures, the light looks inverted (lighted where it should be shaded and heavily shaded where it should be light). This means the x,y of the hill are going the opposite way of the light source x,y. Look below:

                X    Y     Z
slopeNormal     +    +     -
lightDir        -    -     -
DotProduct      -    -     +

Since the light_int takes the negative of the DotProduct, if the DotProduct comes out to positive, then it will be negative, which will be less than 0, therefore, equalling 0. Thus, somehow, slopeNormal.z * lightDir.z > (slopeNormal.x * lightDir.x) + (slopeNormal.y * lightDir.y).

I tried, but it wasn't much better. Imagine taking a negative of that picture above.

I think it has something to do with the points that I'm picking for figuring the slopeNormal. I tried several different values that led to several different results.

The scope of the world is basically 640 X 480 X 30000.