/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;

    position.x += velocity.x * Monocle::deltaTime;

    while (Collide("Solid"))

      {

	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"))

      {

	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 *(300-32)) + 32) /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));

    skitter1 = Audio::NewDeck(Assets::RequestAudio("skitter1.ogg"));

    skitter1->SetLoops(0); //loop indefinitely

    alert = Assets::RequestAudio("alert.ogg");

    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;

	    noiseTime = 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;

	noiseTime += 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 = DEFAULT_MAXSPEED;

	    // Play hunt noise (REEET!)

	  }

	//after 6 or 7 seconds on the noiseTime clock, play sound and ping again

	// if we hit a wall, call off the search?

	//we'll want to play that sound again

	// do others go ALERT if we start stalking?

	//probably a timeout here too.

      }

    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"))

      {

	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"))

      {

	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 *inst2 = new Text("Press ESC to quit");

    inst2->position = Vector2(-492, -354); // 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));

      }

    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();

  }

}