mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-25 17:53:47 +00:00
356 lines
7.1 KiB
C++
356 lines
7.1 KiB
C++
#include "Tile.h"
|
|
#include "RenderGrid.h"
|
|
#include "Tileset.h"
|
|
#include "Base.h"
|
|
|
|
TileStorage::TileStorage(const TileEffectStorage& eff)
|
|
: effstore(eff)
|
|
{
|
|
}
|
|
|
|
TileStorage::~TileStorage()
|
|
{
|
|
destroyAll();
|
|
}
|
|
|
|
void TileStorage::moveToFront(size_t idx)
|
|
{
|
|
_moveToFront(idx);
|
|
refreshAll();
|
|
}
|
|
|
|
void TileStorage::moveToBack(size_t idx)
|
|
{
|
|
_moveToBack(idx);
|
|
refreshAll();
|
|
}
|
|
|
|
void TileStorage::update(float dt)
|
|
{
|
|
for(size_t i = 0; i < indicesToUpdate.size(); ++i)
|
|
{
|
|
TileData& t = tiles[indicesToUpdate[i]];
|
|
assert(t.flags & TILEFLAG_OWN_EFFDATA); // known to be set if this ends up on the list
|
|
t.eff->update(dt, &t);
|
|
}
|
|
}
|
|
|
|
void TileStorage::doInteraction(const Vector& pos, const Vector& vel, float mult, float touchWidth)
|
|
{
|
|
for(size_t i = 0; i < indicesToCollide.size(); ++i)
|
|
{
|
|
TileData& t = tiles[indicesToCollide[i]];
|
|
t.eff->doInteraction(t, pos, vel, mult, touchWidth);
|
|
}
|
|
}
|
|
|
|
void TileStorage::_moveToFront(size_t idx)
|
|
{
|
|
// move tile to front -> move it to the back of the list, to be rendered last aka on top of everything else
|
|
TileData tile = tiles[idx];
|
|
tiles.erase(tiles.begin() + idx);
|
|
tiles.push_back(tile);
|
|
}
|
|
|
|
void TileStorage::_moveToBack(size_t idx)
|
|
{
|
|
// move tile to back -> move it to the front of the list, to be rendered first aka underneath everything else
|
|
TileData tile = tiles[idx];
|
|
tiles.erase(tiles.begin() + idx);
|
|
tiles.insert(tiles.begin(), tile);
|
|
}
|
|
|
|
void TileStorage::moveToOther(TileStorage& other, const size_t *indices, size_t n)
|
|
{
|
|
for(size_t i = 0; i < n; ++i)
|
|
other.tiles.push_back(tiles[indices[i]]);
|
|
|
|
std::vector<TileData> tmp;
|
|
tmp.swap(tiles);
|
|
tiles.reserve(tmp.size() - n);
|
|
for(size_t i = 0; i < tmp.size(); ++i)
|
|
{
|
|
for(size_t k = 0; k < n; ++i) // not particularly efficient, could be much better by sorting first but eh
|
|
if(indices[k] == i)
|
|
goto skip;
|
|
|
|
tiles.push_back(tmp[i]);
|
|
|
|
skip: ;
|
|
}
|
|
|
|
refreshAll();
|
|
other.refreshAll();
|
|
}
|
|
|
|
static void dropAttachments(TileData& t)
|
|
{
|
|
if(t.flags & TILEFLAG_OWN_EFFDATA)
|
|
{
|
|
delete t.eff;
|
|
t.flags &= ~TILEFLAG_OWN_EFFDATA;
|
|
}
|
|
t.eff = NULL;
|
|
}
|
|
|
|
void TileStorage::deleteSome(const size_t* indices, size_t n)
|
|
{
|
|
std::vector<TileData> tmp;
|
|
tmp.swap(tiles);
|
|
tiles.reserve(tmp.size() - n);
|
|
|
|
for(size_t i = 0; i < tmp.size(); ++i)
|
|
{
|
|
for(size_t k = 0; k < n; ++i) // not particularly efficient, could be much better by sorting first but eh
|
|
if(indices[k] == i)
|
|
{
|
|
dropAttachments(tmp[i]);
|
|
goto skip;
|
|
}
|
|
|
|
tiles.push_back(tmp[i]);
|
|
|
|
skip: ;
|
|
}
|
|
|
|
refreshAll();
|
|
}
|
|
|
|
void TileStorage::destroyAll()
|
|
{
|
|
const size_t n = tiles.size();
|
|
for(size_t i = 0; i < n; ++i)
|
|
dropAttachments(tiles[i]);
|
|
tiles.clear();
|
|
indicesToCollide.clear();
|
|
indicesToUpdate.clear();
|
|
}
|
|
|
|
void TileStorage::setTag(unsigned tag, const size_t* indices, size_t n)
|
|
{
|
|
for(size_t i = 0; i < n; ++i)
|
|
tiles[indices[i]].tag = tag;
|
|
// don't need to refresh here
|
|
}
|
|
|
|
void TileStorage::setEffect(int idx, const size_t* indices, size_t n)
|
|
{
|
|
for(size_t i = 0; i < n; ++i)
|
|
effstore.assignEffect(tiles[indices[i]], idx);
|
|
refreshAll();
|
|
}
|
|
|
|
void TileStorage::refreshAll()
|
|
{
|
|
indicesToCollide.clear();
|
|
indicesToUpdate.clear();
|
|
|
|
const size_t n = tiles.size();
|
|
for(size_t i = 0; i < n; ++i)
|
|
{
|
|
const TileData& t = tiles[i];
|
|
if(const TileEffectData *e = t.eff)
|
|
{
|
|
if(t.flags & TILEFLAG_OWN_EFFDATA)
|
|
{
|
|
indicesToUpdate.push_back(i);
|
|
if(e->efxtype == EFX_WAVY)
|
|
indicesToCollide.push_back(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TileStorage::clearSelection()
|
|
{
|
|
const size_t n = tiles.size();
|
|
for(size_t i = 0; i < n; ++i)
|
|
tiles[i].flags &= ~TILEFLAG_SELECTED;
|
|
}
|
|
|
|
TileEffectData::TileEffectData(const TileEffectConfig& cfg)
|
|
: efxtype(cfg.type), efxidx(cfg.index)
|
|
, grid(NULL), blend(BLEND_DEFAULT)
|
|
{
|
|
switch(cfg.type)
|
|
{
|
|
case EFX_WAVY:
|
|
{
|
|
float bity = 20; // FIXME
|
|
wavy.wavy.resize(cfg.u.wavy.segsy, 0.0f);
|
|
wavy.flip = cfg.u.wavy.flip;
|
|
wavy.min = bity;
|
|
wavy.max = bity*1.2f;
|
|
|
|
RenderGrid *g = new RenderGrid(2, cfg.u.wavy.segsy);
|
|
grid = g;
|
|
g->gridType = GRID_UNDEFINED; // by default it's GRID_WAVY, but that would reset during update
|
|
|
|
wavy.angleOffset = 0;
|
|
wavy.magnitude = 0;
|
|
wavy.lerpIn = 0;
|
|
wavy.hitPerc = 0;
|
|
wavy.effectMult = 0;
|
|
wavy.waving = false;
|
|
wavy.flip = false;
|
|
wavy.touching = false;
|
|
}
|
|
break;
|
|
|
|
case EFX_SEGS:
|
|
{
|
|
RenderGrid *g = new RenderGrid(cfg.u.segs.x, cfg.u.segs.y);
|
|
grid = g;
|
|
g->setSegs(cfg.u.segs.dgox, cfg.u.segs.dgoy, cfg.u.segs.dgmx, cfg.u.segs.dgmy, cfg.u.segs.dgtm, cfg.u.segs.dgo);
|
|
}
|
|
break;
|
|
|
|
case EFX_ALPHA:
|
|
{
|
|
alpha.x = cfg.u.alpha.val0;
|
|
alpha.interpolateTo(cfg.u.alpha.val1, cfg.u.alpha.time, -1, cfg.u.alpha.pingpong, cfg.u.alpha.ease);
|
|
blend = cfg.u.alpha.blend;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
TileEffectData::~TileEffectData()
|
|
{
|
|
delete grid;
|
|
}
|
|
|
|
void TileEffectData::Wavy::update(float dt)
|
|
{
|
|
if (touching)
|
|
{
|
|
touching = false;
|
|
float ramp = touchVel.getLength2D()/800.0f;
|
|
if (ramp < 0) ramp = 0;
|
|
if (ramp > 1) ramp = 1;
|
|
|
|
magnitude = 100 * ramp + 16;
|
|
|
|
if (touchVel.x < 0)
|
|
magnitude = -magnitude;
|
|
|
|
angleOffset = (hitPerc-0.5f)*PI;
|
|
|
|
wavySave = wavy;
|
|
lerpIn = 0;
|
|
}
|
|
|
|
if (waving)
|
|
{
|
|
// TODO: set waving=false if magnitude==0 ?
|
|
float spd = PI*1.1f;
|
|
float magRedSpd = 48;
|
|
float lerpSpd = 5.0;
|
|
float wavySz = float(wavy.size());
|
|
for (size_t i = 0; i < wavy.size(); i++)
|
|
{
|
|
float weight = float(i)/wavySz;
|
|
if (flip)
|
|
weight = 1.0f-weight;
|
|
if (weight < 0.125f)
|
|
weight *= 0.5f;
|
|
wavy[i] = sinf(angleOffset + (float(i)/wavySz)*PI)*(magnitude*effectMult)*weight;
|
|
if (!wavySave.empty())
|
|
{
|
|
if (lerpIn < 1)
|
|
wavy[i] = wavy[i] * lerpIn + (wavySave[i] * (1.0f-lerpIn));
|
|
}
|
|
}
|
|
|
|
if (lerpIn < 1)
|
|
{
|
|
lerpIn += dt*lerpSpd;
|
|
if (lerpIn > 1)
|
|
lerpIn = 1;
|
|
}
|
|
angleOffset += dt*spd;
|
|
if (magnitude > 0)
|
|
{
|
|
magnitude -= magRedSpd*dt;
|
|
if (magnitude < 0)
|
|
magnitude = 0;
|
|
}
|
|
else
|
|
{
|
|
magnitude += magRedSpd*dt;
|
|
if (magnitude > 0)
|
|
magnitude = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TileEffectData::update(float dt, const TileData *t)
|
|
{
|
|
switch(efxtype)
|
|
{
|
|
case EFX_WAVY:
|
|
wavy.update(dt);
|
|
if(const size_t N = wavy.wavy.size())
|
|
grid->setFromWavy(&wavy.wavy[0], N, t->et->w);
|
|
break;
|
|
|
|
case EFX_SEGS:
|
|
grid->update(dt);
|
|
break;
|
|
|
|
case EFX_ALPHA:
|
|
alpha.update(dt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TileEffectData::doInteraction(const TileData& t, const Vector& pos, const Vector& vel, float mult, float touchWidth)
|
|
{
|
|
assert(efxtype == EFX_WAVY);
|
|
|
|
const Vector tp(t.x, t.y);
|
|
|
|
if (pos.x > tp.x-touchWidth && pos.x < tp.x+touchWidth)
|
|
{
|
|
float h = t.et->h*t.scaley;
|
|
float h2 = h * 0.5f;
|
|
if (pos.y < tp.y+h2 && pos.y > tp.y-h2)
|
|
{
|
|
wavy.touching = true;
|
|
wavy.waving = true;
|
|
float hitPerc = tp.y - h2 - pos.y;
|
|
hitPerc /= h;
|
|
hitPerc = (1.0f-hitPerc)-1.0f;
|
|
wavy.hitPerc = hitPerc;
|
|
wavy.touchVel = vel;
|
|
wavy.effectMult = mult;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TileEffectStorage::assignEffect(TileData& t, int index) const
|
|
{
|
|
dropAttachments(t);
|
|
|
|
if(index < 0)
|
|
return;
|
|
|
|
size_t idx = size_t(index);
|
|
|
|
if(idx < prepared.size() && prepared[idx])
|
|
{
|
|
t.eff = prepared[idx];
|
|
}
|
|
else if(idx < configs.size())
|
|
{
|
|
t.eff = new TileEffectData(configs[idx]);
|
|
t.flags |= TILEFLAG_OWN_EFFDATA;
|
|
}
|
|
}
|
|
|
|
void TileEffectStorage::update(float dt)
|
|
{
|
|
for(size_t i = 0; i < prepared.size(); ++i)
|
|
if(TileEffectData *eff = prepared[i])
|
|
eff->update(dt, NULL);
|
|
}
|