Still a no-go. Here is the code with all of the corrections. Do I have the lighting code that I got from the wiki placed in the proper area? I am racking my brain, but i just dont seem to be getting anywhere.

Code:

---

 
float4x4 matWorldViewProj: register(c0);	
float4x4 matView: register(c4);
float4x4 matWorld;

float4 vecSkill41;
float4 vecSunDir;
float4 vecSunDiffuse = float4(200.f/255.f, 200.f/255.f, 200.f/255.f, 1.f);
float4 vecLightPos[8];
float4 vecLightColor[8];
float3 vecFalloff = float3(0.f, 0.f, 2.f);
float4 vecFog;

texture entSkin1; 
texture entSkin2;

sampler ColorMapSampler = sampler_state
{
   Texture = <entSkin1>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;   
   AddressU  = wrap;  
   AddressV  = wrap;
};


sampler BumpMapSampler = sampler_state
{
   Texture = <entSkin2>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;   
   AddressU  = wrap;
   AddressV  = wrap;
};


/////////////////////////LIGHTING FROM WIKI//////////////


 float4 DoPointLight(float3 P, float3 N, int i)
        {
// calculate the light ray pointing from the light to the surface
                float3 D = (float3)vecLightPos[i]-P;
// calculate the angle between surface and light ray
                float NdotL = dot(N,normalize(D));
// modulate the light by the surface angle
                float4 Color = vecLightColor[i] * NdotL;

// calculate the light attenuation factor, DX uses a really strange formula here
                float fac = 0.f;
                if (NdotL >= 0.f && vecLightPos[i].w > 0.f)
                {
// get the distance factor
                        float LD = length(D)/vecLightPos[i].w;
#ifdef DXLIGHTING
                        if (LD < 1.3f)
                                fac = 1.f/(vecFalloff.x + vecFalloff.y*LD + vecFalloff.z*LD*LD);
#else  // linear Lighting
                        if (LD < 1.f)
                                fac = 1.f - LD;
#endif
                }
                return Color * fac;
        }

float4 DoSunLight(float3 N)
        {
// modulate the sunlight by the surface angle
                return vecSunDiffuse * dot(N,-vecSunDir);
        }
float DoFog(float3 Pos)
        {
// convert the vector position to view space to get it's depth (.z)
                float3 P = mul(Pos,matWorldViewProj);
// apply the linear fog formula
                return saturate((vecFog.y-P.z) * vecFog.z);
        }
///////////////////////////////////


struct VS_OUTPUT {
   float4 Pos: POSITION;
   float2 texCoord: TEXCOORD0;
   float3 lightvec: TEXCOORD1;

   float4 Color: COLOR0;
   float  Fog: FOG;  
    
};


VS_OUTPUT VS1(float4 inPos: POSITION, float3 normal: normal, float3 tangent: TANGENT, float2 texCoord : TEXCOORD0) {
   VS_OUTPUT Out;

   //Out.Pos = mul(view_proj_matrix, Pos);
   Out.Pos = mul(inPos, matWorldViewProj);

// transform the normal and the position
                float3 N = normalize(mul(normal,matWorld));
                float3 P = mul(inPos,matWorld);
// Add ambient and sun light
                Out.Color = vecSkill41.w + DoSunLight(N);
// Add 6 dynamic lights (maximum for vs 1.1)
                for (int i=0; i<6; i++)
                        Out.Color += DoPointLight(P,N,i);
// Add fog
                Out.Fog = DoFog(inPos);

// convert texture coordinates or do other stuff

   // Some object-linear texgen, specific for this particular model
   Out.texCoord.x = inPos.x * 0.0065 + 0.46;
   Out.texCoord.y = inPos.z * 0.0065 + 0.46;
Out.texCoord = texCoord;
   

   
   float3 Pview = -mul(matView, inPos);

   // Move our tangent-space into eye-space
   
float3 vtang   = mul(matView, tangent);
float3 vbinorm = mul(matView, cross(tangent, normal));
float3 vnorm   = mul(matView, normal);


   // We use lightVec = viewVec, that is, the camera is also the light.
   float3 lightvec = Pview;         

   // Transform light vector from eye-space to tangent-soace
   Out.lightvec.x = dot(lightvec, vtang);
   Out.lightvec.y = dot(lightvec, vbinorm);
   Out.lightvec.z = dot(lightvec, vnorm);

   return Out;
}

/////////////////////Pixel Shader


float4 Gold: register(c0);
sampler ColorMap: register(s0);
sampler BumpMap: register(s1);

float4 PS1(float2 texCoord: TEXCOORD0, float3 lightvec: TEXCOORD1) : COLOR {
   float4 base = tex2D(ColorMapSampler, texCoord);
   float3 bump = tex2D(BumpMapSampler, texCoord) * 2.0 - 1.0;


   // shine = diffuse and specular
   float shine = saturate(dot(normalize(lightvec), normalize(bump)));
   return (shine * 0.2) * base + pow(shine, 64) * Gold;

}


technique Gold_shine
{
 pass p0
 {
  VertexShader = compile vs_2_0 VS1();
  PixelShader = compile ps_2_0 PS1();
 }
}  

---