ActWorld/MapPresent/MapPresent.cpp

#include "MapPresent.h"
#include "UnitDelegate.h"
#include <QVector2D>
#include <cmath>
#include <QVector3D>
#include <QEvent>
#include <QPainter>
#include <QMouseEvent>


class OptionGroup {
private:
	PresentOption _bind_opt;
	std::shared_ptr<OptionGroup> _next_group;

public:
	OptionGroup(const PresentOption& opt, std::shared_ptr<OptionGroup> next = nullptr)
		:_bind_opt(opt), _next_group(next) {
	}

	std::shared_ptr<OptionGroup> nextGet() const {
		return _next_group;
	}
	const PresentOption& optionGet() const {
		return _bind_opt;
	}
};



MapPresent::MapPresent(QWidget* parent /*= nullptr*/)
	:QWidget(parent)
{
	_center_index.row = 0;
	_center_index.col = 0;

	auto delegate = new BasicUnitDelegate(this);
	_present_delegate[delegate->unitType()] = delegate;
	connect(this, &MapPresent::mouseOut, delegate, &BasicUnitDelegate::hotClear);
	connect(this, &MapPresent::mouseHover, delegate, &BasicUnitDelegate::hotIndexSet);
	connect(delegate, &BasicUnitDelegate::updateRequest, [=]() { this->update(); });

	this->setMouseTracking(true);
}

PresentIndex MapPresent::indexGet(const QPointF& pos) const
{
	QList<PresentOption> templist;
	for (auto unit_g : _visible_unit_groups) {
		while (unit_g) {
			auto unit = unit_g->optionGet();

			if (unit.outline.contains(pos)) {
				templist << unit;
			}

			unit_g = unit_g->nextGet();
		}
	}

	while (templist.size() > 1) {
		auto opta = templist[0];
		auto optb = templist[1];
		auto dista = QVector3D(opta.outline.center()).distanceToPoint(QVector3D(pos));
		auto distb = QVector3D(optb.outline.center()).distanceToPoint(QVector3D(pos));
		if (dista < distb) {
			templist.removeAt(1);
		}
		else {
			templist.removeAt(0);
		}
	}

	if (templist.size())
		return templist[0].index;

	return PresentIndex();
}

QRectF MapPresent::outlineGet(const PresentIndex& idx) const
{
	auto widget_rect = this->rect();
	auto widget_center = widget_rect.center();

	const float ap_len = _primitive_region_len / 2;
	auto a2_vec = ap_len * sqrt(3) / 2;
	auto n_yinc = QVector3D(a2_vec, ap_len * 3 / 2, 0);
	auto n_xinc = QVector3D(a2_vec, -ap_len * 3 / 2, 0);

	auto xinc = idx.row - _center_index.row;
	auto yinc = idx.col - _center_index.col;
	auto target_center = QVector3D(widget_center) + n_yinc * yinc + n_xinc * xinc;
	target_center -= QVector3D(ap_len, ap_len, 0);

	return QRectF(target_center.toPointF(), QSizeF(ap_len * 2, ap_len * 2));
}

#include <QElapsedTimer>
#include <QtDebug>
void MapPresent::paintEvent(QPaintEvent* ev)
{
	QWidget::paintEvent(ev);
	UnitPresentDelegate& t = *_present_delegate[0];

	QPainter p(this);
	for (auto opt_g : _visible_unit_groups) {
		while (opt_g) {
			p.save();

			auto opt = opt_g->optionGet();
			auto rect = opt.outline;
			p.translate(rect.topLeft());
			rect.moveTo(0, 0);

			auto clip_path = BasicUnitDelegate::clipPathGet(rect);
			p.setClipPath(clip_path);

			opt.outline = rect;
			t.paint(&p, opt);

			p.restore();

			opt_g = opt_g->nextGet();
		}
	}
}

