int Text::update(void* p)
{
RectType r= set_father_window(true);
Font::set_window(Graphic::RectType(real_position(), area.xSize/Font::font_width() , area.ySize/Font::font_high()));
Out::print(real_position().x, real_position().y, text.c_str());
Font::set_full_window();
release_father_window(r);
return 0;
}
static gboolean get_mpris_metadata_cb(void *data)
{
struct MprisMetadataRequest *request = data;
g_mutex_lock(info_mutex);
real_position(&request->playlist, &request->entry);
gchar * filename = playlist_entry_get_filename (request->playlist,
request->entry);
Tuple * tuple = playlist_entry_get_tuple (request->playlist, request->entry,
FALSE);
if (filename && tuple)
request->metadata = make_mpris_metadata (filename, tuple);
else
request->metadata = NULL;
g_free (filename);
if (tuple)
tuple_free (tuple);
g_cond_signal(info_cond);
g_mutex_unlock(info_mutex);
return FALSE;
}
int32 MoveSplineInit::Launch()
{
MoveSpline& move_spline = *unit->movespline;
Location real_position(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZMinusOffset(), unit->GetOrientation());
// Elevators also use MOVEMENTFLAG_ONTRANSPORT but we do not keep track of their position changes
if (unit->GetTransGUID())
{
real_position.x = unit->GetTransOffsetX();
real_position.y = unit->GetTransOffsetY();
real_position.z = unit->GetTransOffsetZ();
real_position.orientation = unit->GetTransOffsetO();
}
// there is a big chance that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
// Don't compute for transport movement if the unit is in a motion between two transports
if (!move_spline.Finalized() && move_spline.onTransport == (unit->GetTransGUID() != 0))
real_position = move_spline.ComputePosition();
// should i do the things that user should do? - no.
if (args.path.empty())
return 0;
// correct first vertex
args.path[0] = real_position;
args.initialOrientation = real_position.orientation;
move_spline.onTransport = (unit->GetTransGUID() != 0);
uint32 moveFlags = unit->m_movementInfo.GetMovementFlags();
moveFlags |= MOVEMENTFLAG_FORWARD;
if (moveFlags & MOVEMENTFLAG_ROOT)
moveFlags &= ~MOVEMENTFLAG_MASK_MOVING;
if (!args.HasVelocity)
{
// If spline is initialized with SetWalk method it only means we need to select
// walk move speed for it but not add walk flag to unit
uint32 moveFlagsForSpeed = moveFlags;
if (args.flags.walkmode)
moveFlagsForSpeed |= MOVEMENTFLAG_WALKING;
else
moveFlagsForSpeed &= ~MOVEMENTFLAG_WALKING;
args.velocity = unit->GetSpeed(SelectSpeedType(moveFlagsForSpeed));
}
if (!args.Validate(unit))
return 0;
unit->m_movementInfo.SetMovementFlags(moveFlags);
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
PacketBuilder::WriteMonsterMove(move_spline, data, unit);
unit->SendMessageToSet(&data, true);
return move_spline.Duration();
}
void MoveSplineInit::Launch()
{
MoveSpline& move_spline = *unit.movespline;
bool transport = false;
Location real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZMinusOffset(), unit.GetOrientation());
// Elevators also use MOVEMENTFLAG_ONTRANSPORT but we do not keep track of their position changes
if (unit.HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && unit.GetTransGUID())
{
transport = true;
real_position.x = unit.GetTransOffsetX();
real_position.y = unit.GetTransOffsetY();
real_position.z = unit.GetTransOffsetZ();
real_position.orientation = unit.GetTransOffsetO();
}
// there is a big chance that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
real_position = move_spline.ComputePosition();
// should i do the things that user should do? - no.
if (args.path.empty())
return;
// corrent first vertex
args.path[0] = real_position;
args.initialOrientation = real_position.orientation;
uint32 moveFlags = unit.m_movementInfo.GetMovementFlags();
if (args.flags.walkmode)
moveFlags |= MOVEMENTFLAG_WALKING;
else
moveFlags &= ~MOVEMENTFLAG_WALKING;
moveFlags |= (MOVEMENTFLAG_SPLINE_ENABLED|MOVEMENTFLAG_FORWARD);
if (!args.HasVelocity)
args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags));
if (!args.Validate())
return;
if (moveFlags & MOVEMENTFLAG_ROOT)
moveFlags &= ~MOVEMENTFLAG_MASK_MOVING;
unit.m_movementInfo.SetMovementFlags((MovementFlags)moveFlags);
move_spline.Initialize(args);
WorldPacket data(!transport ? SMSG_MONSTER_MOVE : SMSG_MONSTER_MOVE_TRANSPORT, 64);
data.append(unit.GetPackGUID());
if (transport)
{
data.appendPackGUID(unit.GetTransGUID());
data << int8(unit.GetTransSeat());
}
PacketBuilder::WriteMonsterMove(move_spline, data);
unit.SendMessageToSet(&data,true);
}
int32 MoveSplineInit::Launch()
{
MoveSpline& move_spline = *unit.movespline;
TransportInfo* transportInfo = unit.GetTransportInfo();
Location real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ(), unit.GetOrientation());
// If boarded use current local position
if (transportInfo)
transportInfo->GetLocalPosition(real_position.x, real_position.y, real_position.z, real_position.orientation);
// there is a big chane that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized() && !transportInfo)
real_position = move_spline.ComputePosition();
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// corrent first vertex
args.path[0] = real_position;
args.initialOrientation = real_position.orientation;
uint32 moveFlags = unit.m_movementInfo.GetMovementFlags();
if (args.flags.walkmode)
moveFlags |= MOVEFLAG_WALK_MODE;
else
moveFlags &= ~MOVEFLAG_WALK_MODE;
moveFlags |= (MOVEFLAG_SPLINE_ENABLED | MOVEFLAG_FORWARD);
if (args.velocity == 0.f)
args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags));
if (!args.Validate(&unit))
return 0;
unit.m_movementInfo.SetMovementFlags((MovementFlags)moveFlags);
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
if (transportInfo)
{
data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
data << transportInfo->GetTransportGuid().WriteAsPacked();
data << int8(transportInfo->GetTransportSeat());
}
PacketBuilder::WriteMonsterMove(move_spline, data);
unit.SendMessageToSet(&data, true);
return move_spline.Duration();
}
int32 MoveSplineInit::Launch(int32 maxTravelTime, bool hideMovement)
{
MoveSpline& move_spline = *unit.movespline;
Vector3 real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ());
// there is a big chane that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
real_position = move_spline.ComputePosition();
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// corrent first vertex
args.path[0] = real_position;
uint32 moveFlags = unit.m_movementInfo.GetMovementFlags();
if (args.flags.runmode)
moveFlags &= ~MOVEFLAG_WALK_MODE;
else
moveFlags |= MOVEFLAG_WALK_MODE;
moveFlags |= (MOVEFLAG_SPLINE_ENABLED | MOVEFLAG_FORWARD);
if (args.velocity == 0.f)
args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags));
if (!args.Validate(&unit))
return 0;
unit.m_movementInfo.SetMovementFlags((MovementFlags)moveFlags);
move_spline.Initialize(args);
auto duration = move_spline.Duration();
if (maxTravelTime && duration > maxTravelTime)
{
auto dest = args.path[args.path.size() - 1];
dest.z += 1.f;
args.path_Idx_offset = 0;
args.path.resize(2);
args.path[1] = dest;
move_spline.Initialize(args);
}
if (hideMovement)
return duration;
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
PacketBuilder::WriteMonsterMove(move_spline, data);
unit.SendMessageToSet(&data, true);
return duration;
}
vec3d get_real_position()
{
vec3d real_position(0, 0, 0);
ALLEGRO_TRANSFORM t;
position_transform(&t);
al_transform_coordinates_3d(&t, &real_position.x, &real_position.y, &real_position.z);
return real_position;
}
static gboolean get_position_cb(void *data)
{
struct PositionRequest *request = data;
g_mutex_lock(info_mutex);
real_position(&request->playlist, &request->entry);
request->entry_count = playlist_entry_count(request->playlist);
request->queue_count = playlist_queue_count(request->playlist);
g_cond_signal(info_cond);
g_mutex_unlock(info_mutex);
return FALSE;
}
void MoveSplineInit::Stop()
{
MoveSpline& move_spline = *unit.movespline;
// No need to stop if we are not moving
if (move_spline.Finalized())
return;
// ToDo: update transport info if required
// TransportInfo* transportInfo = unit.GetTransportInfo();
Location real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ(), unit.GetOrientation());
// If boarded use current local position
// if (transportInfo)
// transportInfo->GetLocalPosition(real_position.x, real_position.y, real_position.z, real_position.orientation);
// there is a big chance that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized() /*&& !transportInfo*/)
real_position = move_spline.ComputePosition();
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// current first vertex
args.path[0] = real_position;
args.flags = MoveSplineFlag::Done;
unit.m_movementInfo.RemoveMovementFlag(MovementFlags(MOVEFLAG_FORWARD | MOVEFLAG_SPLINE_ENABLED));
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
// ToDo: update transport info if required
/*if (transportInfo)
{
data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
data << transportInfo->GetTransportGuid().WriteAsPacked();
}*/
data << real_position.x << real_position.y << real_position.z;
data << move_spline.GetId();
data << uint8(MonsterMoveStop);
unit.SendMessageToSet(&data, true);
}
static gboolean get_field_cb(void *data)
{
struct FieldRequest *request = data;
g_mutex_lock(info_mutex);
real_position(&request->playlist, &request->entry);
Tuple * tuple = playlist_entry_get_tuple (request->playlist, request->entry, FALSE);
request->value = (tuple == NULL) ? NULL : tuple_value_to_gvalue(tuple, request->field);
if (tuple)
tuple_free (tuple)
g_cond_signal(info_cond);
g_mutex_unlock(info_mutex);
return FALSE;
}
// void MoveSplineInit::Launch()
int32 MoveSplineInit::Launch()
{
MoveSpline& move_spline = *unit.movespline;
Location real_position(unit.GetPositionX(),unit.GetPositionY(),unit.GetPositionZ(),unit.GetOrientation());
// there is a big chane that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
real_position = move_spline.ComputePosition();
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// corrent first vertex
args.path[0] = real_position;
args.initialOrientation = real_position.orientation;
uint32 moveFlags = unit._movementInfo.GetMovementFlags();
if (args.flags.walkmode)
moveFlags |= MOVEMENTFLAG_WALKING;
else
moveFlags &= ~MOVEMENTFLAG_WALKING;
moveFlags |= (MOVEMENTFLAG_SPLINE_ENABLED|MOVEMENTFLAG_FORWARD);
if (args.velocity == 0.f)
args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags));
if (!args.Validate())
return 0;
if (moveFlags & MOVEMENTFLAG_ROOT)
moveFlags &= ~MOVEMENTFLAG_MASK_MOVING;
unit._movementInfo.SetMovementFlags((MovementFlags)moveFlags);
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data.append(unit.GetPackGUID());
PacketBuilder::WriteMonsterMove(move_spline, data);
unit.SendMessageToSet(&data, true);
return move_spline.Duration();
}
static gboolean get_info_cb(void *data)
{
struct InfoRequest *request = data;
g_mutex_lock(info_mutex);
real_position(&request->playlist, &request->entry);
request->filename = playlist_entry_get_filename (request->playlist,
request->entry);
request->title = playlist_entry_get_title (request->playlist,
request->entry, FALSE);
request->length = playlist_entry_get_length (request->playlist,
request->entry, FALSE);
request->pltitle = playlist_get_title (request->playlist);
g_cond_signal(info_cond);
g_mutex_unlock(info_mutex);
return FALSE;
}
float get_inter(t_eye *eye, t_3dpoint *vec, t_obj *obj)
{
t_3dpoint tmp_eye;
t_3dpoint pvec;
pvec.x = vec->x;
pvec.y = vec->y;
pvec.z = vec->z;
real_position(&tmp_eye, &pvec, eye, obj);
if (obj->type == O_SPHERE)
return (inter_sphere(&tmp_eye, &pvec, obj->obj.sphere.radius));
if (obj->type == O_PLANE)
return (inter_plane(&tmp_eye, &pvec));
if (obj->type == O_CONE)
return (inter_cone(obj, &tmp_eye, &pvec));
if (obj->type == O_CYLINDER)
return (inter_cylinder(obj, &tmp_eye, &pvec));
return (0);
}
int32 MoveSplineInit::Launch()
{
MoveSpline& move_spline = *unit.movespline;
Vector3 real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ());
// there is a big chane that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
{ real_position = move_spline.ComputePosition(); }
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// corrent first vertex
args.path[0] = real_position;
uint32 moveFlags = unit.m_movementInfo.GetMovementFlags();
if (args.flags.runmode)
{ moveFlags &= ~MOVEFLAG_WALK_MODE; }
else
{ moveFlags |= MOVEFLAG_WALK_MODE; }
moveFlags |= (MOVEFLAG_MOVE_FORWARD);
if (args.velocity == 0.f)
{ args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags)); }
if (!args.Validate(&unit))
{ return 0; }
unit.m_movementInfo.SetMovementFlags((MovementFlags)moveFlags);
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
PacketBuilder::WriteMonsterMove(move_spline, data);
unit.SendMessageToSet(&data, true);
return move_spline.Duration();
}
void MoveSplineInit::Stop()
{
MoveSpline& move_spline = *unit.movespline;
// No need to stop if we are not moving
if (move_spline.Finalized())
return;
Location real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ(), unit.GetOrientation());
// there is a big chance that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
real_position = move_spline.ComputePosition();
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// current first vertex
args.path[0] = real_position;
args.flags = MoveSplineFlag::Done;
unit.m_movementInfo.RemoveMovementFlag(MovementFlags(MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_SPLINE_ENABLED));
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
data << real_position.x << real_position.y << real_position.z;
data << move_spline.GetId();
data << uint8(MonsterMoveStop);
unit.SendMessageToSet(&data, true);
}
void MotionMaster::MovePointSmooth(float x, float y, float diffDist, bool vmapsOnly, Movement::MoveSplineInit * _init)
{
// Creature current(start) position
Movement::Location real_position(_owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZMinusOffset(), _owner->GetOrientation());
// Current position may differ if creature is moving
if (!_owner->movespline->Finalized())
real_position = _owner->movespline->ComputePosition();
Movement::MoveSplineInit init(_owner);
if (_init && _init->GetMasterUnit() == _owner)
init = *_init;
float dist = 5.f;
float angle = _owner->GetAngle(x, y);
float controllZ = _owner->GetPositionZ() + 5.f;
float _controllMinZ = controllZ;
float _controllMaxZ = controllZ;
float _x, _y, _z;
// Total travel distance based on real creature position
float dx = real_position.x - x;
float dy = real_position.y - y;;
// Dist between 2 last waypoints must be >= diffDist
float controllDist = sqrt(dx*dx + dy*dy) - diffDist;
// Fake waypoint for spline system
G3D::Vector3 fake_vertice(0.f, 0.f, 0.f);
init.Path().push_back(fake_vertice);
// Generate intermediate waypoints
while (dist < controllDist)
{
_x = real_position.x + dist * std::cos(angle);
_y = real_position.y + dist * std::sin(angle);
if (vmapsOnly)
_z = _owner->GetMap()->GetHeight(_x, _y, controllZ + diffDist);
else
_z = _owner->GetMap()->GetHeight(_owner->GetPhaseMask(), _x, _y, controllZ + diffDist);
dist += diffDist;
controllZ = _z;
if (controllZ > _controllMaxZ)
{
_controllMaxZ = controllZ;
_controllMinZ = controllZ;
}
else
{
if (_controllMaxZ - _controllMinZ > 250.f)
_controllMinZ = _controllMaxZ;
if (_controllMinZ - controllZ > diffDist * 2)
controllZ = _controllMinZ;
else
_controllMinZ = controllZ;
}
G3D::Vector3 vertice(_x, _y, _z);
init.Path().push_back(vertice);
}
// Add last waypoint
_x = x;
_y = y;
_z = _owner->GetMap()->GetHeight(_owner->GetPhaseMask(), _x, _y, controllZ, true);
G3D::Vector3 last_vertice(_x, _y, _z);
init.Path().push_back(last_vertice);
init.SetUncompressed();
init.Launch();
}
void * blobs2voxels_SimpleGrid( void * data )
{
ThreadBlobsToVoxels * thread_data = (ThreadBlobsToVoxels *) data;
const MultidimArray<double> *vol_blobs = thread_data->vol_blobs;
const SimpleGrid *grid = thread_data->grid;
const struct blobtype *blob = thread_data->blob;
MultidimArray<double> *vol_voxels = thread_data->vol_voxels;
const Matrix2D<double> *D = thread_data->D;
int istep = thread_data->istep;
MultidimArray<double> *vol_corr = thread_data->vol_corr;
const MultidimArray<double> *vol_mask = thread_data->vol_mask;
;
bool FORW = thread_data->FORW;
int eq_mode = thread_data->eq_mode;
int min_separation = thread_data->min_separation;
int z_planes = (int)(ZZ(grid->highest) - ZZ(grid->lowest) + 1);
Matrix2D<double> Dinv; // Inverse of D
Matrix1D<double> act_coord(3); // Coord: Actual position inside
// the voxel volume without deforming
Matrix1D<double> real_position(3); // Coord: actual position after
// applying the V transformation
Matrix1D<double> beginZ(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,YY(lowest),XX(lowest))
Matrix1D<double> beginY(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,y0,XX(lowest))
Matrix1D<double> corner2(3), corner1(3); // Coord: Corners of the
// blob in the voxel volume
Matrix1D<double> gcurrent(3); // Position in g of current point
MultidimArray<double> blob_table; // Something like a blobprint
// but with the values of the
// blob in space
double d; // Distance between the center
// of the blob and a voxel position
int id; // index inside the blob value
// table for tha blob value at
// a distance d
double intx, inty, intz; // Nearest integer voxel
int i, j, k; // Index within the blob volume
int process; // True if this blob has to be
// processed
double vol_correction=0; // Correction to apply to the
// volume when "projecting" back
SPEED_UP_temps012;
// Some aliases
#define x0 STARTINGX(*vol_voxels)
#define xF FINISHINGX(*vol_voxels)
#define y0 STARTINGY(*vol_voxels)
#define yF FINISHINGY(*vol_voxels)
#define z0 STARTINGZ(*vol_voxels)
#define zF FINISHINGZ(*vol_voxels)
#ifdef DEBUG
bool condition = !FORW;
if (condition)
{
(*vol_voxels)().printShape();
std::cout << std::endl;
std::cout << "x0= " << x0 << " xF= " << xF << std::endl;
std::cout << "y0= " << y0 << " yF= " << yF << std::endl;
std::cout << "z0= " << z0 << " zF= " << zF << std::endl;
std::cout << grid;
}
#endif
// Invert deformation matrix ............................................
if (D != NULL)
Dinv = D->inv();
// Compute a blob value table ...........................................
blob_table.resize((int)(blob->radius*istep + 1));
for (size_t i = 0; i < blob_table.xdim; i++)
{
A1D_ELEM(blob_table, i) = kaiser_value((double)i/istep, blob->radius, blob->alpha, blob->order);
#ifdef DEBUG_MORE
if (condition)
std::cout << "Blob (" << i << ") r=" << (double)i / istep <<
" val= " << A1D_ELEM(blob_table, i) << std::endl;
#endif
}
int assigned_slice;
do
{
assigned_slice = -1;
do
{
pthread_mutex_lock(&blobs_conv_mutex);
if( slices_processed == z_planes )
{
pthread_mutex_unlock(&blobs_conv_mutex);
return (void*)NULL;
}
for(int w = 0 ; w < z_planes ; w++ )
{
if( slices_status[w]==0 )
{
slices_status[w] = -1;
assigned_slice = w;
slices_processed++;
for( int in = (w-min_separation+1) ; in <= (w+min_separation-1 ) ; in ++ )
{
if( in != w )
{
if( ( in >= 0 ) && ( in < z_planes ))
{
if( slices_status[in] != -1 )
slices_status[in]++;
}
}
}
break;
}
}
pthread_mutex_unlock(&blobs_conv_mutex);
}
while( assigned_slice == -1);
// Convert the whole grid ...............................................
// Corner of the plane defined by Z. These coordinates are in the
// universal coord. system
Matrix1D<double> aux( grid->lowest );
k = (int)(assigned_slice + ZZ( grid->lowest ));
ZZ(aux) = k;
grid->grid2universe(aux, beginZ);
Matrix1D<double> grid_index(3);
// Corner of the row defined by Y
beginY = beginZ;
for (i = (int) YY(grid->lowest); i <= (int) YY(grid->highest); i++)
{
// First point in the row
act_coord = beginY;
for (j = (int) XX(grid->lowest); j <= (int) XX(grid->highest); j++)
{
VECTOR_R3(grid_index, j, i, k);
#ifdef DEBUG
if (condition)
{
printf("Dealing blob at (%d,%d,%d) = %f\n", j, i, k, A3D_ELEM(*vol_blobs, k, i, j));
std::cout << "Center of the blob "
<< act_coord.transpose() << std::endl;
}
#endif
// Place act_coord in its right place
if (D != NULL)
{
M3x3_BY_V3x1(real_position, *D, act_coord);
#ifdef DEBUG
if (condition)
std::cout << "Center of the blob moved to "
//ROB, the "moved" coordinates are in
// real_position not in act_coord
<< act_coord.transpose() << std::endl;
<< real_position.transpose() << std::endl;
#endif
// ROB This is OK if blob.radius is in Cartesian space as I
// think is the case
}
else
real_position = act_coord;
// These two corners are also real valued
process = true;
//ROB
//This is OK if blob.radius is in Cartesian space as I think is the case
V3_PLUS_CT(corner1, real_position, -blob->radius);
V3_PLUS_CT(corner2, real_position, blob->radius);
#ifdef DEFORM_BLOB_WHEN_IN_CRYSTAL
//ROB
//we do not need this, it is already in Cartesian space
//if (D!=NULL)
// box_enclosing(corner1,corner2, *D, corner1, corner2);
#endif
if (XX(corner1) >= xF)
process = false;
if (YY(corner1) >= yF)
process = false;
if (ZZ(corner1) >= zF)
process = false;
if (XX(corner2) <= x0)
process = false;
if (YY(corner2) <= y0)
process = false;
if (ZZ(corner2) <= z0)
process = false;
#ifdef DEBUG
if (!process && condition)
std::cout << " It is outside output volume\n";
#endif
if (!grid->is_interesting(real_position))
{
#ifdef DEBUG
if (process && condition)
std::cout << " It is not interesting\n";
#endif
process = false;
}
#ifdef DEBUG
if (condition)
{
std::cout << "Corner 1 for this point " << corner1.transpose() << std::endl;
std::cout << "Corner 2 for this point " << corner2.transpose() << std::endl;
}
#endif
if (process)
{
// Clip the corners to the volume borders
XX(corner1) = ROUND(CLIP(XX(corner1), x0, xF));
YY(corner1) = ROUND(CLIP(YY(corner1), y0, yF));
ZZ(corner1) = ROUND(CLIP(ZZ(corner1), z0, zF));
XX(corner2) = ROUND(CLIP(XX(corner2), x0, xF));
YY(corner2) = ROUND(CLIP(YY(corner2), y0, yF));
ZZ(corner2) = ROUND(CLIP(ZZ(corner2), z0, zF));
#ifdef DEBUG
if (condition)
{
std::cout << "Clipped and rounded Corner 1 " << corner1.transpose() << std::endl;
std::cout << "Clipped and rounded Corner 2 " << corner2.transpose() << std::endl;
}
#endif
if (!FORW)
switch (eq_mode)
{
case VARTK:
vol_correction = 0;
break;
case VMAXARTK:
vol_correction = -1e38;
break;
}
// Effectively convert
long N_eq;
N_eq = 0;
for (intz = ZZ(corner1); intz <= ZZ(corner2); intz++)
for (inty = YY(corner1); inty <= YY(corner2); inty++)
for (intx = XX(corner1); intx <= XX(corner2); intx++)
{
int iz = (int)intz, iy = (int)inty, ix = (int)intx;
if (vol_mask != NULL)
if (!A3D_ELEM(*vol_mask, iz, iy, ix))
continue;
// Compute distance to the center of the blob
VECTOR_R3(gcurrent, intx, inty, intz);
#ifdef DEFORM_BLOB_WHEN_IN_CRYSTAL
// ROB
//if (D!=NULL)
// M3x3_BY_V3x1(gcurrent,Dinv,gcurrent);
#endif
V3_MINUS_V3(gcurrent, real_position, gcurrent);
d = sqrt(XX(gcurrent) * XX(gcurrent) +
YY(gcurrent) * YY(gcurrent) +
ZZ(gcurrent) * ZZ(gcurrent));
if (d > blob->radius)
continue;
id = (int)(d * istep);
#ifdef DEBUG_MORE
if (condition)
{
std::cout << "At (" << intx << ","
<< inty << "," << intz << ") distance=" << d;
std::cout.flush();
}
#endif
// Add at that position the corresponding blob value
if (FORW)
{
A3D_ELEM(*vol_voxels, iz, iy, ix) +=
A3D_ELEM(*vol_blobs, k, i, j) *
A1D_ELEM(blob_table, id);
#ifdef DEBUG_MORE
if (condition)
{
std::cout << " adding " << A3D_ELEM(*vol_blobs, k, i, j)
<< " * " << A1D_ELEM(blob_table, id) << " = "
<< A3D_ELEM(*vol_blobs, k, i, j)*
A1D_ELEM(blob_table, id) << std::endl;
std::cout.flush();
}
#endif
if (vol_corr != NULL)
A3D_ELEM(*vol_corr, iz, iy, ix) +=
A1D_ELEM(blob_table, id) * A1D_ELEM(blob_table, id);
}
else
{
double contrib = A3D_ELEM(*vol_corr, iz, iy, ix) *
A1D_ELEM(blob_table, id);
switch (eq_mode)
{
case VARTK:
vol_correction += contrib;
N_eq++;
break;
case VMAXARTK:
if (contrib > vol_correction)
vol_correction = contrib;
break;
}
#ifdef DEBUG_MORE
if (condition)
{
std::cout << " adding " << A3D_ELEM(*vol_corr, iz, iy, ix)
<< " * " << A1D_ELEM(blob_table, id) << " = "
<< contrib << std::endl;
std::cout.flush();
}
#endif
}
}
if (N_eq == 0)
N_eq = 1;
if (!FORW)
{
A3D_ELEM(*vol_blobs, k, i, j) += vol_correction / N_eq;
#ifdef DEBUG_MORE
std::cout << " correction= " << vol_correction << std::endl
<< " Number of eqs= " << N_eq << std::endl
<< " Blob after correction= "
<< A3D_ELEM(*vol_blobs, k, i, j) << std::endl;
#endif
}
}
// Prepare for next iteration
XX(act_coord) = XX(act_coord) + grid->relative_size * (grid->basis)( 0, 0);
YY(act_coord) = YY(act_coord) + grid->relative_size * (grid->basis)( 1, 0);
ZZ(act_coord) = ZZ(act_coord) + grid->relative_size * (grid->basis)( 2, 0);
}
int32 MoveSplineInit::Launch()
{
float realSpeedRun = 0.0f;
MoveSpline& move_spline = *unit.movespline;
Transport* newTransport = NULL;
if (args.transportGuid)
newTransport = HashMapHolder<Transport>::Find(ObjectGuid(HIGHGUID_MO_TRANSPORT, args.transportGuid));
Vector3 real_position(unit.GetPositionX(), unit.GetPositionY(), unit.GetPositionZ());
// there is a big chance that current position is unknown if current state is not finalized, need compute it
// this also allows calculate spline position and update map position in much greater intervals
if (!move_spline.Finalized())
{
real_position = move_spline.ComputePosition();
Transport* oldTransport = NULL;
if (move_spline.GetTransportGuid())
oldTransport = HashMapHolder<Transport>::Find(ObjectGuid(HIGHGUID_MO_TRANSPORT, move_spline.GetTransportGuid()));
if (oldTransport)
oldTransport->CalculatePassengerPosition(real_position.x, real_position.y, real_position.z);
}
if (newTransport)
newTransport->CalculatePassengerOffset(real_position.x, real_position.y, real_position.z);
if (args.path.empty())
{
// should i do the things that user should do?
MoveTo(real_position);
}
// corrent first vertex
args.path[0] = real_position;
uint32 moveFlags = unit.m_movementInfo.GetMovementFlags();
uint32 oldMoveFlags = moveFlags;
if (args.flags.done)
{
args.flags = MoveSplineFlag::Done;
moveFlags &= ~(MOVEFLAG_SPLINE_ENABLED | MOVEFLAG_MASK_MOVING);
}
else
{
moveFlags |= (MOVEFLAG_SPLINE_ENABLED | MOVEFLAG_FORWARD);
if (args.flags.runmode)
moveFlags &= ~MOVEFLAG_WALK_MODE;
else
moveFlags |= MOVEFLAG_WALK_MODE;
}
if (newTransport)
moveFlags |= MOVEFLAG_ONTRANSPORT;
else
moveFlags &= ~MOVEFLAG_ONTRANSPORT;
if (args.velocity == 0.f)
realSpeedRun = args.velocity = unit.GetSpeed(SelectSpeedType(moveFlags));
else
realSpeedRun = unit.GetSpeed(MOVE_RUN);
if (!args.Validate(&unit))
return 0;
unit.m_movementInfo.SetMovementFlags((MovementFlags)moveFlags);
unit.clearUnitState(UNIT_STAT_CLIENT_ROOT);
move_spline.SetMovementOrigin(movementType);
move_spline.Initialize(args);
WorldPacket data(SMSG_MONSTER_MOVE, 64);
data << unit.GetPackGUID();
if (newTransport)
{
data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
data << newTransport->GetPackGUID();
}
if (unit.GetTransport() && unit.GetTransport() != newTransport)
unit.GetTransport()->RemovePassenger(&unit);
if (newTransport && unit.GetTransport() != newTransport)
newTransport->AddPassenger(&unit);
// Stop packet
if (args.flags.done)
{
data << real_position.x << real_position.y << real_position.z;
data << move_spline.GetId();
data << uint8(1); // MonsterMoveStop=1
}
else
move_spline.setLastPointSent(PacketBuilder::WriteMonsterMove(move_spline, data));
// Compress data or not ?
bool compress = false;
if (!args.flags.done && args.velocity > 4 * realSpeedRun)
compress = true;
else if ((data.wpos() + 2) > 0x10)
compress = true;
else if (unit.hasUnitState(UNIT_STAT_CLIENT_ROOT))
compress = true;
// Since packet size is stored with an uint8, packet size is limited for compressed packets
if ((data.wpos() + 2) > 0xFF)
compress = false;
MovementData mvtData(compress ? NULL : &unit);
// Nostalrius: client has a hardcoded limit to spline movement speed : 4*runSpeed.
// We need to fix this, in case of charges for example (if character has movement slowing effects)
if (args.velocity > 4 * realSpeedRun && !args.flags.done) // From client
mvtData.SetUnitSpeed(SMSG_SPLINE_SET_RUN_SPEED, unit.GetObjectGuid(), args.velocity);
if (unit.hasUnitState(UNIT_STAT_CLIENT_ROOT))
mvtData.SetSplineOpcode(SMSG_SPLINE_MOVE_UNROOT, unit.GetObjectGuid());
if (oldMoveFlags & MOVEFLAG_WALK_MODE && !(moveFlags & MOVEFLAG_WALK_MODE)) // Switch to run mode
mvtData.SetSplineOpcode(SMSG_SPLINE_MOVE_SET_RUN_MODE, unit.GetObjectGuid());
if (moveFlags & MOVEFLAG_WALK_MODE && !(oldMoveFlags & MOVEFLAG_WALK_MODE)) // Switch to walk mode
mvtData.SetSplineOpcode(SMSG_SPLINE_MOVE_SET_WALK_MODE, unit.GetObjectGuid());
mvtData.AddPacket(data);
// Do not forget to restore velocity after movement !
if (args.velocity > 4 * realSpeedRun && !args.flags.done)
mvtData.SetUnitSpeed(SMSG_SPLINE_SET_RUN_SPEED, unit.GetObjectGuid(), realSpeedRun);
// Restore correct walk mode for players
if (unit.GetTypeId() == TYPEID_PLAYER && (moveFlags & MOVEFLAG_WALK_MODE) != (oldMoveFlags & MOVEFLAG_WALK_MODE))
mvtData.SetSplineOpcode(oldMoveFlags & MOVEFLAG_WALK_MODE ? SMSG_SPLINE_MOVE_SET_WALK_MODE : SMSG_SPLINE_MOVE_SET_RUN_MODE, unit.GetObjectGuid());
if (compress)
{
WorldPacket data2;
mvtData.BuildPacket(data2);
unit.SendMovementMessageToSet(std::move(data2), true);
}
return move_spline.Duration();
}
