Building a Custom Shader

Hi everyone, I am trying to code a shader for use in an underwater script, I have the 'simple water' shader and I want to some how combne it with the transparent/diffuse shader to get a slightly transparent water with wave motion

the simple water script:

     Shader "FX/Water (simple)" {
 Properties {
     _horizonColor ("Horizon color", COLOR)  = ( .172 , .463 , .435 , 0)
     _WaveScale ("Wave scale", Range (0.02,0.15)) = .07
     _ColorControl ("Reflective color (RGB) fresnel (A) ", 2D) = "" { }
     _ColorControlCube ("Reflective color cube (RGB) fresnel (A) ", Cube) = "" { TexGen CubeReflect }
     _BumpMap ("Waves Normalmap ", 2D) = "" { }
     WaveSpeed ("Wave speed (map1 x,y; map2 x,y)", Vector) = (19,9,-16,-7)
     _MainTex ("Fallback texture", 2D) = "" { }
 }
 
 CGINCLUDE
 // -----------------------------------------------------------
 // This section is included in all program sections below
 
 #include "UnityCG.cginc"
 
 uniform float4 _horizonColor;
 
 uniform float4 WaveSpeed;
 uniform float _WaveScale;
 uniform float4 _WaveOffset;
 
 struct appdata {
     float4 vertex : POSITION;
     float3 normal : NORMAL;
 };
 
 struct v2f {
     float4 pos : SV_POSITION;
     float2 bumpuv[2] : TEXCOORD0;
     float3 viewDir : TEXCOORD2;
 };
 
 v2f vert(appdata v)
 {
     v2f o;
     float4 s;
 
     o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
 
     // scroll bump waves
     float4 temp;
     temp.xyzw = v.vertex.xzxz * _WaveScale / unity_Scale.w + _WaveOffset;
     o.bumpuv[0] = temp.xy * float2(.4, .45);
     o.bumpuv[1] = temp.wz;
 
     // object space view direction
     o.viewDir.xzy = normalize( ObjSpaceViewDir(v.vertex) );
 
     return o;
 }
 
 ENDCG
     
 // -----------------------------------------------------------
 // Fragment program
 
 Subshader {
     Tags { "RenderType"="Opaque" }
     Pass {
 
 CGPROGRAM
 #pragma vertex vert
 #pragma fragment frag
 #pragma fragmentoption ARB_precision_hint_fastest 
 
 sampler2D _BumpMap;
 sampler2D _ColorControl;
 
 half4 frag( v2f i ) : COLOR
 {
     half3 bump1 = UnpackNormal(tex2D( _BumpMap, i.bumpuv[0] )).rgb;
     half3 bump2 = UnpackNormal(tex2D( _BumpMap, i.bumpuv[1] )).rgb;
     half3 bump = (bump1 + bump2) * 0.5;
     
     half fresnel = dot( i.viewDir, bump );
     half4 water = tex2D( _ColorControl, float2(fresnel,fresnel) );
     
     half4 col;
     col.rgb = lerp( water.rgb, _horizonColor.rgb, water.a );
     col.a = _horizonColor.a;
     return col;
 }
 ENDCG
     }
 }
 
 // -----------------------------------------------------------
 //  Old cards
 
 // three texture, cubemaps
 Subshader {
     Tags { "RenderType"="Opaque" }
     Pass {
         Color (0.5,0.5,0.5,0.5)
         SetTexture [_MainTex] {
             Matrix [_WaveMatrix]
             combine texture * primary
         }
         SetTexture [_MainTex] {
             Matrix [_WaveMatrix2]
             combine texture * primary + previous
         }
         SetTexture [_ColorControlCube] {
             combine texture +- previous, primary
             Matrix [_Reflection]
         }
     }
 }
 
 // dual texture, cubemaps
 Subshader {
     Tags { "RenderType"="Opaque" }
     Pass {
         Color (0.5,0.5,0.5,0.5)
         SetTexture [_MainTex] {
             Matrix [_WaveMatrix]
             combine texture
         }
         SetTexture [_ColorControlCube] {
             combine texture +- previous, primary
             Matrix [_Reflection]
         }
     }
 }
 
 // single texture
 Subshader {
     Tags { "RenderType"="Opaque" }
     Pass {
         Color (0.5,0.5,0.5,0)
         SetTexture [_MainTex] {
             Matrix [_WaveMatrix]
             combine texture, primary
         }
     }
 }
 
 }

the transparent diffuse shader:

     Shader "Transparent/Diffuse" {
 Properties {
     _Color ("Main Color", Color) = (1,1,1,1)
     _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
 }
 
 SubShader {
     Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
     LOD 200
 
 CGPROGRAM
 #pragma surface surf Lambert alpha
 
 sampler2D _MainTex;
 fixed4 _Color;
 
 struct Input {
     float2 uv_MainTex;
 };
 
 void surf (Input IN, inout SurfaceOutput o) {
     fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
     o.Albedo = c.rgb;
     o.Alpha = c.a;
 }
 ENDCG
 }
 
 Fallback "Transparent/VertexLit"
 }

this is the first time I've had a need to build a custom shader and I really have no idea what I'm doing, but I'd be very grateful if someone could give me some tutorials or tips on where to start so I start off in the right direction or if anyone had the time or bother to show me how this is done that would be fanatastic (don't worry I'm not expecting anyone to write me a script :P)

thanks for you time

Scribe