ApartmentGrid::ApartmentGrid (int idBuilding,
int type,
int nbFloors,
double side_X,
double side_Y,
double center_X,
double center_Y)
{
SetIdBuilding(idBuilding);
SetBuildingType(TYPE_3GPP_5x5_grid);
SetFloors(nbFloors);
double* side = new double[2];
side [0] = side_X;
side [1] = side_Y;
SetSide(side);
CartesianCoordinates *Position = new CartesianCoordinates(center_X,center_Y);
SetCenterPosition(Position);
std::vector<Femtocell*>* femtoCellsInBuilding = new std::vector<Femtocell*>;
SetFemtoCellsInBuilding(femtoCellsInBuilding);
}
/*!
*
* @param lookAtVec
* @param upVec
*/
Camera::Camera(glm::vec3 positionVec, glm::vec3 lookAtVec, glm::vec3 upVec)
{
m_initPos = positionVec;
m_position = positionVec;
m_initLookAt = lookAtVec;
m_lookAt = lookAtVec;
m_initUp = upVec;
m_up = upVec;
m_lookVec = m_initLookAt - m_initPos;
m_initSide = glm::cross(m_lookVec, m_initUp);
m_side = glm::cross(m_lookVec, m_initUp);
SetSide(m_side);
SetUp(m_up);
SetLookAt(m_lookAt);
SetPosition(m_position);
m_fieldOfView = 60.0f;
m_width = Singleton<Context>::Instance()->GetWidth();
m_height = Singleton<Context>::Instance()->GetHeight();
m_aspect = static_cast<float>(m_width) / static_cast<float>(m_height);
m_nearPlane = 0.1f;
m_farPlane = 200.f;
m_viewMatrix = glm::lookAt(m_position, m_lookAt, m_up);
m_inverseViewMatrix = glm::inverse(m_viewMatrix);
m_projectionMatrix = glm::perspective(m_fieldOfView, m_aspect, m_nearPlane, m_farPlane);
m_isOrtho = false;
m_speed = 0.05;
}
/*!
*
*/
Camera::Camera()
{
m_position = glm::vec3(0.0, 0.0, 1.0);
m_lookAt = glm::vec3(0.0, 0.0, 0.0);
m_up = glm::vec3(0.0, 1.0, 0.0);
m_side = glm::vec3(1.0, 0.0, 0.0);
SetSide(m_side);
SetUp(m_up);
SetLookAt(m_lookAt);
SetPosition(m_position);
m_fieldOfView = 60.0f;
m_width = Singleton<Context>::Instance()->GetWidth();
m_height = Singleton<Context>::Instance()->GetHeight();
m_aspect = static_cast<float>(m_width) / static_cast<float>(m_height);
m_nearPlane = 0.1f;
m_farPlane = 200.0f;
m_viewMatrix = glm::lookAt(m_position, m_lookAt, m_up);
m_inverseViewMatrix = glm::inverse(m_viewMatrix);
m_projectionMatrix = glm::perspective(m_fieldOfView, m_aspect, m_nearPlane, m_farPlane);
m_isOrtho = false;
m_speed = 0.05;
}
Femtocell::Femtocell(int idCell,
double side,
double X,
double Y)
{
SetIdCell(idCell);
SetSide(side);
SetMinDistance(0.0);
CartesianCoordinates *Position = new CartesianCoordinates(X,Y);
SetCellCenterPosition(Position);
}
/************************************************************************************************
* CRMBSPInstance::Spawn
* spawns a bsp into the world using the previously aquired origin
*
* inputs:
* none
*
* return:
* none
*
************************************************************************************************/
bool CRMBSPInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer)
{
#ifndef PRE_RELEASE_DEMO
// TEntity* ent;
float yaw;
char temp[10000];
char *savePtr;
vec3_t origin;
vec3_t notmirrored;
float water_level = terrain->GetLandScape()->GetWaterHeight();
const vec3_t& terxelSize = terrain->GetLandScape()->GetTerxelSize ( );
const vec3pair_t& bounds = terrain->GetLandScape()->GetBounds();
// If this entity somehow lost its collision flag then boot it
if ( !GetArea().IsCollisionEnabled ( ) )
{
return false;
}
// copy out the unmirrored version
VectorCopy(GetOrigin(), notmirrored);
// we want to mirror it before determining the Z value just in case the landscape isn't perfectly mirrored
if (mMirror)
{
GetOrigin()[0] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][0] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - GetOrigin()[0];
GetOrigin()[1] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][1] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][1] - GetOrigin()[1];
}
// Align the instance to the center of a terxel
GetOrigin ( )[0] = bounds[0][0] + (int)((GetOrigin ( )[0] - bounds[0][0] + terxelSize[0] / 2) / terxelSize[0]) * terxelSize[0];
GetOrigin ( )[1] = bounds[0][1] + (int)((GetOrigin ( )[1] - bounds[0][1] + terxelSize[1] / 2) / terxelSize[1]) * terxelSize[1];
// Make sure the bsp is resting on the ground, not below or above it
// NOTE: This check is basically saying "is this instance not a bridge", because when instances are created they are all
// placed above the world's Z boundary, EXCEPT FOR BRIDGES. So this call to GetWorldHeight will move all other instances down to
// ground level except bridges
if ( GetOrigin()[2] > terrain->GetBounds()[1][2] )
{
if( GetFlattenRadius() )
{
terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), false );
GetOrigin()[2] += 5;
}
else if (IsServer)
{ // if this instance does not flatten the ground around it, do a trace to more accurately determine its Z value
trace_t tr;
vec3_t end;
vec3_t start;
VectorCopy(GetOrigin(), end);
VectorCopy(GetOrigin(), start);
// start the trace below the top height of the landscape
start[2] = TheRandomMissionManager->GetLandScape()->GetBounds()[1][2] - 1;
// end the trace at the bottom of the world
end[2] = MIN_WORLD_COORD;
memset ( &tr, 0, sizeof ( tr ) );
SV_Trace( &tr, start, vec3_origin, vec3_origin, end, ENTITYNUM_NONE, CONTENTS_TERRAIN|CONTENTS_SOLID, G2_NOCOLLIDE, 0); //qfalse, 0, 10 );
if( !(tr.contents & CONTENTS_TERRAIN) || (tr.fraction == 1.0) )
{
if ( 0 )
assert(0); // this should never happen
// restore the unmirrored origin
VectorCopy( notmirrored, GetOrigin() );
// don't spawn
return false;
}
// assign the Z-value to wherever it hit the terrain
GetOrigin()[2] = tr.endpos[2];
// lower it a little, otherwise the bottom of the instance might be exposed if on some weird sloped terrain
GetOrigin()[2] -= 16; // FIXME: would it be better to use a number related to the instance itself like 1/5 it's height or something...
}
}
else
{
terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), true );
}
// save away the origin
VectorCopy(GetOrigin(), origin);
// make sure not to spawn if in water
if (!HasObjective() && GetOrigin()[2] < water_level)
return false;
// restore the origin
VectorCopy(origin, GetOrigin());
if (mMirror)
{ // change blue things to red for symmetric maps
if (strlen(mFilter) > 0)
{
char * blue = strstr(mFilter,"blue");
if (blue)
{
blue[0] = (char) 0;
strcat(mFilter, "red");
SetSide(SIDE_RED);
}
}
if (strlen(mTeamFilter) > 0)
{
char * blue = strstr(mTeamFilter,"blue");
if (blue)
{
strcpy(mTeamFilter, "red");
SetSide(SIDE_RED);
}
}
yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle) + 180;
}
else
{
yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle);
}
/*
if( TheRandomMissionManager->GetMission()->GetSymmetric() )
{
vec3_t diagonal;
vec3_t lineToPoint;
vec3_t mins;
vec3_t maxs;
vec3_t point;
vec3_t vProj;
vec3_t vec;
float distance;
VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[1], maxs );
VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[0], mins );
VectorCopy( GetOrigin(), point );
mins[2] = maxs[2] = point[2] = 0;
VectorSubtract( point, mins, lineToPoint );
VectorSubtract( maxs, mins, diagonal);
VectorNormalize(diagonal);
VectorMA( mins, DotProduct(lineToPoint, diagonal), diagonal, vProj);
VectorSubtract(point, vProj, vec );
distance = VectorLength(vec);
// if an instance is too close to the imaginary diagonal that cuts the world in half, don't spawn it
// otherwise you can get overlapping instances
if( distance < GetSpacingRadius() )
{
#ifdef _DEBUG
mAutomapSymbol = AUTOMAP_END;
#endif
if( !HasObjective() )
{
return false;
}
}
}
*/
// Spawn in the bsp model
sprintf(temp,
"{\n"
"\"classname\" \"misc_bsp\"\n"
"\"bspmodel\" \"%s\"\n"
"\"origin\" \"%f %f %f\"\n"
"\"angles\" \"0 %f 0\"\n"
"\"filter\" \"%s\"\n"
"\"teamfilter\" \"%s\"\n"
"\"spacing\" \"%d\"\n"
"\"flatten\" \"%d\"\n"
"}\n",
mBsp,
GetOrigin()[0], GetOrigin()[1], GetOrigin()[2],
AngleNormalize360(yaw),
mFilter,
mTeamFilter,
(int)GetSpacingRadius(),
(int)GetFlattenRadius()
);
if (IsServer)
{ // only allow for true spawning on the server
savePtr = sv.entityParsePoint;
sv.entityParsePoint = temp;
// VM_Call( cgvm, GAME_SPAWN_RMG_ENTITY );
// char *s;
int bufferSize = 1024;
char buffer[1024];
// s = COM_Parse( (const char **)&sv.entityParsePoint );
Q_strncpyz( buffer, sv.entityParsePoint, bufferSize );
if ( sv.entityParsePoint && sv.entityParsePoint[0] )
{
ge->GameSpawnRMGEntity(sv.entityParsePoint);
}
sv.entityParsePoint = savePtr;
}
#ifndef DEDICATED
DrawAutomapSymbol();
#endif
Com_DPrintf( "RMG: Building '%s' spawned at (%f %f %f)\n", mBsp, GetOrigin()[0], GetOrigin()[1], GetOrigin()[2] );
// now restore the instances un-mirrored origin
// NOTE: all this origin flipping, setting the side etc... should be done when mMirror is set
// because right after this function is called, mMirror is set to 0 but all the instance data is STILL MIRRORED -- not good
VectorCopy(notmirrored, GetOrigin());
#endif // PRE_RELEASE_DEMO
return true;
}
HRESULT CmineIGC::Initialize(ImissionIGC* pMission, Time now, const void* data, int dataSize)
{
ZRetailAssert (data && (dataSize > sizeof(DataMineBase)));
{
DataMineBase* dataMineBase = (DataMineBase*)data;
if ((dataMineBase->exportF) &&
((DataMineExport*)dataMineBase)->createNow)
{
m_time0 = now;
}
else
{
m_time0 = pMission->GetIgcSite()->ClientTimeFromServerTime(dataMineBase->time0);
}
TmodelIGC<ImineIGC>::Initialize(pMission, now, data, dataSize);
IshipIGC* pshipLauncher;
IclusterIGC* pcluster;
DataMineTypeIGC* dataMineType;
if (dataMineBase->exportF)
{
assert (dataSize >= sizeof(DataMineExport));
DataMineExport* dataMineExport = (DataMineExport*)dataMineBase;
m_mineType = (ImineTypeIGC*)(pMission->GetExpendableType(dataMineExport->minetypeID));
assert (m_mineType);
assert (m_mineType->GetObjectType() == OT_mineType);
pcluster = pMission->GetCluster(dataMineExport->clusterID);
assert (m_mineType);
dataMineType = (DataMineTypeIGC*)(m_mineType->GetData());
pshipLauncher = pMission->GetShip(dataMineExport->launcherID);
SetSide(pMission->GetSide(dataMineExport->sideID));
m_fraction = dataMineExport->fraction;
}
else
{
assert (dataSize == sizeof(DataMineIGC));
DataMineIGC* dataMine = (DataMineIGC*)dataMineBase;
m_mineType = dataMine->pminetype;
pcluster = dataMine->pcluster;
assert (m_mineType);
assert (m_mineType->GetObjectType() == OT_mineType);
dataMineType = (DataMineTypeIGC*)(m_mineType->GetData());
pshipLauncher = dataMine->pshipLauncher;
SetSide(dataMine->psideLauncher);
m_fraction = 1.0f;
}
if (pshipLauncher && (dataMineType->launcherDef.price == 0))
{
m_launcher = pshipLauncher;
m_launcher->AddRef();
}
assert (GetSide());
assert (pcluster);
m_mineType->AddRef();
//Load the model for the mine
LoadMine(dataMineType->textureName, 1.0f, dataMineType->radius, dataMineType->iconName,
c_mtSeenBySide | c_mtPredictable | c_mtHitable | c_mtStatic);
SetRadius(dataMineType->radius);
SetSignature(dataMineType->signature);
SetSecondaryName(dataMineType->launcherDef.name);
{
//lifespan == 0 => immortal mine that can hit until it gets terminated on the next update; this is bad
assert (dataMineType->lifespan > 0.0f);
m_timeExpire = m_time0 + dataMineType->lifespan;
assert (m_timeExpire != m_time0);
}
SetMass(0.0f);
m_mineID = dataMineBase->mineID;
SetPosition(dataMineBase->p0);
SetCluster(pcluster);
pMission->AddMine(this);
}
return S_OK;
}
HRESULT CprobeIGC::Initialize(ImissionIGC* pMission, Time now, const void* data, int dataSize)
{
assert (pMission);
m_pMission = pMission;
ZRetailAssert (data && (dataSize > sizeof(DataProbeBase)));
{
DataProbeBase* dataProbeBase = (DataProbeBase*)data;
if ((dataProbeBase->exportF) &&
((DataProbeExport*)dataProbeBase)->createNow)
{
m_time0 = now;
}
else
{
m_time0 = pMission->GetIgcSite()->ClientTimeFromServerTime(dataProbeBase->time0);
}
TmodelIGC<IprobeIGC>::Initialize(pMission, now, data, dataSize);
IshipIGC* pshipLauncher;
IsideIGC* pside;
IclusterIGC* pcluster;
if (dataProbeBase->exportF)
{
assert (dataSize == sizeof(DataProbeExport));
DataProbeExport* dataProbeExport = (DataProbeExport*)dataProbeBase;
m_probeType = (IprobeTypeIGC*)(pMission->GetExpendableType(dataProbeExport->probetypeID));
pside = pMission->GetSide(dataProbeExport->sideID);
pcluster = pMission->GetCluster(dataProbeExport->clusterID);
pshipLauncher = pside->GetShip(dataProbeExport->shipID);
if (m_probeType->HasCapability(c_eabmShootOnlyTarget))
m_target = pMission->GetModel(dataProbeExport->otTarget, dataProbeExport->oidTarget);
}
else
{
assert (dataSize == sizeof(DataProbeIGC));
DataProbeIGC* dataProbe = (DataProbeIGC*)dataProbeBase;
m_probeType = dataProbe->pprobetype;
pside = dataProbe->pside;
pcluster = dataProbe->pcluster;
pshipLauncher = dataProbe->pship;
if (m_probeType->HasCapability(c_eabmShootOnlyTarget))
m_target = dataProbe->pmodelTarget;
}
assert (m_probeType);
assert (m_probeType->GetObjectType() == OT_probeType);
m_probeType->AddRef();
m_ammo = m_probeType->GetAmmo();
DataProbeTypeIGC* dataProbeType = (DataProbeTypeIGC*)(m_probeType->GetData());
m_projectileType = m_probeType->GetProjectileType();
if (m_projectileType)
{
m_projectileType->AddRef();
m_bSeenByAll = false;
if (pshipLauncher && (dataProbeType->launcherDef.price == 0))
m_launcher = pshipLauncher;
}
assert (pcluster);
//Load the model for the probe
assert (iswalpha(dataProbeType->modelName[0]));
HRESULT hr = Load(0, dataProbeType->modelName,
dataProbeType->textureName,
dataProbeType->iconName,
c_mtDamagable | c_mtHitable | c_mtStatic | c_mtSeenBySide | c_mtPredictable | c_mtScanner);
assert (SUCCEEDED(hr));
SetRadius(dataProbeType->radius);
SetSignature(dataProbeType->signature);
SetSide(pside);
SetSecondaryName(dataProbeType->launcherDef.name);
{
//Parts get a random orientation
Vector v = Vector::RandomDirection();
Orientation o(v);
SetOrientation(o);
}
//lifespan == 0 => immortal probe that can hit until it gets terminated on the next update; this is bad
assert (dataProbeType->lifespan > 0.0f);
m_timeExpire = m_time0 + dataProbeType->lifespan;
assert (m_timeExpire != m_time0);
m_nextFire = m_time0 + (m_probeType->HasCapability(c_eabmQuickReady)
? 5.0f //5 second delay
: 30.0f); //30 second delay before we start to shoot
assert (GetSide());
SetMass(0.0f);
m_probeID = dataProbeBase->probeID;
SetPosition(dataProbeBase->p0);
SetCluster(pcluster);
pMission->AddProbe(this);
if ((dataProbeType->dtRipcord >= 0.0f) && ((GetMyLastUpdate() - m_time0) >= dataProbeType->dtRipcord))
{
pMission->GetIgcSite()->ActivateTeleportProbe(this);
}
// mmf 04/08 destroy any probe near aleph (warp) tip as this is viewed as an exploit as the enemy
// often cannot delete it
//
// if (experimental game type) mmf
const MissionParams* pmp = pMission->GetMissionParams();
if (pmp->bExperimental) {
Vector dV, probeV, warpV, tipdistV;
Vector bV, tipV;
float warp_rad, distance;
Orientation warp_orient;
Rotation warp_rot;
// loop through list of warps
for (WarpLinkIGC* pwl = pcluster->GetWarps()->first(); (pwl != NULL); pwl = pwl->next())
{
IwarpIGC* pwarp = pwl->data();
warp_rad = pwarp->GetRadius();
warp_orient = pwarp->GetOrientation();
warpV = pwarp->GetPosition();
probeV = this->GetPosition();
dV= warpV-probeV;
distance = dV.Length();
warp_rot = pwarp->GetRotation();
// if rotating (i.e. rotation is other than 0 0 1 0) abort check
if (!((warp_rot.x()==0) && (warp_rot.y()==0) && (warp_rot.z()==1) && (warp_rot.angle()==0)))
break;
if (distance < (warp_rad * 2) ) { // only check if close to tip if reasonably close to warp center
bV = warp_orient.GetBackward();
tipV = warpV + (bV*warp_rad);
tipdistV = tipV-probeV;
distance = tipdistV.Length();
if (distance < 30) {
debugf("Destroying probe as it was dropped too close (within 30) of aleph(warp) tip. dist = $f\n",distance);
return S_FALSE; // this will destroy the probe
}
}
}
}
// mmf end
// mmf added code to detect tp drop near asteroid and if too close destroy it
// leave ActivateTeleProbe code above so enemy is alerted to the drop even though it may be destroyed
if (dataProbeType->dtRipcord >= 0.0f) // check to see if this is a teleprobe
{
Vector dV;
float asteroid_rad, distance;
// loop through list of asteroids
for (AsteroidLinkIGC* pal = pcluster->GetAsteroids()->first(); (pal != NULL); pal = pal->next())
{
asteroid_rad = (pal->data()->GetRadius());
dV=this->GetPosition() - pal->data()->GetPosition();
distance = dV.Length();
if (distance < (asteroid_rad-5)) {
debugf("Teleprobe dropped too close to asteroid (within -5) destroying probe. dist = %f, asteroid rad = %f\n",
distance,asteroid_rad);
// this->Terminate(); should be terminated when missionigc processes S_FALSE
return S_FALSE;
}
}
}
// mmf end
}
return S_OK;
}
