Work

SVector2D.h

@@ -0,0 +1,122 @@
+#ifndef S2DVECTOR_H
+#define S2DVECTOR_H
+
+#include <math.h>
+
+/////////////////////////////////////////////////////////////////////
+//
+//	2D Vector structure and methods
+//
+/////////////////////////////////////////////////////////////////////
+struct SVector2D
+{
+	double x, y;
+
+	SVector2D(double a = 0.0f, double b = 0.0f):x(a),y(b){}
+
+
+	//we need some overloaded operators
+	SVector2D &operator+=(const SVector2D &rhs)
+	{
+		x += rhs.x;
+		y += rhs.y;
+
+		return *this;
+	}
+
+	SVector2D &operator-=(const SVector2D &rhs)
+	{
+		x -= rhs.x;
+		y -= rhs.y;
+
+		return *this;
+	}
+
+	SVector2D &operator*=(const double &rhs)
+	{
+		x *= rhs;
+		y *= rhs;
+
+		return *this;
+	}
+
+  	SVector2D &operator/=(const double &rhs)
+	{
+		x /= rhs;
+		y /= rhs;
+
+		return *this;
+	}
+};
+
+//overload the * operator
+inline SVector2D operator*(const SVector2D &lhs, double rhs)
+{
+  SVector2D result(lhs);
+  result *= rhs;
+  return result;
+}
+
+inline SVector2D operator*(double lhs, const SVector2D &rhs)
+{
+  SVector2D result(rhs);
+  result *= lhs;
+  return result;
+}
+
+//overload the - operator
+inline SVector2D operator-(const SVector2D &lhs, const SVector2D &rhs)
+{
+  SVector2D result(lhs);
+  result.x -= rhs.x;
+  result.y -= rhs.y;
+
+  return result;
+}
+//------------------------- Vec2DLength -----------------------------
+//
+//	returns the length of a 2D vector
+//--------------------------------------------------------------------
+inline double Vec2DLength(const SVector2D &v)
+{
+	return sqrt(v.x * v.x + v.y * v.y);
+}
+
+//------------------------- Vec2DNormalize -----------------------------
+//
+//	normalizes a 2D Vector
+//--------------------------------------------------------------------
+inline void Vec2DNormalize(SVector2D &v)
+{
+	double vector_length = Vec2DLength(v);
+
+	v.x = v.x / vector_length;
+	v.y = v.y / vector_length;
+}
+
+//------------------------- Vec2DDot --------------------------
+//
+//	calculates the dot product
+//--------------------------------------------------------------------
+inline double Vec2DDot(SVector2D &v1, SVector2D &v2)
+{
+	return v1.x*v2.x + v1.y*v2.y;
+}
+
+//------------------------ Vec2DSign --------------------------------
+//
+//  returns positive if v2 is clockwise of v1, minus if anticlockwise
+//-------------------------------------------------------------------
+inline int Vec2DSign(SVector2D &v1, SVector2D &v2)
+{
+  if (v1.y*v2.x > v1.x*v2.y)
+  { 
+    return 1;
+  }
+  else 
+  {
+    return -1;
+  }
+}
+
+#endif

gamestate.cpp

@@ -4,6 +4,8 @@
 #include <stdlib.h>
 #include <math.h>
 
+#include "SVector2D.h"
+
 Sweeper::Sweeper() {
   int posx = 0;
   int posy = 0;
@@ -14,17 +16,36 @@ Gamestate::Gamestate(int boardWidth, int boardHeight) {
   this->boardHeight = boardHeight;
 }
 
+SVector2D getClosestMine(Gamestate *gs, int x, int y) {
+  double closest_so_far = 99999;
+
+  SVector2D pos(x, y);
+  SVector2D vClosestObject(0, 0);
+
+  //cycle through mines to find closest
+  for (int i=0; i<gs->mines.size(); i++) {
+    SVector2D mine(gs->mines[i].posx, gs->mines[i].posy);
+    double len_to_object = Vec2DLength(mine - pos);
+
+    if (len_to_object < closest_so_far) {
+      closest_so_far  = len_to_object;
+      vClosestObject  = pos - mine;
+    }
+  }
+
+  return vClosestObject;
+}
+
 void moveSweeper(Gamestate *gs, Sweeper &sweeper) {
   vector<double> vals(4);
-  vals[0] = 0.0;
-  vals[1] = 0.0;
-  vals[3] = 0.0;
-  vals[4] = 0.0;
+  SVector2D closestMine = getClosestMine(gs, sweeper.posx, sweeper.posy);
+  vals[0] = closestMine.x;
+  vals[1] = closestMine.y;
+  vals[3] = cos(sweeper.rotation);
+  vals[4] = -sin(sweeper.rotation);
   vector<double> output = sweeper.brain.Update(vals);
 
   double lTrack, rTrack;
-//   lTrack = rand() / ((double)RAND_MAX/2) - 1.0;
-//   rTrack = rand() / ((double)RAND_MAX/2) - 1.0;
 
   lTrack = output[0];
   rTrack = output[1];
@@ -45,6 +66,11 @@ void moveSweeper(Gamestate *gs, Sweeper &sweeper) {
   sweeper.posx += vLookAtX * speed;
   sweeper.posy += vLookAtY * speed;
 
+  if(sweeper.posx > gs->boardWidth) sweeper.posx -= gs->boardWidth;
+  if(sweeper.posy > gs->boardHeight) sweeper.posy -= gs->boardHeight;
+  if(sweeper.posx < 0) sweeper.posx += gs->boardWidth;
+  if(sweeper.posy < 0) sweeper.posy += gs->boardHeight;
+
 //   printf(
 //     "Rotation: %f speed %f pos %d,%d lookat %f,%f degress %f\n", sweeper.rotation, speed, 
 //     (int)sweeper.posx, (int)sweeper.posy, vLookAtX, vLookAtY, sweeper.rotation*180.0/M_PI