#include <string>

// En fristående representation av en spelare så enkelt som möjligt
// "På riktigt" skulle vi istället låta spearen vara ett spelobjekt i en klasshierarki
struct Player
{
  float x;
  float y;
  float r;
  std::string story;
};

// En liten funktion för att kvadrera ett tal
float sq(float f) { return f*f; }

// Här fyller du på med dina klasser och deras implementation.
// Du får lägga all kod i denna fil om du vill.
// Du får filuppdela i *.h och *.cc om du vill.

class Modifier
{
public:
  Modifier(float x, float y, float r)
    : x{x}, y{y}, r{r}
  {
  }
  virtual ~Modifier() = default;
    
  bool collides(Player const& p) const
  {
    return ( (sq(x-p.x) + sq(y-p.y)) < sq(r+p.r) );
  }
  
  virtual void affect(Player& p) const = 0;
  
private:
  float x;
  float y;
  float r;
};

class StoryMod : public Modifier
{
public:
  StoryMod(float x, float y, float r, std::string event)
    : Modifier{x,y,r}, event{event}
  {
  }
  
  void affect(Player& p) const override
  {
    p.story += event;
  }
  
private:
  std::string event;
};

class SizeMod : public Modifier
{
public:
  SizeMod(float x, float y, float r, float d)
    : Modifier{x,y,r}, delta{d}
  {
  }

  void affect(Player& p) const override
  {
    p.story += ("Size adjusted by " + std::to_string(delta) + "\n");
    p.r += delta;
  }
  
private:
  float delta;
};

// Du behöver göre ett fåtal ändringar i nedan given kod:
// (1) välja datatyp att lagra i vectorn, du behöver ändra i:
//     - parameterdeklarationen i update
//     - deklarationen i huvudprogrammet
//     - hur vektorn fylls med data
// (2) göra klar funktionen update enligt dina klasser
// (3) se till att inget minne läcker (om du allokerar något)

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>

using namespace std;

// Kontrollera om spelaren överlappar med någon mod och utför i så fall den modden
void update(Player& player, vector< Modifier* > const& mod_list)
{
  for (Modifier* mod : mod_list) // För varje modifier i mod_list
  {
    if (mod->collides(player)) // Om modifiern kolliderar med spelaren (t.ex. collides(player) )
    {
      mod->affect(player); // Utför modifierns påverkan på spelaren (t.ex. affect(player) )
    }
  }
}

void move(Player& player, float x, float y)
{
  player.x = x;
  player.y = y;
}

int main()
{
  vector< Modifier* > mod_list
  {
    // Parameterordning: (x, y, radie, ...)    
    new SizeMod{10,10,4, -3}, // 1
    
    new StoryMod{20,14,3, "Bumped chair 2\n"},
    new StoryMod{31,20,3, "Bumped chair 3\n"},
    new StoryMod{31,30,3, "Bumped chair 4\n"},
    new StoryMod{20,36,3, "Bumped chair 5\n"},
    new StoryMod{ 9,30,3, "Bumped chair 6\n"},
    new StoryMod{ 9,20,3, "Bumped chair 7\n"},
    new StoryMod{20,25,7, "Jumps on table\n"}, // 8
    new StoryMod{38,48,1, "Found treasure\n"}, // 9

    new SizeMod{22,26,4, 5}, // :
  };
  
  Player p1{4,4,4,"=== Player One ===\n"};

  // Låt spelaren gå till ett antal olika punkter och se hur den påverkas
  move(p1, 4.0,   4.0);
  update(p1, mod_list);
  cout << p1.story << endl;
  
  move(p1, 12.0, 14.0);
  update(p1, mod_list);
  cout << p1.story << endl;

  move(p1, 14.0, 17.0);
  update(p1, mod_list);
  cout << p1.story << endl;

  move(p1, 20.0, 25.0);
  update(p1, mod_list);
  cout << p1.story << endl;

  move(p1, 27.0, 36.0);
  update(p1, mod_list);
  cout << p1.story << endl;

  move(p1, 35.0, 45.0);
  update(p1, mod_list);
      
  // Skriv ut spelarens "story" efter alla förflyttningarna
  cout << p1.story << endl;

  for (Modifier* m : mod_list )
  {
    delete m;
  }
  
  return 0;
}