/minild29

#include "Dark.h"
#include <cmath>

namespace Dark
{
  Player::Player() : Entity(),
		     FRICTION(150),
		     MAXSPEED(150.0f),
		     ACCELERATION(300)
  {
    sprite = new SpriteAnimation("player.png", FILTER_NONE, 64, 64);
    sprite->Add("idle", 0, 0, 0.35f);
    sprite->Play("idle");
    SetGraphic(sprite);
    scale = Vector2(0.25, 0.25);

    AddTag("player");

    footsteps = Audio::NewDeck(Assets::RequestAudio("footsteps.ogg"));
    footsteps->SetLoops(0); //loop indefinitely
    footsteps->SetVolume(0);
    footsteps->Play();
    
    SetCollider(new RectangleCollider(16, 16));

    dark = new Entity();
    dark->SetGraphic(new Sprite("dark.png", FILTER_NONE, 2048, 1536)); //alpha?
  }

  void Player::Update()
  {
    Entity::Update();

    if (Input::IsKeyMaskHeld("left"))
      {
	velocity.x -= ACCELERATION * Monocle::deltaTime;
      }
    if (Input::IsKeyMaskHeld("right"))
      {
	velocity.x += ACCELERATION * Monocle::deltaTime;
      }
    if (Input::IsKeyMaskHeld("up"))
      {
	velocity.y -= ACCELERATION * Monocle::deltaTime;
      }
    if (Input::IsKeyMaskHeld("down"))
      {
	velocity.y += ACCELERATION * Monocle::deltaTime;
      }
    
    // velocity will approach 0 in steps of FRICTION * dt
    velocity.x = APPROACH(velocity.x, 0, FRICTION * Monocle::deltaTime);
    velocity.y = APPROACH(velocity.y, 0, FRICTION * Monocle::deltaTime);

    if (velocity.GetSquaredMagnitude() > pow(MAXSPEED, 2))
      velocity = velocity.GetNormalized() * MAXSPEED;

    bool xcol = false;
    bool ycol = false;

    if (Collide("exit")) {
      Scene *s = GetScene();
      s->isPaused = true;
      
      Text *win1 = new Text("You made it safely through the dark!", 
			   Assets::RequestFont("LiberationSans-Regular.ttf", 50.0f));
      win1->position = Vector2(-350,0);
      s->Add(win1);

      Text *win2 = new Text("Congratulations!", 
			   Assets::RequestFont("LiberationSans-Regular.ttf", 50.0f));
      win2->position = Vector2(-150,50);
      s->Add(win2);
    }

    Collider *collider = NULL;

    position.x += velocity.x * Monocle::deltaTime;
    while (Collide("Solid") || (collider = Collide("creature")))
      {
	// Don't colide with hunters.  We should just die.
	if (collider) {
	  Creature *c = (Creature *) collider->GetEntity();
	  if (c->state == "hunt") { break; }
	}

	xcol = true;
	if (velocity.x == 0) { break; }
	//printf("collision1\n");
	position.x -= SIGN(velocity.x, 0.1);
      }
    if (xcol) {velocity.x = 0;}

    collider = NULL;
    position.y += velocity.y * Monocle::deltaTime;
    while (Collide("Solid") || (collider = Collide("creature")))
      {
	// Don't colide with hunters.  We should just die.
	if (collider) {
	  Creature *c = (Creature *) collider->GetEntity();
	  if (c->state == "hunt") { break; }
	}

	ycol = true;
	if (velocity.y == 0) { break; }
	//printf("collision2\n");
	position.y -= SIGN(velocity.y, 0.1);
      }
    if (ycol) {velocity.y = 0;}
    
    float magnitude = velocity.GetMagnitude();

    footsteps->SetVolume(magnitude / MAXSPEED);

    // How far away can they hear your footsteps?
    // The circle is diameter 300 at MAXSPEED, 32 (2x your size) at 0 speed
    noisiness = ((magnitude / MAXSPEED *(400-64)) + 64) /2;

    dark->position = position;

    //Scene::GetCamera()->position = position;
  }

