game-client/source/Cell.cpp

#include "Cell.h"
#include <assert.h>
#include <string>
#include <string.h>
//#include "unit.h"
#include <queue>
#include <vector>
#include <map>
#include <iostream>

class Unit{
private:
public:
    bool CanMoveForDistance(int distance){
        return true;
    }
    bool CanAttackForDistance(std::string AttackType, int distance){
        return true;
    }
};

class EffectsForCell{
public:
	void OperateOnCell(Cell*){}
};

Cell::Cell(Unit* character) {
	leftUp_ = left_ = leftDown_ = nullptr;
	rightUp_ = right_ = rightDown_ = nullptr;
	character_ = character;
	clearCell_();
	AddedToQuery_ = true;
	col_ = row_ = 0;
}

Cell * Cell::getleftUp() {
	return leftUp_;
}
void Cell::setleftUp(Cell * t) {
	leftUp_ = t;
}
Cell * Cell::getleft() {
	return left_;
}
void Cell::setleft(Cell * t) {
	left_ = t;
}
Cell * Cell::getleftDown() {
	return leftDown_;
}
void Cell::setleftDown(Cell * t) {
	leftDown_ = t;
}
Cell * Cell::getrightUp() {
	return rightUp_;
}
void Cell::setrightUp(Cell * t) {
	rightUp_ = t;
}
Cell * Cell::getright() {
	return right_;
}
void Cell::setright(Cell * t) {
	right_ = t;
}
Cell * Cell::getrightDown() {
	return rightDown_;
}
void Cell::setrightDown(Cell * t) {
	rightDown_ = t;
}
Unit * Cell::getCharacter() {
	return character_;
}
void Cell::setCharacter(Unit * t) {
	character_ = t;
}

int Cell::getdistance_barrier(){
    return distance_barrier_;
}
void Cell::setdistance_barrier(int distance_barrier){
    distance_barrier_ = distance_barrier;
}
int Cell::getdistance_through(){
    return distance_through_;
}
void Cell::setdistance_through(int distance_through){
    distance_through_ = distance_through;
}

bool Cell::getisMoveAble(){
    return isMoveAble_;
}
void Cell::setisMoveAble(bool isMoveAble){
    isMoveAble_ = isMoveAble;
}
bool Cell::getisMeleeAttackAble(){
    return isMeleeAttackAble_;
}
void Cell::setisMeleeAttackAble(bool isMeleeAttackAble){
    isMeleeAttackAble_ = isMeleeAttackAble;
}
bool Cell::getisRangeAttackAble(){
    return isRangeAttackAble_;
}
void Cell::setisRangeAttackAble(bool isRangeAttackAble){
    isRangeAttackAble_ = isRangeAttackAble;
}

bool Cell::isEmpty() {
	return character_ == nullptr;
}

void Cell::recalculateAllEffectsList(){
    for(std::vector<EffectsForCell*>::iterator it = beginIteratorEffectsList();
            it != endIteratorEffectsList();++it){
        (*it)->OperateOnCell(this);
    }
}
void Cell::add(EffectsForCell* effect){
    if(effect == nullptr)
        throw new int(228);
    effects_list_.push_back(effect);
}
void Cell::remove(std::vector<EffectsForCell*>::iterator it){
    if(beginIteratorEffectsList() <= it && it < endIteratorEffectsList()){
        effects_list_.erase(it);
    }
}
void Cell::remove(EffectsForCell* effect){
    for(std::vector<EffectsForCell*>::iterator it = beginIteratorEffectsList();
            it != endIteratorEffectsList();++it){
        if((*it) == effect){
            remove(it);
            return;
        }
    }
}
std::vector<EffectsForCell*>::iterator Cell::beginIteratorEffectsList(){
    return effects_list_.begin();
}
std::vector<EffectsForCell*>::iterator Cell::endIteratorEffectsList(){
    return effects_list_.end();
}

void Cell::RecalculateTableWithCenterThisPoint() {
    clearTable_();
    std::queue<Cell*> qWithUnMoveable;
    updateMoveableCells_(qWithUnMoveable);
    updateUnMovealeCells_(qWithUnMoveable);
}
std::vector <Cell*> Cell::actualPath(Cell* to) {
    if (!to || !to->getisMoveAble())return std::vector<Cell*>();
    auto ret = std::vector<Cell*>(1, to);
    while (to != this) {
        Cell * parent = nullptr;
        auto f = [&parent](Cell * TestParent, Cell * Now) {
            if (TestParent && TestParent->getdistance_barrier() + 1 == Now->getdistance_barrier()
                && TestParent->getisMoveAble()) {
                parent = TestParent;
            }
        };
        assert(parent != nullptr);
        f(to->getleftUp(), to);
        f(to->getleft(), to);
        f(to->getleftDown(), to);
        f(to->getrightUp(), to);
        f(to->getright(), to);
        f(to->getrightDown(), to);
        to = parent;
        ret.push_back(to);
    }
    return ret;
}

