using System.Threading;
using Engine3D;
using Engine3DVP;

public class Sound
{
 [Flags]
 public enum SoundFlags : int 
 {
  SND_SYNC = 0x0000,
  SND_ASYNC = 0x0001,
  SND_NODEFAULT = 0x0002,
  SND_MEMORY = 0x0004,
  SND_LOOP = 0x0008,
  SND_NOSTOP = 0x0010,
  SND_NOWAIT = 0x00002000,
  SND_ALIAS = 0x00010000,
  SND_ALIAS_ID = 0x00110000,
  SND_FILENAME = 0x00020000,
  SND_RESOURCE = 0x00040004
 }

 [DllImport("winmm.dll")]
 public static extern bool PlaySound( string szSound,
 IntPtr hMod, SoundFlags flags );
 [DllImport("winmm.dll")]
 public static extern long mciSendString(string strCommand,
 string strReturn, int iReturnLength, IntPtr hwndCallback);
            
 private bool mLoop;
 private string mSound;
 private string mName;

 private void ThreadPlay()
 {
  mciSendString("open \""+
  this.mSound+"\" type mpegvideo
  alias "+this.mName,null,0,IntPtr.Zero);

  if(this.mLoop)
   mciSendString("play "+
   this.mName+" repeat",null,0,IntPtr.Zero);
  else
   mciSendString("play "+this.mName,null,0,IntPtr.Zero);
 }
 public void PlayMulti( string strFileName, bool loop, string name)
 {
  this.mName = name;
  this.mLoop = loop;
  this.mSound = strFileName;

  Thread mMThread = new Thread(new ThreadStart(ThreadPlay));
  mMThread.Start();
  mMThread.Join();
  this.ThreadPlay();
 }
 public void PlaySingle( string strFileName, bool loop)
 {
  PlaySound(strFileName,IntPtr.Zero, SoundFlags.SND_ASYNC);
 }
}

private Engine3DVP.IEngine3D eng =
   new Engine3D.Engine3D(SCREEN_WIDTH,SCREEN_HEIGHT);

using Engine3DVP;

namespace Engine3D
{
 public class Engine3D: IEngine3D
 {        
  private int SCREEN_HEIGHT;
  private int SCREEN_WIDTH;
  private Point mMouse; //Mouse coordinates from the client app.

  private ArrayList mObjects;

  public Engine3D(int screen_width, int screen_height)
  {
   //…..

  }
  public int Energy(int i)
  {
   return ((IObject3D)this.mObjects[i]).Energy;
  }

  //Will get the degree of object i polygon m
  //in the rotated mesh, this though the Object3D class.

  public double GetDegree(int i, int m)
  {
   return ((IObject3D)this.mObjects[i]).GetDegree(m);
  }
  //Will set the object i polygon m. The degree value.

  public void SetDegree(int i, int m, double degree)
  {
   ((IObject3D)this.mObjects[i]).SetDegree(m,degree);
  }
  //Will create the polygon mesh in this object.

  public void NewPlayer(ref ArrayList mesh, Poinx3D place,
    double rotX, double rotY, int energy)
  {
   IObject3D temp = new Player(place, rotX, rotY, energy);
   temp.SetMeshPoints(ref mesh);
   this.mObjects.Add((IPlayer)temp); //Make it a player.

  }
  public void NewEnemy(ref ArrayList mesh, Poinx3D place,
    double rotX, double rotY, double paseX, double paseY, int energy)
  {
   IObject3D temp = new Enemy(place, rotX, rotY, paseX, paseY, energy);
   temp.SetMeshPoints(ref mesh);
   this.mObjects.Add((IEnemy)temp); //Make it an enemy!
  }
  
  //Some other functions
 
  private void MovePlayer(Player obj)
  {
   if(obj.Energy>0)
  {
  //Calculate the power of the speed.

  obj.PaseX = ((double)this.mMouse.X- ((double)obj.ObjPos.X))/200.00;
  obj.PaseY = ((double)this.mMouse.Y- ((double)obj.ObjPos.Y))/200.00;

  //Speed Limit

  if(obj.CountX>25)
   obj.CountX=25;
  else if(obj.CountX<-25)
   obj.CountX=-25;

  if(obj.CountY>25)
   obj.CountY=25;
  else if(obj.CountY<-25)
   obj.CountY=-25;

  //Counter.

  obj.CountX += obj.PaseX;
  obj.CountY += obj.PaseY;

  //Give new position.

  Poinx3D newpos = new Poinx3D();
  newpos.X = (int)obj.CountX+obj.ObjPos.X;
  newpos.Y = (int)obj.CountY+obj.ObjPos.Y;
  newpos.Z = obj.ObjPos.Z;

  //Screen limit detection.

  TestForScreenLimits(ref newpos);

  //Give the thrust we need.

  obj.ObjPos = newpos;
            
  //And rotate the player.

  obj.SetRotX(obj.PaseY/40.0);
  obj.SetRotY(obj.PaseX/40.0);

  ColDetection(obj);
  }
}

private void TestEnemyPlayer(ref Enemy obj)
{
  for(int i=0;i<this.mobjects.count;i++)
  {
   if(this.mObjects[i] is Player)
   {
    IObject3D pl = (Player)this.mObjects[i];
    double distx = (obj.ObjPos.X-pl.ObjPos.X);
    double disty = (obj.ObjPos.Y-pl.ObjPos.Y);
    double dist = Math.Sqrt(Math.Abs(distx)*Math.Abs(distx)+
     Math.Abs(disty)*Math.Abs(disty));

    //Within range to player!

    if(dist>0 && dist<140 && !obj.InWar && pl.Energy>0)
    {
     //Calculate degrees to target.

     double cc4 = -Math.Cos((Math.Acos(distx/dist)))*10;
     double cr4 = -Math.Sin((Math.Asin(disty/dist)))*10;

     obj.PaseX = cc4;
     obj.PaseY = cr4;
     obj.InWar = true;
    }
    else if(dist>=80 && obj.InWar)
     obj.InWar = false;
   }
  }
}

private void MoveEnemy(Enemy obj)
{
  if(!obj.IsDead)
  {
   TestEnemyPlayer(ref obj);

   Poinx3D temp;
   temp = obj.ObjPos;
   temp.X += (int)(obj.PaseX);
   temp.Y += (int)(obj.PaseY);
   temp.Z = obj.ObjPos.Z;

   //Screen limit detection.

   TestForScreenLimits(ref temp);

   obj.ObjPos = temp;

   ColDetection(obj);
  }
 }