  Creature::Creature() : Entity(),
			 FRICTION(800),
			 ACCELERATION(1200),
			 DEFAULT_MAXSPEED(80.0f),
			 STALKSPEED(20.0f)
  {
    sprite = new SpriteAnimation("creature.png", FILTER_NONE, 64, 64);
    sprite->Add("idle", 0, 0, 0.35f);
    sprite->Add("move", 1, 2, 4.0f);
    sprite->Add("slowmove", 1, 2, 2.0f);
    sprite->Play("idle");
    SetGraphic(sprite);
    scale = Vector2(0.25, 0.25);

    AddTag("creature");
    SetCollider(new RectangleCollider(16, 16));

    alert = Assets::RequestAudio("alert.ogg");
    freakout = Assets::RequestAudio("freakout.ogg");
    chomp = Assets::RequestAudio("chomp.ogg");
    skitter1 = Audio::NewDeck(Assets::RequestAudio("skitter1.ogg"));
    skitter1->SetLoops(0); //loop indefinitely
    sniff = Audio::NewDeck(Assets::RequestAudio("sniff.ogg"));
    sniff->SetLoops(0);

    maxspeed = DEFAULT_MAXSPEED;

    //set aiTime to random so creatures tick at different times
    aiTime= (float(rand()) / float(RAND_MAX)) * 1.0f;

    state = "idle";
  }

  void Creature::Update()
  {
    Entity::Update();

    if (state == "idle" || state == "wander") 
      {
	aiTime += Monocle::deltaTime;
	if (aiTime > 1.0f)
	  {
	    switch (rand() % 3)
	      {
	      case 0: // idle
		//printf("idle\n");
		direction = Vector2::zero;
		state = "idle";
		break;
	      case 1: // move
		if (state != "wander") {
		  //printf("wander\n");
		  direction = Vector2::Random();
		  state = "wander";
		  break;
		}
	      }
	    
	    aiTime = 0.0f;
	  }
	
	Player *player = ((DarkScene *)scene)->player;
	if ( (player->position - position).GetSquaredMagnitude() < 
	     pow(player->noisiness, 2) )
	  {
	    //printf("alert\n");
	    state = "alert";
	    alert->Play();
	    direction = Vector2::zero;
	    Ping::NewPing(position, 8.0f, 32.0f, 0.15f); // ping diameter 16-64 over .5s
	    aiTime = 0.0f; // diff variable?  stateTime?
	  }
      } // if idle or wander
    else if (state == "alert")
      {
	aiTime += Monocle::deltaTime;
	
	// if we've been listening past the grace period and hear
	// something, switch state again
	// We hear the player at DOUBLE noisiness distance, cuz WE'RE LISNING!
	Player *player = ((DarkScene *)scene)->player;
	if ( aiTime > 1.0f && 
	     (player->position - position).GetSquaredMagnitude() < 
	     pow(player->noisiness * 2, 2) )
	  {
	    state = "stalk";
	    Ping::NewPing(position, 8.0f, 32.0f, 0.15f);
	    direction = (player->position - position).GetNormalized();
	    maxspeed = STALKSPEED;
	    aiTime = 0.0f;
	  }

	// if we've been listening a long time, switch back to idle
	if (aiTime > 5.0f) {
	  //printf("end alert\n");
	  state = "idle";
	  aiTime = 0.0f;
	}
      }
    else if (state == "stalk")
      {
	aiTime += Monocle::deltaTime;

	// Go to HUNT if:
	// * it's been >1s & we hear the player
	// * we collide with the player
	Player *player = ((DarkScene *)scene)->player;
	if ((aiTime > 1.0f &&  
	     (player->position - position).GetSquaredMagnitude() < 
	     pow(player->noisiness, 2) )
	    || Collide("player")
	    )
	  {
	    state = "hunt";
	    direction = (player->position - position).GetNormalized();
	    maxspeed = 0; // give them a running start
	    sniff->Stop();
	    freakout->Play();
	    Ping::NewPing(position, 8.0f, 64.0f, 0.15f); 
	    aiTime = 0.0f;
	    noiseTime = 0.0f;
	  }

	// Go back to IDLE if:
	// * we hit a wall
	// * we stalk for more than 10-15s
	if ((aiTime > 15.0f) || Collide("wall") || Collide("creaturewall"))
	  {
	    // play frustrated noise?
	    state = "idle";
	    aiTime = 0.0f;
	    sniff->Stop();
	    maxspeed = DEFAULT_MAXSPEED;
	    direction = Vector2::zero;
	  }
      }
    else if (state == "hunt")
      {
	aiTime += Monocle::deltaTime;
	noiseTime += Monocle::deltaTime;
	graceTime += Monocle::deltaTime;

	if ((graceTime > 1.0f) && (maxspeed != DEFAULT_MAXSPEED))
	  maxspeed = DEFAULT_MAXSPEED;

	// if we hear the player (
	Player *player = ((DarkScene *)scene)->player;
	if ( (player->position - position).GetSquaredMagnitude() < 
	     pow(player->noisiness, 2) )
	  {
	    direction = (player->position - position).GetNormalized();
	    aiTime = 0.0f;
	    if (noiseTime > 2.0f) {
	      freakout->Play();
	      Ping::NewPing(position, 8.0f, 64.0f, 0.15f);
	      noiseTime = 0.0f;
	    }
	  }

	// I guess chill out if it's been a while
	if (aiTime > 15.0f) {
	    state = "alert";
	    //alert->Play();
	    direction = Vector2::zero;
	    aiTime = 0.0f;
	    noiseTime = 0.0f;
	    graceTime = 0.0f;
	}

	// if we collide with you, move you back to the starting point
	if (Collide("player")) {
	  // TODO: first wait a second or 3?
	  chomp->Play();
	  DarkScene *scene = (DarkScene *) GetScene();
	  Entity* playersp = scene->GetFirstEntityWithTag("playerspawner");
	  scene->player->position = playersp->position;
	}
      }

    velocity += direction * ACCELERATION * Monocle::deltaTime;
    
    velocity.x = APPROACH(velocity.x, 0, FRICTION * Monocle::deltaTime);
    velocity.y = APPROACH(velocity.y, 0, FRICTION * Monocle::deltaTime);

    if (velocity.GetSquaredMagnitude() > pow(maxspeed, 2))
      velocity = velocity.GetNormalized() * maxspeed;

    bool xcol = false;
    bool ycol = false;

    position.x += velocity.x * Monocle::deltaTime;
    while (Collide("Solid") || Collide("creaturewall"))
      {
	xcol = true;
	if (velocity.x == 0) { break; }
	//printf("collision1\n");
	position.x -= SIGN(velocity.x, 0.1);
      }
    if (xcol) {velocity.x = 0;}

    position.y += velocity.y * Monocle::deltaTime;
    while (Collide("Solid") || Collide("creaturewall"))
      {
	ycol = true;
	if (velocity.y == 0) { break; }
	//printf("collision2\n");
	position.y -= SIGN(velocity.y, 0.1);
      }
    if (ycol) {velocity.y = 0;}

    Vector2 distance = ((DarkScene *)scene)->player->position - position;
    if (state == "stalk")
      {
	float vol = (distance.GetMagnitude() / -250.0f) + 1.0f;
	sniff->SetVolume(vol);
	sniff->Play();
	sprite->Play("slowmove");
      }
    else if (velocity.GetSquaredMagnitude() > 20)
      {
	// at distance 0, vol should be 1.0.  at 800, it should be 0.
	float vol = (distance.GetMagnitude() / -600.0f) + 1.0f;
	skitter1->SetVolume(vol);
	skitter1->Play();
	sprite->Play("move");
      }
    else
      {
	skitter1->Pause(); //Stop()?
	sprite->Play("idle");
      }
  }