void Cell::clearCell_() {
    setdistance_barrier(-1);
    setdistance_through(-1);
    setisMeleeAttackAble(false);
    setisMoveAble(false);
    setisRangeAttackAble(false);
}

void Cell::clearTable_() {
	std::queue<Cell*> q;
	q.push(this);
	clearCell_();
	setdistance_through(0);
	this->AddedToQuery_ = false;
	auto f = [&q](Cell * t, Cell * parent, int delta_col, int delta_row) {
		if (t && t->AddedToQuery_ == true) {
			q.push(t);
			t->col_ = parent->col_ + delta_col;
			t->row_ = parent->row_ + delta_row;
			t->setdistance_through(
			        parent->getdistance_through() + 1
            );
			t->AddedToQuery_ = false;
		}
	};
	while (!q.empty()) {
		Cell * Now = q.front();
		q.pop();
		Now->clearCell_();
		f(Now->getleftUp(), Now, -1, 0);
		f(Now->getleft(), Now, 0, -1);
		f(Now->getleftDown(), Now, 1, -1);
		f(Now->getrightUp(), Now, -1, 1);
		f(Now->getright(), Now, 0, 1);
		f(Now->getrightDown(), Now, 1, 0);
	}
}

void Cell::recalcAttackable_(Cell * Now,bool isReached){
    if(Now == nullptr)return;
    if (!isEmpty() && !Now->isEmpty() &&
        getCharacter()->CanAttackForDistance("Melee", Now->getdistance_barrier())
            ) {
        Now->setisMeleeAttackAble(isReached);
    }
    if (!isEmpty() && !Now->isEmpty() &&
        getCharacter()->CanAttackForDistance("Range", Now->getdistance_barrier())
            ) {
        Now->setisRangeAttackAble(true);
    }
}

void Cell::recalcMoveable_(Cell * Now, bool isReached){
    if(Now == nullptr || Now->isEmpty() || isEmpty())return;
    if(!isEmpty() && Now->isEmpty() &&
	   getCharacter()->CanMoveForDistance(Now->getdistance_barrier())){
    	Now->setisMoveAble(isReached);
    }
}

void Cell::updateMoveableCells_(std::queue<Cell*> & Q) {
	std::queue<Cell*> q;
	q.push(this);
	setdistance_barrier(0);
	auto f = [&q, &Q](Cell * t, Cell * parent) {
		if (t && !t->AddedToQuery_) {
			t->AddedToQuery_ = true;
			if (t->getCharacter() != NULL) {
				Q.push(t);
				return;
			}
			q.push(t);
			t->setdistance_barrier(
			        parent->getdistance_barrier() + 1
            );
		}
	};
	while (!q.empty()) {
		Cell * Now = q.front();
		q.pop();
		recalcMoveable_(Now, true);
		recalcAttackable_(Now, true);

		f(Now->getleftUp(), Now);
		f(Now->getleft(), Now);
		f(Now->getleftDown(), Now);
		f(Now->getrightUp(), Now);
		f(Now->getright(), Now);
		f(Now->getrightDown(), Now);
	}
}

void Cell::updateUnMovealeCells_(std::queue<Cell*> & Q) {
	auto f = [&Q](Cell * t, Cell * parent) {
		if (t && !t->AddedToQuery_) {
			t->AddedToQuery_ = true;
			Q.push(t);
		}
	};
	while (!Q.empty()) {
		Cell * Now = Q.front();
		recalcMoveable_(Now, false);
		recalcAttackable_(Now, false);
		Q.pop();
		f(Now->getleftUp(), Now);
		f(Now->getleft(), Now);
		f(Now->getleftDown(), Now);
		f(Now->getrightUp(), Now);
		f(Now->getright(), Now);
		f(Now->getrightDown(), Now);
	}
}

void Cell::print() {
	std::cout << col_ << " " << row_ << std::endl;
}

Cell* Cell::getRealShootTarget(Cell* next){
	if(next == this){
		return next;
	}
	int next_col = next->col_;
	int next_row = next->row_;
	if(next_col - col_ == next_row - row_){
		if(next_col > col_){
			return getrightDown()->getright();
		}
		if(next_col < col_){
			return getleftUp()->getleft();
		}
		throw new std::string("Don`t recalculated");
	}
	if(-2 * (next_col - col_) == (next_row - row_)){
		if(next_col < col_){
			return getrightUp()->getright();
		}
		if(next_col > col_){
			return getleftDown()->getleft();
		}
		throw new std::string("Don`t recalculated");
	}
	if(next_col - col_ == -2 * (next_row - row_)){
		if(next_col < col_){
			return (getleftUp() != nullptr ? getleftUp()->getrightUp() : getrightUp()->getleftUp());
		}
		if(next_col > col_){
			return (getleftDown() != nullptr ? getleftDown()->getrightDown() : getrightDown()->getleftDown());
		}
		throw new std::string("Don`t recalculated");
	}
	return this;



}