static void StoreEntityMovement(Entity * io, Vec3f & ftr, float scale) {
if(!io)
return;
arx_assert(isallfinite(ftr));
ftr *= scale;
float temp;
if (io == entities.player()) {
temp = MAKEANGLE(180.f - player.angle.getYaw());
} else {
temp = MAKEANGLE(180.f - io->angle.getYaw());
}
Vec3f ftr2 = VRotateY(ftr, temp);
// stores Translations for a later use
io->move = ftr2;
if(io->animlayer[0].cur_anim) {
// Use calculated value to notify the Movement engine of the translation to do
if(io->ioflags & IO_NPC) {
ftr = Vec3f_ZERO;
io->move -= io->lastmove;
} else if (io->gameFlags & GFLAG_ELEVATOR) {
// Must recover translations for NON-NPC IO
PushIO_ON_Top(io, io->move.y - io->lastmove.y);
}
io->lastmove = ftr2;
}
}
glm::quat angleToQuatForArrow(const Anglef & angle) {
float aa = angle.getYaw();
float ab = 90 - angle.getPitch();
Vec3f front(0,0,1);
Vec3f up(0,-1,0);
front = VRotateZ(front, aa);
front = VRotateY(front, ab);
up = VRotateZ(up, aa);
up = VRotateY(up, ab);
glm::mat4x4 tmat;
MatrixSetByVectors(tmat, front, up);
return glm::toQuat(tmat);
}
bool Manage3DCursor(Entity * io, bool simulate) {
arx_assert(io);
if(BLOCK_PLAYER_CONTROLS)
return false;
float ag = player.angle.getYaw();
if(ag > 180)
ag = ag - 360;
float drop_miny = (float)(g_size.center().y) - g_size.center().y * (ag * (1.f/70));
if(DANAEMouse.y < drop_miny)
return false;
Anglef temp = Anglef::ZERO;
if(io->ioflags & IO_INVERTED) {
temp.setYaw(180.f);
temp.setPitch(-MAKEANGLE(270.f - io->angle.getPitch() - (player.angle.getPitch() - STARTED_ANGLE)));
} else {
temp.setPitch(MAKEANGLE(270.f - io->angle.getPitch() - (player.angle.getPitch() - STARTED_ANGLE)));
}
EERIE_3D_BBOX bbox;
for(size_t i = 0; i < io->obj->vertexlist.size(); i++) {
bbox.add(io->obj->vertexlist[i].v);
}
Vec3f mvectx = angleToVectorXZ(player.angle.getPitch() - 90.f);
Vec2f mod = Vec2f(Vec2i(DANAEMouse) - g_size.center()) / Vec2f(g_size.center()) * Vec2f(160.f, 220.f);
mvectx *= mod.x;
Vec3f mvecty(0, mod.y, 0);
Vec3f orgn = player.pos;
orgn += angleToVector(player.angle) * 50.f;
orgn += mvectx;
orgn.y += mvecty.y;
Vec3f dest = player.pos;
dest += angleToVector(player.angle) * 10000.f;
dest += mvectx;
dest.y += mvecty.y * 5.f;
Vec3f pos = orgn;
Vec3f movev = glm::normalize(dest - orgn);
float lastanything = 0.f;
float height = -(bbox.max.y - bbox.min.y);
if(height > -30.f)
height = -30.f;
Vec3f objcenter = bbox.min + (bbox.max - bbox.min) * Vec3f(0.5f);
Vec3f collidpos = Vec3f_ZERO;
bool collidpos_ok = false;
{
float maxdist = 0.f;
for(size_t i = 0; i < io->obj->vertexlist.size(); i++) {
const EERIE_VERTEX & vert = io->obj->vertexlist[i];
float dist = glm::distance(Vec2f(objcenter.x, objcenter.z), Vec2f(vert.v.x, vert.v.z)) - 4.f;
maxdist = std::max(maxdist, dist);
}
if(io->obj->pbox) {
Vec2f tmpVert(io->obj->pbox->vert[0].initpos.x, io->obj->pbox->vert[0].initpos.z);
for(int i = 1; i < io->obj->pbox->nb_physvert; i++) {
const PHYSVERT & physVert = io->obj->pbox->vert[i];
float dist = glm::distance(tmpVert, Vec2f(physVert.initpos.x, physVert.initpos.z)) + 14.f;
maxdist = std::max(maxdist, dist);
}
}
Cylinder cyl2;
const float inc = 10.f;
long iterating = 40;
cyl2.height = std::min(-30.f, height);
cyl2.radius = glm::clamp(maxdist, 20.f, 150.f);
while(iterating > 0) {
cyl2.origin = pos + movev * inc + Vec3f(0.f, bbox.max.y, 0.f);
float anything = CheckAnythingInCylinder(cyl2, io, CFLAG_JUST_TEST | CFLAG_COLLIDE_NOCOL | CFLAG_NO_NPC_COLLIDE);
if(anything < 0.f) {
if(iterating == 40) {
CANNOT_PUT_IT_HERE = 1;
// TODO is this correct ?
return true;
}
iterating = 0;
collidpos = cyl2.origin;
if(lastanything < 0.f) {
pos.y += lastanything;
collidpos.y += lastanything;
}
} else {
pos = cyl2.origin;
lastanything = anything;
}
iterating--;
}
collidpos_ok = iterating == -1;
}
objcenter = VRotateY(objcenter, temp.getPitch());
collidpos.x -= objcenter.x;
collidpos.z -= objcenter.z;
pos.x -= objcenter.x;
pos.z -= objcenter.z;
if(!collidpos_ok) {
CANNOT_PUT_IT_HERE = 1;
return false;
}
if(collidpos_ok && closerThan(player.pos, pos, 300.f)) {
if(simulate) {
ARX_INTERACTIVE_Teleport(io, pos, true);
io->gameFlags &= ~GFLAG_NOCOMPUTATION;
glm::quat rotation = glm::toQuat(toRotationMatrix(temp));
if(SPECIAL_DRAGINTER_RENDER) {
if(glm::abs(lastanything) > glm::abs(height)) {
TransformInfo t(collidpos, rotation, io->scale);
static const float invisibility = 0.5f;
DrawEERIEInter(io->obj, t, io, false, invisibility);
} else {
TransformInfo t(pos, rotation, io->scale);
float invisibility = Cedric_GetInvisibility(io);
DrawEERIEInter(io->obj, t, io, false, invisibility);
}
}
} else {
if(glm::abs(lastanything) > std::min(glm::abs(height), 12.0f)) {
Entity * io = DRAGINTER;
ARX_PLAYER_Remove_Invisibility();
io->obj->pbox->active = 1;
io->obj->pbox->stopcount = 0;
io->pos = collidpos;
io->velocity = Vec3f_ZERO;
io->stopped = 1;
movev.x *= 0.0001f;
movev.y = 0.1f;
movev.z *= 0.0001f;
Vec3f viewvector = movev;
Anglef angle = temp;
io->soundtime = 0;
io->soundcount = 0;
EERIE_PHYSICS_BOX_Launch(io->obj, io->pos, angle, viewvector);
ARX_SOUND_PlaySFX(SND_WHOOSH, &pos);
io->show = SHOW_FLAG_IN_SCENE;
Set_DragInter(NULL);
} else {
ARX_PLAYER_Remove_Invisibility();
ARX_SOUND_PlayInterface(SND_INVSTD);
ARX_INTERACTIVE_Teleport(io, pos, true);
io->angle.setYaw(temp.getYaw());
io->angle.setPitch(270.f - temp.getPitch());
io->angle.setRoll(temp.getRoll());
io->stopped = 0;
io->show = SHOW_FLAG_IN_SCENE;
io->obj->pbox->active = 0;
Set_DragInter(NULL);
}
}
GRenderer->SetCulling(Renderer::CullNone);
return true;
} else {
CANNOT_PUT_IT_HERE=-1;
}
return false;
}
void CLightning::Render()
{
if(ulCurrentTime >= ulDuration)
return;
if(m_iTTL <= 0) {
fTotoro = 0;
fMySize = 2;
ReCreate(8);
}
Vec3f ePos;
float fBeta = 0.f;
float falpha = 0.f;
if(m_isMassLightning) {
ePos = Vec3f_ZERO;
} else {
ePos = m_pos;
fBeta = m_beta;
falpha = m_alpha;
}
float f = 1.5f * fMySize;
m_cnodetab[0].f = randomVec(-f, f);
RenderMaterial mat;
mat.setCulling(Renderer::CullNone);
mat.setDepthTest(false);
mat.setBlendType(RenderMaterial::Additive);
float fbeta = fBeta + rnd() * 2 * fMySize;
for(size_t i = 0; i < m_nbtotal && i <= fTotoro; i++) {
CLightningNode & node = m_cnodetab[i];
Vec3f astart = m_cnodetab[node.parent].pos + m_cnodetab[node.parent].f;
float temp = 1.5f * fMySize;
Vec3f z_z = m_cnodetab[node.parent].f + randomVec(-temp, temp);
float zz = node.size + node.size * 0.3f * rnd();
float xx = node.size * glm::cos(glm::radians(-fbeta));
node.f = z_z;
Vec3f a = node.pos + z_z;
if(!m_isMassLightning) {
Vec3f vv2;
Vec3f vv1 = astart;
vv1 = VRotateX(vv1, (falpha));
vv2 = VRotateY(vv1, 180 - MAKEANGLE(fBeta));
astart = vv2;
vv1 = a;
vv1 = VRotateX(vv1, (falpha));
vv2 = VRotateY(vv1, 180 - MAKEANGLE(fBeta));
a = vv2;
astart += ePos;
a += ePos;
}
if(i % 4 == 0) {
Sphere sphere;
sphere.origin = a;
sphere.radius = std::min(node.size, 50.f);
if(CheckAnythingInSphere(sphere, m_caster, CAS_NO_SAME_GROUP)) {
DamageParameters damage;
damage.pos = sphere.origin;
damage.radius = sphere.radius;
damage.damages = m_fDamage * m_level * ( 1.0f / 3 );
damage.area = DAMAGE_FULL;
damage.duration = 1;
damage.source = m_caster;
damage.flags = DAMAGE_FLAG_DONT_HURT_SOURCE | DAMAGE_FLAG_ADD_VISUAL_FX;
damage.type = DAMAGE_TYPE_FAKEFIRE | DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_LIGHTNING;
DamageCreate(damage);
}
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_ZERO;
q.v[2].uv = Vec2f_Y_AXIS;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart + Vec3f(0.f, zz, 0.f);
q.v[2].p = a + Vec3f(0.f, zz, 0.f);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_X_AXIS;
q.v[2].uv = Vec2f_ONE;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart - Vec3f(0.f, zz, 0.f);
q.v[2].p = a - Vec3f(0.f, zz, 0.f);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
zz *= glm::sin(glm::radians(fbeta));
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_X_AXIS;
q.v[2].uv = Vec2f_ONE;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart + Vec3f(xx, 0.f, zz);
q.v[2].p = a + Vec3f(xx, 0.f, zz);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_ZERO;
q.v[2].uv = Vec2f_Y_AXIS;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart - Vec3f(xx, 0.f, zz);
q.v[2].p = a - Vec3f(xx, 0.f, zz);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
}
}
static bool ANCHOR_ARX_COLLISION_Move_Cylinder(IO_PHYSICS * ip, Entity * io,
float MOVE_CYLINDER_STEP,
CollisionFlags flags) {
MOVING_CYLINDER = 1;
DIRECT_PATH = true;
IO_PHYSICS test;
if(ip == NULL) {
MOVING_CYLINDER = 0;
return false;
}
float distance = glm::distance(ip->startpos, ip->targetpos);
if(distance <= 0.f) {
MOVING_CYLINDER = 0;
return true;
}
Vec3f mvector = (ip->targetpos - ip->startpos) / distance;
while(distance > 0.f) {
// First We compute current increment
float curmovedist = std::min(distance, MOVE_CYLINDER_STEP);
distance -= curmovedist;
//CUR_FRAME_SLICE=curmovedist*onedist;
// Store our cylinder desc into a test struct
test = *ip;
// uses test struct to simulate movement.
test.cyl.origin += mvector * curmovedist;
vector2D.x = mvector.x * curmovedist;
vector2D.y = 0.f;
vector2D.z = mvector.z * curmovedist;
if ((flags & CFLAG_CHECK_VALID_POS)
&& (CylinderAboveInvalidZone(test.cyl)))
return false;
if(ANCHOR_AttemptValidCylinderPos(test.cyl, io, flags)) {
*ip = test;
} else {
if(flags & CFLAG_CLIMBING) {
test.cyl = ip->cyl;
test.cyl.origin.y += mvector.y * curmovedist;
if(ANCHOR_AttemptValidCylinderPos(test.cyl, io, flags)) {
*ip = test;
goto oki;
}
}
DIRECT_PATH = false;
// Must Attempt To Slide along collisions
Vec3f vecatt;
Vec3f rpos = Vec3f_ZERO;
Vec3f lpos = Vec3f_ZERO;
long RFOUND = 0;
long LFOUND = 0;
long maxRANGLE = 90;
float ANGLESTEPP;
// player sliding in fact...
if(flags & CFLAG_EASY_SLIDING) {
ANGLESTEPP = 10.f;
maxRANGLE = 70;
} else {
ANGLESTEPP = 30.f;
}
float rangle = ANGLESTEPP;
float langle = 360.f - ANGLESTEPP;
//tries on the Right and Left sides
while(rangle <= maxRANGLE) {
test.cyl = ip->cyl;
float t = MAKEANGLE(rangle);
vecatt = VRotateY(mvector, t);
test.cyl.origin += vecatt * curmovedist;
if(ANCHOR_AttemptValidCylinderPos(test.cyl, io, flags)) {
rpos = test.cyl.origin;
RFOUND = 1;
}
rangle += ANGLESTEPP;
test.cyl = ip->cyl;
t = MAKEANGLE(langle);
vecatt = VRotateY(mvector, t);
test.cyl.origin += vecatt * curmovedist;
if(ANCHOR_AttemptValidCylinderPos(test.cyl, io, flags)) {
lpos = test.cyl.origin;
LFOUND = 1;
}
langle -= ANGLESTEPP;
if(RFOUND || LFOUND)
break;
}
if(LFOUND && RFOUND) {
langle = 360.f - langle;
if(langle < rangle) {
ip->cyl.origin = lpos;
distance -= curmovedist;
} else {
ip->cyl.origin = rpos;
distance -= curmovedist;
}
} else if(LFOUND) {
ip->cyl.origin = lpos;
distance -= curmovedist;
} else if(RFOUND) {
ip->cyl.origin = rpos;
distance -= curmovedist;
} else { //stopped
ip->velocity = Vec3f_ZERO;
MOVING_CYLINDER = 0;
return false;
}
}
oki:
;
}
MOVING_CYLINDER = 0;
return true;
}