  Ping::Ping() : Entity(),
		 d1(0.0f), d2(0.0f), t(0.0f), t2(0.0f)
  {
    sprite = new Sprite("yellow.png", FILTER_LINEAR, 64, 64);
    SetGraphic(sprite);
    scale = Vector2::zero;
  }

  Ping *Ping::NewPing(Vector2 pos, float d1, float d2, float t2)
  {
    Ping *ping = new Ping();
    ping->d1 = d1;
    ping->d2 = d2;
    ping->t2 = t2;
    ping->position = pos;

    Game::GetScene()->Add(ping);
    return ping;
  }

  void Ping::Update()
  {
    Entity::Update();

    // once we're done LERPing, get gone
    if (t > t2)
      RemoveSelf();

    t += Monocle::deltaTime;
    float scaleFactor = LERP(d1/64, d2/64, t/t2);
    scale = Vector2(scaleFactor, scaleFactor);
  }

  // Scene

  DarkScene::DarkScene() : Scene()
  {
  }
  
  void DarkScene::Begin()
  {
    Scene::Begin();

    Graphics::Set2D(1024, 768);

    Text *inst1 = new Text("Use arrow keys to move");
    inst1->position = Vector2(-492, -354);
    Add(inst1);

    Text *inst2 = new Text("Press ESC to quit");
    inst2->position = Vector2(-492, -334); // 20px h, 30px v from U-L corner
    Add(inst2);

    Input::DefineMaskKey("left", KEY_LEFT);
    Input::DefineMaskKey("right", KEY_RIGHT);
    Input::DefineMaskKey("up", KEY_UP);
    Input::DefineMaskKey("down", KEY_DOWN);

    Input::DefineMaskKey("up", KEY_W);
    Input::DefineMaskKey("left", KEY_A);
    Input::DefineMaskKey("down", KEY_S);
    Input::DefineMaskKey("right", KEY_D);

    // level editor
    Add( levelEditor = new LevelEditor() );
    levelEditor->Disable();

    // load level from files
    Level::LoadProject("project.xml");
    Level::Load("level.xml", this);

    HideSpawners();
    Spawn();

    std::list<Entity*> *walls = GetAllTag("wall");
    for (std::list<Entity*>::iterator i = walls->begin(); i != walls->end(); ++i)
      {
        Entity *e = (*i);
        Vector2 s = e->scale;
        e->SetCollider(new RectangleCollider(s.x * 64, s.y * 64));
      }

    std::list<Entity*> *creaturewalls = GetAllTag("creaturewall");
    for (std::list<Entity*>::iterator i = creaturewalls->begin(); i != creaturewalls->end(); ++i)
      {
        Entity *e = (*i);
        Vector2 s = e->scale;
        e->SetCollider(new RectangleCollider(s.x * 64, s.y * 64));
      }

    Entity* exit = GetFirstEntityWithTag("exit");
    Vector2 s = exit->scale;
    exit->SetCollider(new RectangleCollider(s.x * 64, s.y * 64));
 
   
    Graphics::SetBackgroundColor(Color::green * 0.2f);

  }

