mirror of
https://github.com/ApfelTeeSaft/PlanetFleet.git
synced 2026-08-26 19:33:38 +00:00
295 lines
9.7 KiB
C++
Executable File
295 lines
9.7 KiB
C++
Executable File
#include <model.h>
|
|
#include <quad.h>
|
|
#include <material.h>
|
|
#include <texture.h>
|
|
|
|
#include <stateManager.h>
|
|
|
|
#include <glm.hpp>
|
|
#include <ext.hpp>
|
|
|
|
#include "unit.h"
|
|
#include "util.h"
|
|
#include "inGameAppState.h"
|
|
#include "unitData.h"
|
|
|
|
using namespace glm;
|
|
using namespace vb01;
|
|
using namespace std;
|
|
|
|
namespace battleship{
|
|
using namespace unitData;
|
|
|
|
Unit::Unit(Player *player, vb01::Vector3 pos, int id) {
|
|
this->id = id;
|
|
this->player = player;
|
|
this->health = unitData::health[id];
|
|
this->maxTurnAngle = unitData::maxTurnAngle[id];
|
|
this->range = unitData::range[id];
|
|
this->lineOfSight = unitData::lineOfSight[id];
|
|
this->speed = unitData::speed[id];
|
|
type = unitData::unitType[id];
|
|
width = unitData::unitCornerPoints[id][0].x - unitData::unitCornerPoints[id][1].x;
|
|
height = unitData::unitCornerPoints[id][4].y - unitData::unitCornerPoints[id][0].y;
|
|
length = unitData::unitCornerPoints[id][3].z - unitData::unitCornerPoints[id][0].z;
|
|
|
|
GameManager *gm = GameManager::getSingleton();
|
|
model = new Model(basePath[id] + meshPath[id]);
|
|
Root *root = Root::getSingleton();
|
|
string libPath = root->getLibPath();
|
|
|
|
Material *mat = new Material(libPath + "texture");
|
|
string f[]{DEFAULT_TEXTURE};
|
|
Texture *diffuseTexture = new Texture(f, 1, false);
|
|
mat->addBoolUniform("texturingEnabled", true);
|
|
mat->addBoolUniform("lightingEnabled", false);
|
|
mat->addTexUniform("textures[0]", diffuseTexture, true);
|
|
|
|
model->setMaterial(mat);
|
|
root->getRootNode()->attachChild(model);
|
|
placeUnit(pos);
|
|
|
|
selectionSfxBuffer = new sf::SoundBuffer();
|
|
string p = GameManager::getSingleton()->getPath() + "Sounds/" + unitData::name[id] + "s/selection.ogg";
|
|
|
|
if(selectionSfxBuffer->loadFromFile(p.c_str()))
|
|
selectionSfx = new sf::Sound(*selectionSfxBuffer);
|
|
|
|
Node *guiNode = root->getGuiNode();
|
|
|
|
hpBackground = new Quad(Vector3(lenHpBar, 10, 0), false);
|
|
Material *hpBackgroundMat = new Material(libPath + "gui");
|
|
hpBackgroundMat->addBoolUniform("texturingEnabled", false);
|
|
hpBackgroundMat->addVec4Uniform("diffuseColor", Vector4(0, 0, 0, 1));
|
|
hpBackground->setMaterial(hpBackgroundMat);
|
|
hpBackgroundNode = new Node();
|
|
hpBackgroundNode->attachMesh(hpBackground);
|
|
guiNode->attachChild(hpBackgroundNode);
|
|
|
|
hpForeground = new Quad(Vector3(lenHpBar, 10, 0), false);
|
|
Material *hpForegroundMat = new Material(libPath + "gui");
|
|
hpForegroundMat->addBoolUniform("texturingEnabled", false);
|
|
hpForegroundMat->addVec4Uniform("diffuseColor", Vector4(0, 1, 0, 1));
|
|
hpForeground->setMaterial(hpForegroundMat);
|
|
hpForegroundNode = new Node();
|
|
hpForegroundNode->attachMesh(hpForeground);
|
|
guiNode->attachChild(hpForegroundNode);
|
|
}
|
|
|
|
Unit::~Unit() {
|
|
}
|
|
|
|
void Unit::update() {
|
|
leftVec = model->getGlobalAxis(0);
|
|
upVec = model->getGlobalAxis(1);
|
|
dirVec = model->getGlobalAxis(2);
|
|
|
|
if (!orders.empty()){
|
|
LineRenderer *lineRenderer = LineRenderer::getSingleton();
|
|
lineRenderer->toggleVisibility(orders[0].line.id, selected && canDisplayOrderLine());
|
|
lineRenderer->changeLineField(orders[0].line.id, pos, LineRenderer::START);
|
|
}
|
|
|
|
executeOrders();
|
|
|
|
screenPos = spaceToScreen(pos);
|
|
hpBackgroundNode->setVisible(selected);
|
|
hpForegroundNode->setVisible(selected);
|
|
|
|
if (selected) {
|
|
displayUnitStats();
|
|
}
|
|
|
|
if (health <= 0)
|
|
blowUp();
|
|
}
|
|
|
|
void Unit::blowUp(){
|
|
working = false;
|
|
}
|
|
|
|
void Unit::displayUnitStats() {
|
|
float shiftedX = screenPos.x - 0.5 * lenHpBar;
|
|
hpForegroundNode->setPosition(Vector3(shiftedX, screenPos.y, 0));
|
|
hpForeground->setSize(Vector3(health / unitData::health[id] * lenHpBar, 10, 0));
|
|
hpBackgroundNode->setPosition(Vector3(shiftedX, screenPos.y, .1));
|
|
}
|
|
|
|
void Unit::executeOrders() {
|
|
if (orders.size() > 0) {
|
|
Order order = orders[0];
|
|
|
|
switch (order.type) {
|
|
case Order::TYPE::ATTACK:
|
|
attack(order);
|
|
break;
|
|
case Order::TYPE::MOVE:
|
|
move(order, unitData::destinationOffset[id]);
|
|
break;
|
|
case Order::TYPE::PATROL:
|
|
patrol(order);
|
|
break;
|
|
case Order::TYPE::LAUNCH:
|
|
launch(order);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Unit::setOrder(Order order) {
|
|
while (!orders.empty())
|
|
removeOrder(0);
|
|
|
|
addOrder(order);
|
|
orderLineDispTime = getTime();
|
|
}
|
|
|
|
void Unit::attack(Order order) {
|
|
}
|
|
|
|
void Unit::move(Order order, float destOffset) {
|
|
float movementAmmount, radius = getCircleRadius(), angle = 0.;
|
|
int targetId = (order.type == Order::TYPE::PATROL ? getNextPatrolPointId(order.targets.size()) : 0);
|
|
Vector3 dest = *order.targets[targetId].pos;
|
|
dest.y = pos.y;
|
|
Vector3 center;
|
|
|
|
if (leftVec.getAngleBetween(dest - pos) < PI / 2) {
|
|
moveDir = MoveDir::LEFT;
|
|
center = pos + leftVec*radius;
|
|
} else if (-leftVec.getAngleBetween(dest - pos) < PI / 2) {
|
|
moveDir = MoveDir::RIGHT;
|
|
center = pos - leftVec*radius;
|
|
}
|
|
|
|
bool withinCircle = center.getDistanceFrom(dest) < radius ? true : false;
|
|
|
|
if (moveDir != MoveDir::FORWARD) {
|
|
if (withinCircle)
|
|
angle = dirVec.getAngleBetween(center - dest) / PI * 180;
|
|
else
|
|
angle = dirVec.getAngleBetween(dest - pos) / PI * 180;
|
|
|
|
angle = isnan(angle) ? 0. : angle;
|
|
|
|
if (angle > anglePrecision[id]) {
|
|
float rotAngle = maxTurnAngle > angle ? angle : maxTurnAngle;
|
|
angle -= rotAngle;
|
|
turn(moveDir == MoveDir::RIGHT ? -rotAngle : rotAngle);
|
|
}
|
|
}
|
|
|
|
if (angle > anglePrecision[id])
|
|
movementAmmount = speed;
|
|
else {
|
|
if (withinCircle) {
|
|
float inDest = ((center - dest).norm() * radius - (center - dest)).getLength();
|
|
movementAmmount = speed > inDest ? inDest : speed;
|
|
} else
|
|
movementAmmount = speed > pos.getDistanceFrom(dest) ? pos.getDistanceFrom(dest) : speed;
|
|
}
|
|
|
|
advance(movementAmmount);
|
|
|
|
if (pos.getDistanceFrom(dest) <= destOffset && orders[0].type != Order::TYPE::ATTACK) {
|
|
moveDir = MoveDir::FORWARD;
|
|
|
|
if(orders[0].type == Order::TYPE::MOVE)
|
|
removeOrder(0);
|
|
else if(orders[0].type == Order::TYPE::PATROL)
|
|
patrolPointId = targetId;
|
|
}
|
|
}
|
|
|
|
void Unit::patrol(Order order) {
|
|
move(order, unitData::destinationOffset[id]);
|
|
}
|
|
|
|
void Unit::launch(Order order) {}
|
|
|
|
void Unit::advance(float speed) {
|
|
pos = pos + dirVec * speed;
|
|
model->setPosition(pos);
|
|
}
|
|
|
|
void Unit::turn(float angle) {
|
|
Quaternion rotQuat = Quaternion(PI / 180 * angle, Vector3(0, 1, 0));
|
|
model->setOrientation(rotQuat * model->getOrientation());
|
|
}
|
|
|
|
void Unit::halt() {
|
|
while (orders.size() > 0)
|
|
removeOrder(orders.size() - 1);
|
|
|
|
patrolPointId = 0;
|
|
}
|
|
|
|
float Unit::getCircleRadius() {
|
|
float radius = 0.;
|
|
|
|
for (int i = 0; i <= 90 / maxTurnAngle; i++)
|
|
radius += cos(i * (maxTurnAngle / 180 * PI)) * speed;
|
|
|
|
return radius;
|
|
}
|
|
|
|
void Unit::placeUnit(Vector3 p) {
|
|
model->setPosition(p);
|
|
pos = p;
|
|
}
|
|
|
|
void Unit::orientUnit(Vector3 orientVec){
|
|
Vector3 orientVecProj = Vector3(orientVec.x, 0, orientVec.z).norm();
|
|
float projAngle = orientVec.getAngleBetween(orientVecProj);
|
|
float rotAngle = Vector3(0,0,-1).getAngleBetween(orientVecProj);
|
|
|
|
rotAngle *= (orientVec.x < 0 ? 1 : -1) / PI * 180;
|
|
projAngle *= (orientVec.y > 0 ? 1 : -1) / PI * 180;
|
|
dirVec = orientVecProj;
|
|
upVec = Vector3(0,1,0);
|
|
leftVec = Quaternion(-PI / 2, upVec) * dirVec;
|
|
Quaternion rotQuat = Quaternion(projAngle / 180 * PI, leftVec);
|
|
dirVec = rotQuat * dirVec;
|
|
upVec = rotQuat * upVec;
|
|
}
|
|
|
|
Vector3 Unit::getCorner(int i) {
|
|
Vector3 corner = unitCornerPoints[id][i];
|
|
return pos + (leftVec * corner.x + upVec * corner.y - dirVec * corner.z);
|
|
}
|
|
|
|
std::vector<Projectile*> Unit::getProjectiles(){
|
|
std::vector<Projectile*> projectiles;
|
|
InGameAppState *inGameState = ((InGameAppState*)GameManager::getSingleton()->getStateManager()->getAppStateByType((int)AppStateType::IN_GAME_STATE));
|
|
|
|
for(Projectile *p: inGameState->getProjectiles())
|
|
if(p->getUnit() == this)
|
|
projectiles.push_back(p);
|
|
|
|
return projectiles;
|
|
}
|
|
|
|
void Unit::removeOrder(int id) {
|
|
LineRenderer::getSingleton()->removeLine(orders[id].line.id);
|
|
|
|
for(Order::Target t : orders[id].targets)
|
|
if(t.unit)
|
|
delete t.pos;
|
|
|
|
orders.erase(orders.begin() + id);
|
|
}
|
|
|
|
void Unit::toggleSelection(bool selection) {
|
|
selected = selection;
|
|
|
|
if(selection && selectionSfx)
|
|
selectionSfx->play();
|
|
|
|
orderLineDispTime = getTime();
|
|
}
|
|
|
|
void Unit::addProjectile(Projectile *p) {((InGameAppState*)GameManager::getSingleton()->getStateManager()->getAppStateByType((int)AppStateType::IN_GAME_STATE))->addProjectile(p);}
|
|
}
|