;(

//-------------------------Tree.h-------------------------------------
//
//
//

#ifndef TREE_H
#define TREE_H
#include "GameObject.h"
#include <SFML/Graphics.hpp>
class Tree : public GameObject
{
public:
    Tree();
    void update(const sf::Time&);

    //Setters
    void setHealth(const int);

    //Getters
    sf::Sprite getUpperLeafOne();
    sf::Sprite getUpperLeafTwo();
    sf::Sprite getUpperLeafThree();
    sf::Sprite getUpperLeafFour();
    sf::Sprite getLowerLeafOne();
    sf::Sprite getLowerLeafTwo();
    sf::Sprite getLowerLeafThree();
    sf::Sprite getLowerLeafFour();
    sf::CircleShape getBaseCircle();
    int getHealth();


private:

    //Graphical
    sf::Texture upperLeafTexture_;
    sf::Texture lowerLeafTexture_;
    sf::Sprite upperLeafOne_;
    sf::Sprite upperLeafTwo_;
    sf::Sprite upperLeafThree_;
    sf::Sprite upperLeafFour_;
    sf::Sprite lowerLeafOne_;
    sf::Sprite lowerLeafTwo_;
    sf::Sprite lowerLeafThree_;
    sf::Sprite lowerLeafFour_;
    sf::CircleShape baseCircle_;


    //Item properties
    int health_ = 250;
    int rewardMin_ = 2;
    int rewardMax_ = 4;
    float swayMultiplier_ = 2; //Used to increase sway when being shot
    //Clocks
    sf::Clock swayClock_; //Used for sway animation

};

#endif


//-------------------------Tree.cpp--------------------------------
//
//
//
#include "Tree.h"

Tree::Tree()
{
    //Gets Textures
    upperLeafTexture_.loadFromFile("tree__upper.png");
    lowerLeafTexture_.loadFromFile("tree_lower.png");

    //Assigns textures
    upperLeafOne_.setTexture(upperLeafTexture_);
    upperLeafTwo_.setTexture(upperLeafTexture_);
    upperLeafThree_.setTexture(upperLeafTexture_);
    upperLeafFour_.setTexture(upperLeafTexture_);
    lowerLeafOne_.setTexture(lowerLeafTexture_);
    lowerLeafTwo_.setTexture(lowerLeafTexture_);
    lowerLeafThree_.setTexture(lowerLeafTexture_);
    lowerLeafFour_.setTexture(lowerLeafTexture_);

    //Sets up circle
    baseCircle_.setRadius(10.0f);
    baseCircle_.setFillColor(sf::Color(128,91,42));

    //Origins
    upperLeafOne_.setOrigin(20, 79);
    upperLeafTwo_.setOrigin(20, 79);
    upperLeafThree_.setOrigin(20, 79);
    upperLeafFour_.setOrigin(20, 79);
    lowerLeafOne_.setOrigin(19, 70);
    lowerLeafTwo_.setOrigin(19, 70);
    lowerLeafThree_.setOrigin(19, 70);
    lowerLeafFour_.setOrigin(19, 70);

    //Rotations
    upperLeafOne_.setRotation(30);
    upperLeafTwo_.setRotation(120);
    upperLeafThree_.setRotation(210);
    upperLeafFour_.setRotation(300);
    lowerLeafOne_.setRotation(75);
    lowerLeafTwo_.setRotation(165);
    lowerLeafThree_.setRotation(255);
    lowerLeafFour_.setRotation(345);
}
void Tree::update(const sf::Time& dT)
{
    lowerLeafOne_.setPosition(positionGlobal_);
    lowerLeafTwo_.setPosition(positionGlobal_);
    lowerLeafThree_.setPosition(positionGlobal_);
    lowerLeafFour_.setPosition(positionGlobal_);
    upperLeafOne_.setPosition(positionGlobal_);
    upperLeafTwo_.setPosition(positionGlobal_);
    upperLeafThree_.setPosition(positionGlobal_);
    upperLeafFour_.setPosition(positionGlobal_);
    baseCircle_.setPosition(positionGlobal_);

    lowerLeafOne_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 2.0f) / 25.0f);
    lowerLeafTwo_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 4.0f) / 25.0f);
    lowerLeafThree_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 6.0f) / 25.0f);
    lowerLeafFour_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 8.0f) / 25.0f);
    upperLeafOne_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 10.0f) / 25.0f);
    upperLeafTwo_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 12.0f) / 25.0f);
    upperLeafThree_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 14.0f) / 25.0f);
    upperLeafFour_.rotate(sin(swayClock_.getElapsedTime().asSeconds() + 16.0f) / 25.0f);
}

//Setters
void Tree::setHealth(const int health) {health_ = health;}

//Getters
sf::Sprite Tree::getLowerLeafOne() {return lowerLeafOne_;}
sf::Sprite Tree::getLowerLeafTwo() {return lowerLeafTwo_;}
sf::Sprite Tree::getLowerLeafThree() {return lowerLeafThree_;}
sf::Sprite Tree::getLowerLeafFour() {return lowerLeafFour_;}
sf::Sprite Tree::getUpperLeafOne() {return upperLeafOne_;}
sf::Sprite Tree::getUpperLeafTwo() {return upperLeafTwo_;}
sf::Sprite Tree::getUpperLeafThree() {return upperLeafThree_;}
sf::Sprite Tree::getUpperLeafFour() {return upperLeafFour_;}
sf::CircleShape Tree::getBaseCircle() {return baseCircle_;}
int Tree::getHealth() {return health_;}

//---------------------------In Level.cpp----------------------------
//
//
//
            //Places trees
            if(height > rangeShallowWater && std::rand() % 100 <= 2)
            {
                vTrees_.push_back(Tree());
                vTrees_.at(vTrees_.size() - 1).setPositionGlobal(sf::Vector2f(xPos * 50, yPos * 50));
            }

//...... in the .h
std::vector<Tree> getTrees();

//..... in the .cpp
std::vector<Tree> Level::getTrees() {return vTrees_;}


//-------------------------------------in Engine.cpp draw function---------------------------------
    //Draws trees
    std::vector<Tree> vTrees = level_.getTrees();
    for(auto iTree = vTrees.begin(); iTree != vTrees.end(); ++iTree)
    {
        window_.draw(iTree->getLowerLeafOne());
        window_.draw(iTree->getLowerLeafTwo());
        window_.draw(iTree->getLowerLeafThree());
        window_.draw(iTree->getLowerLeafFour());
        window_.draw(iTree->getUpperLeafOne());
        window_.draw(iTree->getUpperLeafTwo());
        window_.draw(iTree->getUpperLeafThree());
        window_.draw(iTree->getUpperLeafFour());
        window_.draw(iTree->getBaseCircle());
    }