void MapPresent::resizeEvent(QResizeEvent* event)
{
	QWidget::resizeEvent(event);

	visible_units_tidy();
}

void MapPresent::mouseMoveEvent(QMouseEvent* event)
{
	QWidget::mouseMoveEvent(event);
	event->accept();

	auto index = indexGet(event->pos());
	emit mouseHover(index);
}

void MapPresent::enterEvent(QEvent* event)
{
	QWidget::enterEvent(event);
	event->accept();

	emit mouseIn();
}

void MapPresent::leaveEvent(QEvent* event)
{
	QWidget::leaveEvent(event);
	event->accept();

	emit mouseOut();
}

PresentOption AssumeOpt(PresentIndex index, QRectF rf) {
	PresentOption opt;
	opt.index = index;
	opt.outline = rf;
	return opt;
}

void MapPresent::visible_units_tidy() {
	_visible_unit_groups.clear();

	QRectF curr_outline = this->rect();
	_visible_unit_groups << std::make_shared<OptionGroup>(
		AssumeOpt(_center_index, outlineGet(_center_index))
	);

	int visible_count = 1, deduce_x = 1;
	while (visible_count) {
		visible_count = 0;

		std::shared_ptr<OptionGroup> prev_g = nullptr;
		auto siblings = siblingsGet(_center_index, deduce_x++);
		for (auto unit : siblings) {
			auto visible_rect = outlineGet(unit);
			if (curr_outline.intersects(visible_rect)) {
				prev_g = std::make_shared<OptionGroup>(AssumeOpt(unit, visible_rect), prev_g);
				visible_count++;
			}
		}

		if (prev_g) {
			_visible_unit_groups << prev_g;
		}
	}

	// TODO <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD>֯<EFBFBD>ṹ
}

QList<PresentIndex> MapPresent::siblingsGet(const PresentIndex& center, uint16_t dist) const
{
	QList<PresentIndex> e6_points;
	e6_points << PresentIndex{ center.row, center.col - dist };
	e6_points << PresentIndex{ center.row + dist, center.col };
	e6_points << PresentIndex{ center.row + dist, center.col + dist };
	e6_points << PresentIndex{ center.row, center.col + dist };
	e6_points << PresentIndex{ center.row - dist, center.col };
	e6_points << PresentIndex{ center.row - dist, center.col - dist };
	e6_points << PresentIndex{ center.row, center.col - dist };

	QList<PresentIndex> values;
	for (auto idx = 0; idx < 6; ++idx) {
		auto ap = e6_points[idx];
		auto bp = e6_points[idx + 1];
		values << item_supply(ap, bp);
	}
	return values;
}

QList<PresentIndex> MapPresent::item_supply(const PresentIndex& a, const PresentIndex& b) const
{
	QList<PresentIndex> items;
	auto sign_row = (a.row == b.row) ? 0 : ((b.row - a.row) / std::abs(a.row - b.row));
	auto sign_col = (a.col == b.col) ? 0 : ((b.col - a.col) / std::abs(a.col - b.col));

	auto temp_pt = a;
	while (temp_pt != b) {
		items << temp_pt;
		temp_pt += PresentIndex{ sign_row, sign_col };
	}

	return items;
}

PresentIndex& PresentIndex::operator+=(const PresentIndex& other)
{
	row += other.row;
	col += other.col;
	return *this;
}

bool PresentIndex::operator!=(const PresentIndex& other) const
{
	return row != other.row || col != other.col;
}

bool PresentIndex::isValid() const
{
	return row != INT_MAX && col != INT_MAX;
}

bool PresentIndex::operator==(const PresentIndex& other) const
{
	return row == other.row && col == other.col;
}

UnitPresentDelegate::UnitPresentDelegate(QObject* parent /*= nullptr*/)
	:QObject(parent) {
}

PresentOption& PresentOption::operator=(const PresentOption& other)
{
	index = other.index;
	outline = other.outline;
	return *this;
}