#pragma once
#include "Vector2.h"

class CCamera
{
private:
    vector2 mPos;
    vector2 mDest;

    double mFactor1;
    double mFactor2;

public:
    void update(double dt);

    inline vector2 getPos(){return mPos;}
    inline void setPos(vector2 pos);
    inline vector2 getDest(){return mDest;}
    inline void setDest(vector2 dest){mDest = dest;}
    inline void moveDest(vector2 dist){mDest += dist;}

    inline double getFactor1(){return mFactor1;}
    inline double getFactor2(){return mFactor2;}
    inline void setFactor1(double fac){mFactor1 = fac;}
    inline void setFactor2(double fac){mFactor2 = fac;}

    inline const double& operator [] (int id) {return mPos[id];}

    CCamera();
    ~CCamera();
};

#include "Camera.h"

void CCamera::setPos(vector2 pos)
{
    mPos = pos;
    mDest = mPos;
}

void CCamera::update(double dt)
{
    if(mDest == mPos) return;

    double dist = (mDest - mPos).length();
    double speed = dist * mFactor2 + mFactor1;

    double factor = speed * dt / dist;
    if(factor >= 1.0) {
  setPos(mDest);
  return;
    }

    mPos += (mDest - mPos) * factor;
}

CCamera::CCamera()
{
    mPos = vector2(0.0, 0.0);
    mDest = vector2(0.0, 0.0);

    mFactor1 = 0.1;
    mFactor2 = 1.0;
}

CCamera::~CCamera()
{
}

#pragma once
#include <cmath>

struct vector2
{
    double val[2];

    vector2() {val[0] = 0.0; val[1] = 0.0;}
    vector2(const vector2& a) {val[0]=a.val[0];  val[1]=a.val[1];}
    vector2(double x, double y) {val[0]=x;  val[1]=y;}
    
    inline double& operator [] (int id) {return val[id];}

    inline void operator = (const vector2& a)  {val[0] =a.val[0];  val[1] =a.val[1];}
    inline vector2 operator - ()  {vector2 temp; temp.val[0] = -val[0];  temp.val[1] = -val[1];  return temp;}
    inline void operator += (vector2& a) {val[0]+=a.val[0];  val[1]+=a.val[1];}
    inline void operator -= (vector2& a) {val[0]-=a.val[0];  val[1]-=a.val[1];}
    inline void operator *= (vector2& a) {val[0]*=a.val[0];  val[1]*=a.val[1];}
    inline void operator /= (vector2& a) {val[0]/=a.val[0];  val[1]/=a.val[1];}

    inline void operator += (double a) {val[0]+=a;  val[1]+=a;}
    inline void operator -= (double a) {val[0]-=a;  val[1]-=a;}
    inline void operator *= (double a) {val[0]*=a;  val[1]*=a;}
    inline void operator /= (double a) {val[0]/=a;  val[1]/=a;}

    inline vector2 operator + (vector2& a) {vector2 ret(*this);  ret+=a;  return ret;}
    inline vector2 operator - (vector2& a) {vector2 ret(*this);  ret-=a;  return ret;}
    inline vector2 operator * (vector2& a) {vector2 ret(*this);  ret*=a;  return ret;}
    inline vector2 operator / (vector2& a) {vector2 ret(*this);  ret/=a;  return ret;}

    inline vector2 operator + (double a) {vector2 ret(*this);  ret+=a;  return ret;}
    inline vector2 operator - (double a) {vector2 ret(*this);  ret-=a;  return ret;}
    inline vector2 operator * (double a) {vector2 ret(*this);  ret*=a;  return ret;}
    inline vector2 operator / (double a) {vector2 ret(*this);  ret/=a;  return ret;}

    inline bool operator == (vector2& a) {return a.val[0] == val[0] && a.val[1] == val[1];}
    inline bool operator != (vector2& a) {return a.val[0] != val[0] || a.val[1] != val[1];}

    inline void  normalize()
    {
  double d = length();

  if(d == 0.0){
   val[0] = 0.7;
   val[1] = 0.7;
   return;
  }

  val[0] /= d;
  val[1] /= d;
    }

    inline void  oppose()
    {
  val[0] = -val[0];
  val[1] = -val[1];
    }

    inline double lengthSqr() {return val[0]*val[0] + val[1]*val[1];}
    inline double length() {return sqrt(lengthSqr());}

    inline bool  left(vector2& a) {return (val[0]*a.val[1] - val[1]*a.val[0]) < 0;}

    inline void  rotate(double c, double s)
    {
  double x = val[0]*c - val[1]*s;
  double y = val[1]*c + val[0]*s;
  val[0] = x;
  val[1] = y;
    }

    inline void  rotate(double angle)
    {
  angle *= 3.1415926535/180;

  float c = cos(angle);
  float s = sin(angle);
  rotate(c, s);
    }
};

double vecScalar(vector2& a, vector2& b);
double vecCross(vector2& a, vector2& b);