 //Astroids kind of thingy

 private void TestForScreenLimits(ref Poinx3D obj)
 {
  if(obj.X<-50)
   obj.X = SCREEN_WIDTH;
  if(obj.X>SCREEN_WIDTH)
   obj.X = -50;

  if(obj.Y<-50)
   obj.Y = SCREEN_HEIGHT;
  if(obj.Y>SCREEN_HEIGHT)
   obj.Y = -50;
 }

//3D horizontal line

 private void HorizontalLine3D(ref Bitmap bm, ref uint[][] zbuffer,
   Poinx3D p1, Poinx3D p2, Color color, double intencity)
 {
  //Delta lengths

  int dx = (int)(p2.X-p1.X);
  int dz = (int)(p2.Z-p1.Z);
            
  //Direction pointers.

  int step_x = 0;
  int step_z = 0;

  //Moving right step +1 else -1

  if(dx>=0)
   step_x = 1;
  else
  {
   step_x = -1;
   dx = -dx;
  }
  if(dz>=0)
   step_z = 1;
  else
  {
   step_z = -1;
   dz = -dz;
  }
            
  //You need this to make the err_term work.
  //Because we are using integers we must multiply with 2
  //otherwise we would just start with error 0.5

  int dx2 = dx*2; //delta X * 2 instead of 0.5
  int dz2 = dz*2; //delta Z * 2 ..
  int err_termXZ = 0;
        
  //Unified things.

  int uni1D = 0, uni2D2 = 0;
  int inc11 = 0, inc12 = 0, inc2 = 0;
  int step1D2 = 0, step2D = 0;
  int loopTo = 0, direction = 0;

  if(dx>=dz)
  {
   err_termXZ = dz2 - dx;
   direction = 0;
   loopTo = dx;
   uni1D = dx2;
   inc11 = (int)p1.Y;
   step1D2 = step_z;
   inc12 = (int)p1.Z;
   uni2D2 = dz2;
   inc2 = (int)p1.X;
   step2D = step_x;
  }
  else if(dz>dx)
  {
   err_termXZ = dx2 - dz;
   direction = 2;
   loopTo = dz;
   uni1D = dz2;
   inc11 = (int)p1.Y;
   inc12 = (int)p1.X;
   step1D2 = step_x;
   uni2D2 = dx2;
   inc2 = (int)p1.Z;
   step2D = step_z;
  }
            
  //Step x direction by one until the end of width.

  for(int i=0;i<=loopTo;i++)
  {
   Color cl = color;

   if(direction==0&&inc2>0&&inc2<screen_width&&inc11>0&&
   inc11<screen_height)
   {
    if(inc12>zbuffer[inc2][inc11])
    {
     bm.SetPixel(inc2,inc11,cl);
     zbuffer[inc2][inc11] = Convert.ToUInt32(inc12);
    }
   }
   if(direction==2&&inc12>0&&inc12<screen_width&&inc11>0&&
    inc11<screen_height)
   {
    if(inc2>zbuffer[inc12][inc11])
    {
      bm.SetPixel(inc12,inc11,cl);
      zbuffer[inc12][inc11]=Convert.ToUInt32(inc2);
    }
   }

   //Adjust error_term

   //This if it's time to do so.

   if(err_termXZ>=0)
   {
    err_termXZ -= uni1D;
    inc12 += step1D2;
   }
   err_termXZ += uni2D2;

   inc2 += step2D;
  }
 }

public Segment3D Normalize(ref Segment3D normal)
{
  double len = Math.Sqrt(normal.sX*normal.sX+normal.sY*normal.sY+
                         normal.sZ*normal.sZ);
  normal.sX = ((double)normal.sX / len); //casting hell yeah right!

  normal.sY = ((double)normal.sY / len); //casting hell yeah right!
  normal.sZ = ((double)normal.sZ / len); //casting hell yeah right!


  return normal; //Always return even if ref!

}

public Segment3D BuildSegment(Poinx3D start, Poinx3D end, ref Segment3D segm)
{
  segm.sX = end.X-start.X;
  segm.sY = end.Y-start.Y;
  segm.sZ = end.Z-start.Z;

  return segm;
}

public double DotNormalized(Segment3D segm1, Segment3D segm2)
{
  double x = segm1.sX * segm2.sX + segm1.sY * segm2.sY + segm1.sZ * segm2.sZ;
  return x;
}

public Segment3D ExctractNormal(Segment3D segm1, 
       Segment3D segm2, ref Segment3D normal)
{
  normal.sX = ((segm2.sY*segm1.sZ)-(segm2.sZ*segm1.sY));
  normal.sY = ((segm2.sZ*segm1.sX)-(segm2.sX*segm1.sZ));
  normal.sZ = ((segm2.sX*segm1.sY)-(segm2.sY*segm1.sX));

  return normal;
}