void StationPlayersCollector::handleSPCharacterShipData(const GameNetworkMessage & message)
{
DEBUG_FATAL( !getImpl(), ("StationPlayersCollector implementation not set"));
getImpl()->handleSPCharacterShipData(message);
}
void AffectorRoad::affect (const float worldX, const float worldZ, const int x, const int z, const float amount, const TerrainGenerator::GeneratorChunkData& generatorChunkData) const
{
if (generatorChunkData.m_legacyRandomGenerator)
{
_legacyAffect(worldX, worldZ, x, z, amount, generatorChunkData);
return;
}
if (!isEnabled ())
return;
if (amount > 0.f)
{
if (m_extent.isWithin (worldX, worldZ))
{
const float width_2 = m_width * 0.5f;
const float originalHeight = generatorChunkData.heightMap->getData (x, z);
FindData result;
if (find (Vector2d (worldX, worldZ), width_2, result))
{
const float distanceToCenter = fabsf (result.distanceToCenter);
const float desiredHeight = result.height;
if (WithinRangeInclusiveInclusive (0.f, distanceToCenter, width_2 * (1.f - getFeatherDistance ())))
{
if(!m_hasFixedHeights)
{
generatorChunkData.heightMap->setData (x, z, desiredHeight);
}
else
{
// ramped road affector using fixed heights
generatorChunkData.heightMap->setData (x,z, getRampedHeight(worldX,worldZ,originalHeight));
}
//-- clear the flora
generatorChunkData.floraStaticCollidableMap->setData (x, z, generatorChunkData.floraGroup->getDefaultFlora ());
generatorChunkData.floraStaticNonCollidableMap->setData (x, z, generatorChunkData.floraGroup->getDefaultFlora ());
generatorChunkData.floraDynamicNearMap->setData (x, z, generatorChunkData.radialGroup->getDefaultRadial ());
generatorChunkData.floraDynamicFarMap->setData (x, z, generatorChunkData.radialGroup->getDefaultRadial ());
}
else
{
//-- height
const float t = distanceToCenter / width_2;
DEBUG_FATAL (t < 0.f || t > 1.f, ("t is out of range"));
if(!m_hasFixedHeights)
{
generatorChunkData.heightMap->setData (x, z, linearInterpolate (desiredHeight, originalHeight, t));
}
else
{
// ramped road affector using fixed heights
generatorChunkData.heightMap->setData (x, z, getRampedHeight(worldX,worldZ,originalHeight));
}
}
if (WithinRangeInclusiveInclusive (0.f, distanceToCenter, width_2 * (1.f - getFeatherDistanceShader ())))
{
//-- set the shader
if (m_cachedFamilyId != m_familyId)
{
m_cachedFamilyId = m_familyId;
m_cachedSgi = generatorChunkData.shaderGroup->chooseShader (m_familyId);
}
FastRandomGenerator randomGenerator(CoordinateHash::hashTuple(worldX, worldZ));
ShaderGroup::Info sgi = m_cachedSgi;
sgi.setChildChoice (randomGenerator.randomFloat());
generatorChunkData.shaderMap->setData (x, z, sgi);
}
}
}
}
}
void StationPlayersCollector::ackSPCharacterRankingData()
{
DEBUG_FATAL( !getImpl(), ("StationPlayersCollector implementation not set"));
getImpl()->ackSPCharacterRankingData();
}
//======================================================================
// game server generic/global commincation methods
//======================================================================
void StationPlayersCollector::sendToCentralServer(const uint32 serverId, const GameNetworkMessage & message, const bool reliable)
{
DEBUG_FATAL( !getImpl(), ("StationPlayersCollector implementation not set"));
getImpl()->sendToCentralServer(serverId, message, reliable);
}
int ServerManufactureSchematicObjectTemplate::getItemCountMax(bool testData) const
{
#ifdef _DEBUG
int testDataValue = 0;
#else
UNREF(testData);
#endif
const ServerManufactureSchematicObjectTemplate * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerManufactureSchematicObjectTemplate *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getItemCountMax(true);
#endif
}
if (!m_itemCount.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter itemCount in template %s", DataResource::getName()));
return 0;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter itemCount has not been defined in template %s!", DataResource::getName()));
return base->getItemCountMax();
}
}
int value = m_itemCount.getMaxValue();
char delta = m_itemCount.getDeltaType();
if (delta == '+' || delta == '-' || delta == '_' || delta == '=')
{
int baseValue = 0;
if (m_baseData != NULL)
{
if (base != NULL)
baseValue = base->getItemCountMax();
else if (ms_allowDefaultTemplateParams)
DEBUG_WARNING(true, ("No base template for delta, using 0"));
else
NOT_NULL(base);
}
if (delta == '+')
value = baseValue + value;
else if (delta == '-')
value = baseValue - value;
else if (delta == '=')
value = baseValue + static_cast<int>(baseValue * (value / 100.0f));
else if (delta == '_')
value = baseValue - static_cast<int>(baseValue * (value / 100.0f));
}
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerManufactureSchematicObjectTemplate::getItemCountMax
void SetupSharedUtility::remove ()
{
DEBUG_FATAL (!ms_installed, ("SetupSharedUtility::remove not installed"));
ms_installed = false;
}
void CharacterCreationTracker::remove()
{
DEBUG_FATAL(!ms_instance,("Not installed.\n"));
delete ms_instance;
ms_instance = 0;
}
int Scenegraph::renderFrame(float delta)
{
static int mouse_button = 0;
static int mouse_x, mouse_y;
ScenegraphCamera *c;
EGLX11EVENT event;
GFXDEBUG_RESET();
#ifdef _DEBUG
float t1, t2;
t1 = getSystemtime();
#endif
DEBUG_INFO("Scenegraph render delta=%f\n", delta);
if (cameras.find(currentcamera) == cameras.end())
{
DEBUG_NOTIFICATION("No camera defined. Aborting!\n");
return -1;
}
c = cameras[currentcamera];
#ifdef _DEBUG
t2 = getSystemtime();
DEBUG_INFO("Profile: cameras.find %f seconds\n", t2-t1);
t1 = t2;
#endif
while (display->eventPump(&event))
{
switch (event.event)
{
case EVENT_KEYEVENT:
DEBUG_FATAL("Keypress detected, key %c (%d 0x%x)\n",
event.u.keyEvent.key,
event.u.keyEvent.key,
event.u.keyEvent.key);
switch(event.u.keyEvent.key)
{
case 'w':
c->setCameraPositionDelta(0.0f, 0.0f, -CAMERA_DELTA);
break;
case 'a':
c->setCameraPositionDelta(-CAMERA_DELTA, 0.0f, 0.0f);
break;
case 's':
c->setCameraPositionDelta(0.0f, 0.0f, CAMERA_DELTA);
break;
case 'd':
c->setCameraPositionDelta(CAMERA_DELTA, 0.0f, 0.0f);
break;
case 'r':
c->setCameraPositionDelta(0.0f, CAMERA_DELTA, 0.0f);
break;
case 'f':
c->setCameraPositionDelta(0.0f, -CAMERA_DELTA, 0.0f);
break;
case 'z':
c->setCameraRotationDelta(0.0f, -0.05f, 0.0f);
break;
case 'x':
c->setCameraRotationDelta(0.0f, -0.05f, 0.0f);
break;
case 27:
DEBUG_NOTIFICATION("Escape pressed. Aborting\n");
return -1;
}
#if 1
{
float x, y, z;
c->getCameraPosition(&x, &y, &z);
DEBUG_FATAL("Current camera pos: %f %f %f\n", x, y, z);
c->getCameraRotation(&x, &y, &z);
DEBUG_FATAL("Current camera rot: %f %f %f\n", x/3.1415f*180.0f, y/3.1415f*180.0f, z/3.1415f*180.0f);
}
#endif
break;
case EVENT_MOUSEBUTTONEVENT:
DEBUG_FATAL("Mouse button event, status %d, button id %d\n", event.u.mouseButtonEvent.status, event.u.mouseButtonEvent.button);
if (event.u.mouseButtonEvent.button == 3 && event.u.mouseButtonEvent.status == true)
{
mouse_button = 1;
mouse_x = event.u.mouseButtonEvent.x;
mouse_y = event.u.mouseButtonEvent.y;
}
else mouse_button = 0;
break;
case EVENT_MOUSEMOTIONEVENT:
if (mouse_button == 0) break;
//DEBUG_FATAL("Mouse motion X %d Y %d - delta X %d Y %d\n", event.u.mouseMotionEvent.x, event.u.mouseMotionEvent.y,
// event.u.mouseMotionEvent.x-mouse_x, event.u.mouseMotionEvent.y-mouse_y);
c->setCameraRotationDelta(0.0f, (GLfloat)(event.u.mouseMotionEvent.x-mouse_x)*3.1415f/180.0f, (GLfloat)(event.u.mouseMotionEvent.y-mouse_y)*3.1415f/180.0f);
mouse_x = event.u.mouseMotionEvent.x;
mouse_y = event.u.mouseMotionEvent.y;
break;
case EVENT_QUIT:
DEBUG_FATAL("System quit signal received.\n");
return -1;
default:
break;
}
}
#ifdef _DEBUG
t2 = getSystemtime();
DEBUG_INFO("Profile: event pump %f seconds\n", t2-t1);
t1 = t2;
#endif
c->applyProjectionMatrix();
GLMath::Instance()->_glMatrixMode(_GL_MATRIXMODE_MODELVIEW);
GLMath::Instance()->_glLoadIdentity();
#ifdef _DEBUG
GLMath::Instance()->_glDebugMatrix(_GL_MATRIXMODE_PROJECTION);
GLMath::Instance()->_glDebugMatrix(_GL_MATRIXMODE_MODELVIEW);
t2 = getSystemtime();
DEBUG_INFO("Profile: matrix formations %f seconds\n", t2-t1);
t1 = t2;
#endif
GLWrapper::Instance()->GLCLEAR(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
#ifdef _DEBUG
t2 = getSystemtime();
DEBUG_INFO("Profile: glClear %f seconds\n", t2-t1);
t1 = t2;
#endif
int total = 0, rendered = 0;
#if 1
float rot_x, rot_y, rot_z;
float cpx, cpy, cpz;
float cx, cy, cz;
c->getCameraRotation(&rot_x, &rot_y, &rot_z);
c->getCameraPosition(&cpx, &cpy, &cpz);
cx = sin(rot_y); cy=0.0f; cz=cos(rot_y);
//printf("camera rot %f %f %f, pos %f %f %f, view %f %f %f\n", rot_x, rot_y, rot_z, cpx, cpy, cpz, cx, cy, cz);
#endif
std::map <int, ScenegraphObject *>::iterator it = objects.begin();
for (it = objects.begin(); it != objects.end(); it++)
{
DEBUG_INFO("Rendering object %d\n", (*it).first);
#if 1
float x, y, z, l, dot;
(*it).second->getPosition(&x, &y, &z);
x = x-cpx; y = y-cpy; z = z-cpz;
l = sqrt(x*x + y*y + z*z);
x /= l; y /= l; z /= l;
dot = x*cx+y*cy+z*cz;
//printf("obj direction %f %f %f, dot camera %f\n", x, y, z, dot);
#endif
(*it).second->isVisible();
if (dot < -0.707f)
{
GLMath::Instance()->_glPushMatrix();
(*it).second->render(delta);
GLMath::Instance()->_glPopMatrix();
rendered++;
}
else
{
}
total++;
#ifdef _DEBUG
t2 = getSystemtime();
DEBUG_INFO("Profile: object render %f seconds\n", t2-t1);
t1 = t2;
#endif
}
DEBUG_INFO("culling Total objects per frame %d, rendered %d, hence %02.1f%% coverage\n", total, rendered, (float)100.0f*rendered/total);
return 0;
}
bool ProcessSpawner::getOutputString(char *buffer, int bufferSize)
{
if (_returnExistingLine(buffer, bufferSize))
{
return true;
}
// ----------------------------------------------
if (!hOutputRead)
{
return false;
}
DWORD dwAvail = 0;
if (!::PeekNamedPipe(hOutputRead, NULL, 0, NULL, &dwAvail, NULL))
{
// ERROR
return false;
}
if (!dwAvail)
{
return false;
}
DWORD dwRead;
if (currentRead >= currentLine)
{
const unsigned bufferAvailable = sizeof(readBuffer) - (currentRead - readBuffer);
unsigned toRead = dwAvail;
if (toRead > bufferAvailable)
{
toRead=bufferAvailable;
}
dwRead=0;
if (!::ReadFile(hOutputRead, currentRead, min(bufferAvailable, dwAvail), &dwRead, NULL) || !dwRead)
{
return false;
}
dwAvail-=dwRead;
currentRead+=dwRead;
if (currentRead==readBuffer+sizeof(readBuffer))
{
currentRead=readBuffer;
}
}
if (dwAvail>0)
{
const unsigned bufferAvailable = currentLine - currentRead - 1;
if (bufferAvailable)
{
unsigned toRead = dwAvail;
if (toRead > bufferAvailable)
{
toRead=bufferAvailable;
}
dwRead=0;
if (!::ReadFile(hOutputRead, currentRead, min(bufferAvailable, dwAvail), &dwRead, NULL) || !dwRead)
{
return false;
}
currentRead+=dwRead;
DEBUG_FATAL(currentRead>=currentLine, (""));
}
}
return _returnExistingLine(buffer, bufferSize);
}
void CharacterCreationTracker::install()
{
DEBUG_FATAL(ms_instance != NULL,("Called install() twice.\n"));
ms_instance = new CharacterCreationTracker;
ExitChain::add(CharacterCreationTracker::remove,"CharacterCreationTracker::remove");
}
DynamicVariableListNestedList::DynamicVariableListNestedList (const DynamicVariableListNestedList &parentList, const std::string &sublistName) :
m_list(parentList.m_list),
m_sublistName(parentList.getContextName()+sublistName + '.')
{
DEBUG_FATAL(sublistName.empty(),("Programmer bug: passed empty sublist name to NestedList::NestedList.\n"));
}
void TangibleController::handleMessage (const int message, const float value, const MessageQueue::Data* const data, const uint32 flags)
{
TangibleObject * const owner = getTangibleOwner();
switch (message)
{
case CM_pvpMessage:
{
const MessageQueuePvpCommand *pvpMsg = dynamic_cast<const MessageQueuePvpCommand *>(data);
NOT_NULL(pvpMsg);
Pvp::handlePvpMessage(*owner, *pvpMsg);
}
break;
case CM_combatDamageList:
{
if (owner->isAuthoritative())
{
const MessageQueueCombatDamageList *damageListMessage =
dynamic_cast<const MessageQueueCombatDamageList *>(data);
NOT_NULL(damageListMessage);
const std::vector<CombatEngineData::DamageData> & damageList =
damageListMessage->getDamageList();
if (damageList.size() == 0)
break;
if (!owner->isInCombat())
{
WARNING(true, ("TangibleController setting owner %s to be in "
"combat to apply damage; we should be able to avoid doing "
"this!", owner->getNetworkId().getValueString().c_str()));
owner->setInCombat(true);
}
// put the damage on the object's current damage list
owner->createCombatData();
CombatEngineData::CombatData * combatData = owner->getCombatData();
for (std::vector<CombatEngineData::DamageData>::const_iterator
iter = damageList.begin(); iter != damageList.end(); ++iter)
{
combatData->defenseData.damage.push_back(*iter);
}
}
}
break;
case CM_directDamage:
{
const MessageQueueDirectDamage *damageMessage =
dynamic_cast<const MessageQueueDirectDamage *>(data);
NOT_NULL(damageMessage);
CombatEngine::damage(*owner,
static_cast<ServerWeaponObjectTemplate::DamageType>(damageMessage->getDamageType()),
static_cast<uint16>(damageMessage->getHitLocation()),
damageMessage->getDamageDone());
}
break;
case CM_setOwnerId:
{
const MessageQueueNetworkId * const msg = safe_cast<const MessageQueueNetworkId *>(data);
if(msg)
{
owner->setOwnerId(msg->getNetworkId());
}
}
break;
case CM_setMaxHitPoints:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->setMaxHitPoints(msg->getValue());
}
}
break;
case CM_setVisible:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
if(msg)
{
owner->setVisible(msg->getValue());
}
}
break;
case CM_hideFromClient:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
if(msg)
{
owner->setHidden(msg->getValue());
}
}
break;
case CM_setInvulnerable:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
if(msg)
{
owner->setInvulnerable(msg->getValue());
}
}
break;
case CM_addLocationTarget:
{
const MessageQueueGenericValueType<LocationData> * const msg = safe_cast<const MessageQueueGenericValueType<LocationData> *>(data);
if(msg)
{
owner->addLocationTarget(msg->getValue());
}
}
break;
case CM_removeLocationTarget:
{
const MessageQueueGenericValueType<Unicode::String> * const msg = safe_cast<const MessageQueueGenericValueType<Unicode::String> *>(data);
if(msg)
{
owner->removeLocationTarget(msg->getValue());
}
}
break;
case CM_setInCombat:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
if(msg)
{
owner->setInCombat(msg->getValue());
}
}
break;
case CM_addAim:
{
owner->addAim();
}
break;
case CM_clearAims:
{
owner->clearAims();
}
break;
case CM_alterHitPoints:
{
const MessageQueueGenericValueType<std::pair<int, NetworkId> > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<int, NetworkId> > *>(data);
if(msg)
{
owner->alterHitPoints(msg->getValue().first, false, msg->getValue().second);
}
}
break;
case CM_addHate:
{
const MessageQueueGenericValueType<std::pair<NetworkId, float> > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<NetworkId, float> > *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_addHate) The message data should never be NULL"));
if(msg)
{
owner->addHate(msg->getValue().first, msg->getValue().second);
}
}
break;
case CM_setHate:
{
const MessageQueueGenericValueType<std::pair<NetworkId, float> > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<NetworkId, float> > *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_setHate) The message data should never be NULL"));
if(msg)
{
owner->setHate(msg->getValue().first, msg->getValue().second);
}
}
break;
case CM_removeHateTarget:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_removeHateTarget) The message data should never be NULL"));
if(msg)
{
owner->removeHateTarget(msg->getValue());
}
}
break;
case CM_clearHateList:
{
owner->clearHateList();
}
break;
case CM_resetHateTimer:
{
owner->resetHateTimer();
}
break;
case CM_forceHateTarget:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_removeHateTarget) The message data should never be NULL"));
if(msg)
{
owner->forceHateTarget(msg->getValue());
}
}
break;
case CM_autoExpireHateListTargetEnabled:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_setHateListExpireTargetEnabled) The message data should never be NULL"));
if (msg != NULL)
{
owner->setHateListAutoExpireTargetEnabled(msg->getValue());
}
}
break;
case CM_setCraftedId:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
owner->setCraftedId(msg->getValue());
}
}
break;
case CM_startCraftingSession:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
CreatureObject * crafter = safe_cast<CreatureObject *>(NetworkIdManager::getObjectById(msg->getValue()));
DEBUG_FATAL(!crafter, ("%s:%s received startCraftingSession controller message for crafter %s, but crafter %s is not loaded on this server!", owner->getObjectTemplateName(), owner->getNetworkId().getValueString().c_str(), msg->getValue().getValueString().c_str(), msg->getValue().getValueString().c_str()));
if(crafter)
owner->startCraftingSession(*crafter);
}
}
break;
case CM_addObjectToOutputSlot:
{
const MessageQueueGenericValueType<std::pair<NetworkId, NetworkId> > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<NetworkId, NetworkId> > *>(data);
if(msg)
{
ServerObject * object = safe_cast<ServerObject *>(NetworkIdManager::getObjectById(msg->getValue().first));
DEBUG_FATAL(! object, ("%s:%s received addObjectToOutputSlot controller message, but the ingredient %s is not loaded on this server!", owner->getObjectTemplateName(), owner->getNetworkId().getValueString().c_str(), msg->getValue().first.getValueString().c_str()));
if(object)
{
ServerObject * transferer = safe_cast<ServerObject *>(NetworkIdManager::getObjectById(msg->getValue().second));
// transferer is allowed to be null
owner->addObjectToOutputSlot(*object, transferer);
}
}
}
break;
case CM_setCraftingManufactureSchematic:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
ManufactureSchematicObject * schematic = safe_cast<ManufactureSchematicObject *>(NetworkIdManager::getObjectById(msg->getValue()));
DEBUG_FATAL(! schematic, ("%s:%s received setCraftingManufactureSchematic controller message, but the ingredient %s is not loaded on this server!", owner->getObjectTemplateName(), owner->getNetworkId().getValueString().c_str(), msg->getValue().getValueString().c_str()));
if(schematic)
{
owner->setCraftingManufactureSchematic(*schematic);
}
}
}
break;
case CM_clearCraftingManufactureSchematic:
{
owner->clearCraftingManufactureSchematic();
}
break;
case CM_setCraftingPrototype:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
ServerObject * prototype = safe_cast<ServerObject *>(NetworkIdManager::getObjectById(msg->getValue()));
DEBUG_FATAL(! prototype, ("%s:%s received setCraftingPrototype controller message, but the ingredient %s is not loaded on this server!", owner->getObjectTemplateName(), owner->getNetworkId().getValueString().c_str(), msg->getValue().getValueString().c_str()));
if(prototype)
{
owner->setCraftingPrototype(*prototype);
}
}
}
break;
case CM_clearCraftingPrototype:
{
owner->clearCraftingPrototype();
}
break;
case CM_setCreatorId:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
owner->setCreatorId(msg->getValue());
}
}
break;
case CM_setCreatorXp:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->setCreatorXp(msg->getValue());
}
}
break;
case CM_setCreatorXpType:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->setCreatorXpType(msg->getValue());
}
}
break;
case CM_setVisibleComponents:
{
const MessageQueueGenericValueType<std::vector<int> > * const msg = safe_cast<const MessageQueueGenericValueType<std::vector<int> > *>(data);
if(msg)
{
owner->setVisibleComponents(msg->getValue());
}
}
break;
case CM_setCraftedType:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->setCraftedType(msg->getValue());
}
}
break;
case CM_setCondition:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->setCondition(msg->getValue());
}
}
break;
case CM_clearCondition:
{
const MessageQueueGenericValueType<int> * const msg = safe_cast<const MessageQueueGenericValueType<int> *>(data);
if(msg)
{
owner->clearCondition(msg->getValue());
}
}
break;
case CM_npcConversationStart:
{
const MessageQueueStartNpcConversation * const msg = NON_NULL(dynamic_cast<const MessageQueueStartNpcConversation *>(data));
const CachedNetworkId npcId (msg->getNpc ());
TangibleObject * const npcObject = dynamic_cast<TangibleObject *>(npcId.getObject ());
if (npcObject)
{
owner->startNpcConversation (*npcObject, msg->getConversationName().c_str(), msg->getStarter(), msg->getAppearanceOverrideTemplateCrc());
}
}
break;
case CM_npcConversationStop:
{
owner->endNpcConversation ();
}
break;
case CM_npcConversationSelect:
{
owner->respondToNpc (static_cast<int>(value));
}
break;
case CM_forwardNpcConversationMessage:
{
typedef std::pair<std::pair<StringId, ProsePackage>, Unicode::String> Payload;
const MessageQueueGenericValueType<Payload> * const msg = safe_cast<const MessageQueueGenericValueType<Payload> *>(data);
if(msg)
{
const Payload & payload = msg->getValue ();
owner->sendNpcConversationMessage(payload.first.first, payload.first.second, payload.second);
}
}
break;
case CM_addNpcConversationResponse:
{
typedef std::pair<StringId, ProsePackage> Payload;
const MessageQueueGenericValueType<Payload> * const msg = safe_cast<const MessageQueueGenericValueType<Payload> *>(data);
if(msg)
{
const Payload & payload = msg->getValue ();
owner->addNpcConversationResponse(payload.first, payload.second);
}
}
break;
case CM_removeNpcConversationResponse:
{
typedef std::pair<StringId, ProsePackage> Payload;
const MessageQueueGenericValueType<Payload> * const msg = safe_cast<const MessageQueueGenericValueType<Payload> *>(data);
if(msg)
{
const Payload & payload = msg->getValue ();
owner->removeNpcConversationResponse(payload.first, payload.second);
}
}
break;
case CM_sendNpcConversationResponses:
{
owner->sendNpcConversationResponses();
}
break;
case CM_playerResponseToNpcConversation:
{
typedef std::pair<std::string, std::pair<NetworkId, std::pair<StringId, ProsePackage> > > Payload;
const MessageQueueGenericValueType<Payload> * const msg = safe_cast<const MessageQueueGenericValueType<Payload> *>(data);
if(msg)
{
const Payload & payload = msg->getValue ();
owner->handlePlayerResponseToNpcConversation(payload.first, payload.second.first, payload.second.second.first, payload.second.second.second);
}
}
break;
case CM_setBioLink:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
const NetworkId & linkId = msg->getValue();
if (linkId != NetworkId::cms_invalid)
owner->setBioLink(linkId);
else
owner->clearBioLink();
}
}
break;
case CM_commandQueueForceExecuteCommandFwd:
{
MessageQueueCommandQueueForceExecuteCommandFwd const * const cmdMsg = dynamic_cast<const MessageQueueCommandQueueForceExecuteCommandFwd *>(data);
Command::ErrorCode status = static_cast<Command::ErrorCode>(cmdMsg->getStatus());
owner->forceExecuteCommand(CommandTable::getCommand(cmdMsg->getCommandHash()), cmdMsg->getTargetId(), cmdMsg->getParams(), status, cmdMsg->getCommandIsFromCommandQueue());
}
break;
case CM_commandQueueEnqueue:
{
handleCommandQueueEnqueue(dynamic_cast<const MessageQueueCommandQueueEnqueue *>(data));
}
break;
case CM_commandQueueRemove:
{
MessageQueueCommandQueueRemove const *msg = dynamic_cast<MessageQueueCommandQueueRemove const *>(data);
owner->commandQueueRemove(msg->getSequenceId());
}
break;
case CM_commandQueueEnqueueFwd:
{
handleCommandQueueEnqueueFwd(dynamic_cast<const MessageQueueCommandQueueEnqueueFwd *>(data));
}
break;
case CM_setAttackableOverride:
{
const MessageQueueGenericValueType<bool> * const msg = safe_cast<const MessageQueueGenericValueType<bool> *>(data);
if(msg)
{
owner->setAttackableOverride(msg->getValue());
}
}
break;
case CM_addPassiveReveal:
{
const MessageQueueGenericValueType<std::pair<std::pair<int, int>, NetworkId> > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<std::pair<int, int>, NetworkId> > *>(data);
if(msg)
{
owner->addPassiveReveal(msg->getValue().second, msg->getValue().first.first, (msg->getValue().first.second != 0));
}
}
break;
case CM_removePassiveReveal:
{
const MessageQueueGenericValueType<NetworkId> * const msg = safe_cast<const MessageQueueGenericValueType<NetworkId> *>(data);
if(msg)
{
owner->removePassiveReveal(msg->getValue());
}
}
break;
case CM_removeAllPassiveReveal:
{
owner->removeAllPassiveReveal();
}
break;
case CM_addHateOverTime:
{
const MessageQueueGenericValueType<std::pair<NetworkId, std::pair<int, float> > > * const msg = safe_cast<const MessageQueueGenericValueType<std::pair<NetworkId, std::pair<int, float> > > *>(data);
if(msg)
{
owner->addHateOverTime(msg->getValue().first, msg->getValue().second.second, msg->getValue().second.first);
}
}
break;
case CM_addUserToAccessList:
{
MessageQueueGenericValueType<std::pair<int, NetworkId> > const *msg = safe_cast<MessageQueueGenericValueType<std::pair<int, NetworkId> > const *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_addUserToAccessList) The message data should never be NULL"));
if(msg)
{
if(msg->getValue().first < 0)
owner->addUserToAccessList(msg->getValue().second);
else
owner->addGuildToAccessList(msg->getValue().first);
}
}
break;
case CM_removeUserFromAccessList:
{
MessageQueueGenericValueType<std::pair<int, NetworkId> > const *msg = safe_cast<MessageQueueGenericValueType<std::pair<int, NetworkId> > const *>(data);
WARNING((msg == NULL), ("TangibleController::handleMessage(CM_removeUserFromAccessList) The message data should never be NULL"));
if(msg)
{
if(msg->getValue().first < 0)
owner->removeUserFromAccessList(msg->getValue().second);
else
owner->removeGuildFromAccessList(msg->getValue().first);
}
}
break;
case CM_clearUserAccessList:
{
MessageQueueGenericValueType<bool> const *msg = safe_cast<MessageQueueGenericValueType<bool> const *>(data);
if(msg)
{
if(msg->getValue())
owner->clearGuildAccessList();
else
owner->clearUserAccessList();
}
}
break;
case CM_addObjectEffect:
{
MessageQueueGenericValueType<std::pair<std::string, std::pair<std::string, std::pair<std::string, std::pair<Vector, float > > > > > const * msg = safe_cast<MessageQueueGenericValueType<std::pair<std::string, std::pair<std::string, std::pair<std::string, std::pair<Vector, float > > > > > const *>(data);
if(msg)
{
owner->addObjectEffect(msg->getValue().second.first, msg->getValue().second.second.first, msg->getValue().second.second.second.first, msg->getValue().second.second.second.second, msg->getValue().first);
}
}
break;
case CM_removeObjectEffect:
{
MessageQueueGenericValueType<std::string> const * msg = safe_cast<MessageQueueGenericValueType<std::string> const *>(data);
if(msg)
{
owner->removeObjectEffect(msg->getValue());
}
}
break;
case CM_removeAllObjectEffect:
{
MessageQueueGenericValueType<bool> const *msg = safe_cast<MessageQueueGenericValueType<bool> const *>(data);
if(msg)
{
if(msg->getValue())
owner->removeAllObjectEffects();
}
}
break;
default:
ServerController::handleMessage(message, value, data, flags);
break;
}
}
/**
* Send the snapshot to the appropriate server.
*
* This function will send messages to the appropriate gameServer to
* create a proxy for the objects in the snapshot, then it will send a
* message to central to relinquish authority for the objects.
*
* @return true if the objects were sent, false if they were not.
*/
bool SwgSnapshot::send(GameServerConnection *connection) const
{
PROFILER_AUTO_BLOCK_DEFINE("SwgSnapshot::send");
if (connection==0)
return false;
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("Sending Snapshot\n"));
PROFILER_BLOCK_DEFINE(prebaselinesBlock,"sendPreBaselinesCustomData");
PROFILER_BLOCK_ENTER(prebaselinesBlock);
for (LocatorListType::const_iterator loc=m_locatorList.begin(); loc!=m_locatorList.end(); ++loc)
{
(*loc)->sendPreBaselinesCustomData(*connection);
}
PROFILER_BLOCK_LEAVE(prebaselinesBlock);
OIDListType oidList;
m_objectTableBuffer.getObjectList(oidList);
PROFILER_BLOCK_DEFINE(sendObjectData,"send object data");
PROFILER_BLOCK_ENTER(sendObjectData);
static std::vector<BatchBaselinesMessageData> baselines;
baselines.clear();
for (OIDListType::iterator i=oidList.begin(); i!=oidList.end(); ++i)
{
PROFILER_BLOCK_DEFINE(createBlock, "object create and position");
PROFILER_BLOCK_ENTER(createBlock);
const DBSchema::ObjectBufferRow *baseData=m_objectTableBuffer.findConstRowByIndex((*i));
NOT_NULL(baseData);
NetworkId networkId=(*i);
DEBUG_FATAL(networkId != baseData->object_id.getValue(),("Object ID and row value didn't match"));
uint32 crc = baseData->object_template_id.getValue();
CreateObjectByCrcMessage com(networkId,
crc,
static_cast<unsigned short>(baseData->type_id.getValue()),
true,
NetworkId(baseData->contained_by.getValue()));
// connection->send(com,true);
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("\tSent CreateObjectMessage for object %s\n",networkId.getValueString().c_str()));
Transform t;
Quaternion q(static_cast<real>(baseData->quaternion_w.getValue()),
static_cast<real>(baseData->quaternion_x.getValue()),
static_cast<real>(baseData->quaternion_y.getValue()),
static_cast<real>(baseData->quaternion_z.getValue()));
q.getTransform(&t); // reorients the transform according to the quaternion
t.validate();
t.setPosition_p(Vector (static_cast<real>(baseData->x.getValue()),
static_cast<real>(baseData->y.getValue()),
static_cast<real>(baseData->z.getValue())));
UpdateObjectPositionMessage uopm(
NetworkId(baseData->object_id.getValue()),
t,
t,
NetworkId(baseData->contained_by.getValue()),
baseData->slot_arrangement.getValue(),
NetworkId(baseData->load_with.getValue()),
baseData->player_controlled.getValue(),
false);
// connection->send(uopm,true);
PROFILER_BLOCK_LEAVE(createBlock);
PROFILER_BLOCK_DEFINE(encodeData,"encode data");
PROFILER_BLOCK_ENTER(encodeData);
bool okToSend = encodeParentClientData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeClientData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeServerData(networkId,baseData->type_id.getValue(),baselines);
okToSend = okToSend && encodeSharedData(networkId,baseData->type_id.getValue(),baselines);
PROFILER_BLOCK_LEAVE(encodeData);
if (okToSend)
{
PROFILER_AUTO_BLOCK_DEFINE("connection->send (baselines)");
connection->send(com,true);
connection->send(uopm,true);
}
else
{
(*i)=NetworkId::cms_invalid;
}
}
BatchBaselinesMessage bbm(baselines);
connection->send(bbm,true);
PROFILER_BLOCK_LEAVE(sendObjectData);
PROFILER_BLOCK_DEFINE(sendEndBaselines,"send EndBaselines");
PROFILER_BLOCK_ENTER(sendEndBaselines);
// Send EndBaselines in reverse order (container & portal system requires this)
for (OIDListType::reverse_iterator r=oidList.rbegin(); r!=oidList.rend(); ++r)
{
if (*r != NetworkId::cms_invalid)
{
EndBaselinesMessage const ebm(*r);
connection->send(ebm,true);
}
// DEBUG_REPORT_LOG(true, ("\tSent EndBaselinesMessage for object %i\n",(*r).getValue()));
}
PROFILER_BLOCK_LEAVE(sendEndBaselines);
// Send resource data (if any) after all objects but before the post-baselines custom data
m_resourceTypeBuffer.sendResourceTypeObjects(*connection);
m_bountyHunterTargetBuffer.sendBountyHunterTargetMessage (*connection);
// Send post-baselines custom data, such as "UniverseComplete" messages, etc.
PROFILER_BLOCK_DEFINE(sendPostBaselinesCustomData,"sendPostBaselinesCustomData");
PROFILER_BLOCK_ENTER(sendPostBaselinesCustomData);
for (LocatorListType::const_iterator loc2=m_locatorList.begin(); loc2!=m_locatorList.end(); ++loc2)
{
(*loc2)->sendPostBaselinesCustomData(*connection);
}
PROFILER_BLOCK_LEAVE(sendPostBaselinesCustomData);
// Send any MessageTos for these objects
// This must happen after EndBaselinesMessage is sent for all of the objects
{
PROFILER_AUTO_BLOCK_DEFINE("send MessageTos");
m_messageBuffer.sendMessages(*connection);
for (OIDListType::const_iterator i=oidList.begin(); i!=oidList.end(); ++i)
{
if (*i != NetworkId::cms_invalid)
MessageToManager::getInstance().sendMessagesForObject(*i, *connection);
}
}
DEBUG_REPORT_LOG(ConfigServerDatabase::getLogObjectLoading(),("Done sending Snapshot\n"));
return true;
}
float AffectorRoad::getRampedHeight (const float worldX, const float worldZ,const float terrainHeight) const
{
if (!m_extent.isWithin (worldX, worldZ))
return -100.f;
const float widthSquared = sqr (m_width/2.0f);
float distanceSquared = widthSquared;
int foundIndex = -1;
//-- first, scan how far we are from the points
{
const int n = m_pointList.getNumberOfElements ();
int i;
for (i = 0; i < n; ++i)
{
const float x = m_pointList [i].x;
const float y = m_pointList [i].y;
const float thisDistanceSquared = sqr (worldX - x) + sqr (worldZ - y);
if (thisDistanceSquared < distanceSquared)
{
distanceSquared = thisDistanceSquared;
foundIndex = i;
}
}
}
//-- next, scan each line
{
const int n = m_pointList.getNumberOfElements () - 1;
int i;
for (i = 0; i < n; ++i)
{
const float x1 = m_pointList [i].x;
const float y1 = m_pointList [i].y; //lint !e578 //-- hides y1 (double)
const float x2 = m_pointList [i + 1].x;
const float y2 = m_pointList [i + 1].y;
const float u = ((worldX - x1) * (x2 - x1) + (worldZ - y1) * (y2 - y1)) / (sqr (x2 - x1) + sqr (y2 - y1));
if (u >= 0 && u <= 1)
{
const float x = x1 + u * (x2 - x1);
const float y = y1 + u * (y2 - y1);
const float thisDistanceSquared = sqr (worldX - x) + sqr (worldZ - y);
if (thisDistanceSquared < distanceSquared)
{
distanceSquared = thisDistanceSquared;
foundIndex = i;
}
}
}
}
if (distanceSquared < widthSquared)
{
DEBUG_FATAL(foundIndex == -1,("AffectorRoad::getRampedHeight - foundIndex is -1"));
float height = 0.0f;
// start feathering
float featherMultiplier = 1.0f;
const float newFeatherDistance = (m_width/2.0f) * (1.f - getFeatherDistance ());
const float newFeatherDistanceSquared = sqr (newFeatherDistance);
if (distanceSquared >= newFeatherDistanceSquared)
{
featherMultiplier = 1.f - (sqrt (distanceSquared) - newFeatherDistance) / (m_width/2.0f - newFeatherDistance);
const Feather feather(getFeatherFunction());
featherMultiplier=feather.feather(0.f, 1.f, featherMultiplier);
}
// end feathering
const float startHeight = m_heightList[foundIndex];
if(foundIndex != m_pointList.getNumberOfElements() - 1)
{
// project the world point onto the line between the control points and interp for the height
const Vector2d position(worldX,worldZ);
const float endHeight = m_heightList[foundIndex + 1];
const Vector2d p1(m_pointList [foundIndex].x,m_pointList [foundIndex].y);
const Vector2d p2(m_pointList [foundIndex+1].x,m_pointList [foundIndex+1].y);
const float totalDistance = p1.magnitudeBetween(p2);
const Line2d line (p1,p2);
const float distToLine = line.computeDistanceTo(position);
const float realDistToPoint1 = p1.magnitudeBetween(position);
const float realDistToPoint2 = p2.magnitudeBetween(position);
const float projectedDistToPoint1 = sqrt(sqr(realDistToPoint1) - sqr(distToLine));
const float projectedDistToPoint2 = sqrt(sqr(realDistToPoint2) - sqr(distToLine));
if(totalDistance != 0.0f && projectedDistToPoint1 <= totalDistance && projectedDistToPoint2 <= totalDistance)
{
height = startHeight + (projectedDistToPoint1/totalDistance) * (endHeight - startHeight);
}
else
{
height = startHeight;
}
}
else
{
height = startHeight;
}
// don't build canyons or ridges due to feathering to 0 height
const float delta = height - terrainHeight;
height = terrainHeight + (delta * featherMultiplier);
return height;
}
return -100.f;
}
Extent::~Extent(void)
{
DEBUG_FATAL(m_referenceCount > 0, ("referenceCount not zero %d", m_referenceCount));
}
int ZlibFile::write(int, const void *)
{
DEBUG_FATAL(true, ("writing to a zlib file is not supported"));
return 0;
}
bool ObjectTemplateCustomizationDataWriter::writeToFile(const std::string &pathName, bool allowOverwrite)
{
//-- Don't write anything if there's no data to write.
bool hasData = false;
if (!m_paletteColorData->empty())
hasData = true;
if (!m_rangedIntData->empty())
hasData = true;
if (!hasData)
{
DEBUG_REPORT_LOG(true, ("writeToFile(): no data: skipped writing [%s].\n", pathName.c_str()));
return true;
}
//-- Handle no-overwrite case.
if (!allowOverwrite)
{
FILE *const testFile = fopen(pathName.c_str(), "r");
if (testFile != NULL)
{
fclose(testFile);
DEBUG_REPORT_LOG(true, ("writeToFile(): overwrite attempt: skipped writing [%s] because it already exists and allowOverwrite == false.\n", pathName.c_str()));
return false;
}
}
//-- open file
FILE *const file = fopen(pathName.c_str(), "w");
if (!file)
{
WARNING(true, ("failed to create file [%s].", pathName.c_str()));
return false;
}
//-- sort the output data
m_paletteColorData->sort();
m_rangedIntData->sort();
//-- write palette color variables
fprintf(file, "paletteColorCustomizationVariables = [");
{
int i = 0;
int const count = static_cast<int>(m_paletteColorData->size());
const StringList::iterator endIt = m_paletteColorData->end();
for (StringList::iterator it = m_paletteColorData->begin(); it != endIt; ++it, ++i)
{
if (i == (count - 1))
{
// -- Fixup last entry to use ] in place of final comma.
std::string::size_type position = it->rfind(',');
DEBUG_FATAL(static_cast<int>(position) == static_cast<int>(std::string::npos), ("bad data, where's the final comma?"));
(*it)[position] = ']';
}
fprintf(file, "\n %s", it->c_str());
}
}
if (m_paletteColorData->empty())
fprintf(file, "]");
fprintf(file, "\n\n");
//-- write ranged int variables
fprintf(file, "rangedIntCustomizationVariables = [");
{
int i = 0;
int const count = static_cast<int>(m_rangedIntData->size());
const StringList::iterator endIt = m_rangedIntData->end();
for (StringList::iterator it = m_rangedIntData->begin(); it != endIt; ++it, ++i)
{
if (i == (count - 1))
{
// -- Fixup last entry to use ] in place of final comma.
std::string::size_type position = it->rfind(',');
DEBUG_FATAL(static_cast<int>(position) == static_cast<int>(std::string::npos), ("bad data, where's the final comma?"));
(*it)[position] = ']';
}
fprintf(file, "\n %s", it->c_str());
}
}
if (m_rangedIntData->empty())
fprintf(file, "]");
fprintf(file, "\n\n");
fclose(file);
//-- return success
return true;
}
