std::pair<Vec3f, Vec3f> angleToFrontUpVec(const Anglef & angle) {
Vec3f front = angleToVector(angle);
Vec3f up = angleToVector(angle + Anglef(90.f, 0, 0));
arx_assert(glm::abs(glm::dot(front, up)) < 5.f * std::numeric_limits<float>::epsilon(),
"front=(%f,%f,%f) and up=(%f,%f,%f) should be orthogonal; dot=%1f*epsilon",
double(front.x), double(front.y), double(front.z),
double(up.x), double(up.y), double(up.z),
double(glm::dot(front, up) / std::numeric_limits<float>::epsilon()));
return std::make_pair(front, up);
}
static void PlayerLaunchArrow_Test(float aimratio, float poisonous, const Vec3f & pos, const Anglef & angle) {
Vec3f vect = angleToVector(angle);
Vec3f position = pos;
float velocity = aimratio + 0.3f;
if(velocity < 0.9f)
velocity = 0.9f;
glm::quat quat = angleToQuatForArrow(angle);
float wd = getEquipmentBaseModifier(IO_EQUIPITEM_ELEMENT_Damages);
// TODO Why ignore relative modifiers? Why not just use player.Full_damages?
float damages = wd * (1.f + (player.m_skillFull.projectile + player.m_attributeFull.dexterity) * (1.f/50));
ARX_THROWN_OBJECT_Throw(PlayerEntityHandle, position, vect, quat, velocity, damages, poisonous);
}
void snMover::reset(float2 offset, float angle, float force, float mass, float torque, float moment)
{
float2 direction = angleToVector(angle);
accel = direction * force / mass;
accelNorm = direction;
accelAngAccel = isZero(offset) ? 0.f : cross(offset, direction * force) / moment;
angAccel = torque / moment;
// FIXME we actually want a different threshhold depending on total torque available
// if we have only a few thrusters we need to use them all to rotate
// but at some point the minimal additional rotation speed is not worth the slew
useForRotation = ((fabsf(accelAngAccel) / length(accel)) > 0.001) || (angAccel > epsilon);
// FIXME we can't even hack this by itself - we need to look at all the movers.3
useForTranslation = !isZero(accel);
accelEnabled = 0;
angAccelEnabled = 0;
}
static void Cedric_PrepareHalo(EERIE_3DOBJ * eobj, Skeleton * obj) {
Vec3f cam_vector = angleToVector(ACTIVECAM->angle);
// Apply light on all vertices
for(size_t i = 0; i != obj->bones.size(); i++) {
const Bone & bone = obj->bones[i];
glm::quat qt1 = bone.anim.quat;
Vec3f t_vector = glm::inverse(qt1) * cam_vector;
// Get light value for each vertex
for(size_t v = 0; v != bone.idxvertices.size(); v++) {
size_t vertIndex = bone.idxvertices[v];
const Vec3f & inVert = eobj->vertexlist[vertIndex].norm;
// Get cos angle between light and vertex norm
eobj->vertexlist3[vertIndex].norm.z =
(inVert.x * t_vector.x + inVert.y * t_vector.y + inVert.z * t_vector.z);
}
}
}
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;
}
const float2 Entity::actualDir() const {
return angleToVector(actualDirAngle());
}
const float2 Entity::dir() const {
return angleToVector(dirAngle());
}
void MagicMissileSpell::Launch() {
m_duration = ArxDurationMs(6000);
m_hand_group = GetActionPointIdx(entities[m_caster]->obj, "primary_attach");
if(m_hand_group != ActionPoint()) {
Entity * caster = entities[m_caster];
ActionPoint group = m_hand_group;
m_hand_pos = actionPointPosition(caster->obj, group);
}
Vec3f startPos;
float pitch, yaw;
if(m_caster == EntityHandle_Player) {
yaw = player.angle.getYaw();
pitch = player.angle.getPitch();
Vec3f vector = angleToVector(Anglef(pitch, yaw, 0.f)) * 60.f;
if(m_hand_group != ActionPoint()) {
startPos = m_hand_pos;
} else {
startPos = player.pos;
startPos += angleToVectorXZ(yaw);
}
startPos += vector;
} else {
pitch = 0;
yaw = entities[m_caster]->angle.getYaw();
Vec3f vector = angleToVector(Anglef(pitch, yaw, 0.f)) * 60.f;
if(m_hand_group != ActionPoint()) {
startPos = m_hand_pos;
} else {
startPos = entities[m_caster]->pos;
}
startPos += vector;
Entity * io = entities[m_caster];
if(ValidIONum(io->targetinfo)) {
const Vec3f & p1 = m_caster_pos;
const Vec3f & p2 = entities[io->targetinfo]->pos;
pitch = -(glm::degrees(getAngle(p1.y, p1.z, p2.y, p2.z + glm::distance(Vec2f(p2.x, p2.z), Vec2f(p1.x, p1.z))))); //alpha entre orgn et dest;
} else if (ValidIONum(m_target)) {
const Vec3f & p1 = m_caster_pos;
const Vec3f & p2 = entities[m_target]->pos;
pitch = -(glm::degrees(getAngle(p1.y, p1.z, p2.y, p2.z + glm::distance(Vec2f(p2.x, p2.z), Vec2f(p1.x, p1.z))))); //alpha entre orgn et dest;
}
}
m_mrCheat = (m_caster == EntityHandle_Player && cur_mr == 3);
ArxDuration lMax = ArxDuration_ZERO;
long number;
if(sp_max || cur_rf == 3) {
number = long(m_level);
} else {
number = glm::clamp(long(m_level + 1) / 2, 1l, 5l);
}
pTab.reserve(number);
for(size_t i = 0; i < size_t(number); i++) {
CMagicMissile * missile = NULL;
if(!m_mrCheat) {
missile = new CMagicMissile();
} else {
missile = new MrMagicMissileFx();
}
pTab.push_back(missile);
Anglef angles(pitch, yaw, 0.f);
if(i > 0) {
angles.setPitch(angles.getPitch() + Random::getf(-4.0f, 4.0f));
angles.setYaw(angles.getYaw() + Random::getf(-6.0f, 6.0f));
}
missile->Create(startPos, angles);
ArxDuration lTime = m_duration + ArxDurationMs(Random::get(-1000, 1000));
lTime = std::max(ArxDurationMs(1000), lTime);
lMax = std::max(lMax, lTime);
missile->SetDuration(lTime);
EERIE_LIGHT * el = dynLightCreate(missile->lLightId);
if(el) {
el->intensity = 0.7f + 2.3f;
el->fallend = 190.f;
el->fallstart = 80.f;
if(m_mrCheat) {
el->rgb = Color3f(1.f, 0.3f, 0.8f);
} else {
el->rgb = Color3f(0.f, 0.f, 1.f);
}
el->pos = startPos;
el->duration = ArxDurationMs(300);
}
}
m_duration = lMax + ArxDurationMs(1000);
}