  void DarkScene::HideSpawners()
  {
    std::list<Entity*> *spawners = GetAllTag("spawner");
    if (spawners == NULL) {printf("NO SPAWNERS!!!\n");}
    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)
      (*i)->isVisible = false;
  }

  void DarkScene::ShowSpawners()
  {
    std::list<Entity*> *spawners = GetAllTag("spawner");
    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)
      (*i)->isVisible = true;
  }
  
  void DarkScene::Spawn()
  {
    Entity* playersp = GetFirstEntityWithTag("playerspawner");
    player = new Player();
    player->position = playersp->position;;
    Add(player);
    Add(player->dark);

    std::list<Entity*> *spawners = GetAllTag("creaturespawner");
    // Ugh, monocle is double-entering all the tags...
    spawners->sort();
    spawners->unique();
    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)
      {
	Creature *creature = new Creature();
	creature->position = (*i)->position;
	Add(creature);
      }
  }

  void DarkScene::Update()
  {
    Scene::Update();

    if (Input::IsKeyPressed(KEY_ESCAPE))
      Game::Quit();

    if (isPaused)
      {
	if (Input::IsKeyPressed(KEY_S) && Input::IsKeyHeld(KEY_LCTRL))
	  Level::Save();

	if (Input::IsKeyPressed(KEY_A))
	  Scene::GetCamera()->position.x -= 600;

	if (Input::IsKeyPressed(KEY_D))
	  Scene::GetCamera()->position.x += 600;
      }

    if (Input::IsKeyPressed(KEY_TAB))
      {
        // if we're not doing anything in the levelEditor...
        if (levelEditor->GetState() == FTES_NONE)
          {
            isPaused = !isPaused;
            
            if (isPaused) {
	      player->dark->isVisible = false;
	      ShowSpawners();
	      levelEditor->Enable();
	    } else {
	      HideSpawners();
	      levelEditor->Disable();
	      player->dark->isVisible = true;
	    }
          }
      }

  }// DarkScene::Update

  Text::Text(const std::string& text, FontAsset* font)
    : Entity(), text(text)
  {
    if (font == NULL)
      this->font = Assets::RequestFont("LiberationSans-Regular.ttf", 18.0f);
    else
      this->font = font;

    SetLayer(-2);
  }

  void Text::Render()
  {
    Graphics::PushMatrix();

    // place text directly relative to camera
    Graphics::Translate(scene->GetCamera()->position + position);

    Graphics::SetBlend(BLEND_ALPHA);
    Graphics::SetColor(Color::white);
    Graphics::BindFont(font);
    
    Graphics::RenderText(*font, text, 0, 0);
    Graphics::PopMatrix();
  }

}