void SpawnMonitor::clear(void)
{
emit clearSpawnPoints();
m_spawns.clear();
m_points.clear();
m_selected = NULL;
}
SpawnPointList::SpawnPointList(SpawnMonitor* spawnMonitor,
QWidget* parent, const char* name):
SEQListView("SpawnPointList", parent, name),
m_spawnMonitor(spawnMonitor),
m_menu(NULL),
m_aboutToPop(false)
{
// get whether to keep the list sorted or not
m_keepSorted = pSEQPrefs->getPrefBool("KeepSorted", preferenceName(), false);
// add all the columns
if (showeq_params->retarded_coords)
{
addColumn ("N/S", "Coord1");
addColumn ("E/W", "Coord2");
}
else
{
addColumn ("X", "Coord1");
addColumn ("Y", "Coord2");
}
addColumn("Z", "Coord3");
addColumn("Remaining");
addColumn("Name");
addColumn("Last");
addColumn("Spawned");
addColumn("Count");
// default sort is on remaining
setSorting(tSpawnPointRemaining, true);
// restore the columns settings from preferences
restoreColumns();
// put in all the spawn points that might already be present in
// the spawn monitor
QAsciiDictIterator<SpawnPoint> it( m_spawnMonitor->spawnPoints() );
SpawnPoint* sp;
while ((sp = it.current()))
{
new SpawnPointListItem(this, sp);
++it;
}
// create the timer
m_timer = new QTimer( this, "spawn-point-timer" );
connect( m_timer, SIGNAL( timeout() ), this, SLOT( refresh() ) );
connect(m_spawnMonitor, SIGNAL(newSpawnPoint(const SpawnPoint*)),
this, SLOT(newSpawnPoint(const SpawnPoint*)));
connect(m_spawnMonitor, SIGNAL(clearSpawnPoints()),
this, SLOT(clear()));
connect(m_spawnMonitor, SIGNAL(selectionChanged(const SpawnPoint*)),
this, SLOT(handleSelChanged(const SpawnPoint*)));
connect(this, SIGNAL(rightButtonClicked(QListViewItem*, const QPoint&, int)),
this, SLOT(rightButtonClicked(QListViewItem*, const QPoint&, int)));
connect(this, SIGNAL( selectionChanged(QListViewItem*)),
this, SLOT(handleSelectItem(QListViewItem*)));
m_timer->start(10000L);
}
void SpawnMonitor::clear(void)
{
emit clearSpawnPoints();
m_spawns.clear();
m_points.clear();
}
void ServerPacketHandlerSystem::handleLoading()
{
while( m_server->hasNewPackets() )
{
Packet packet = m_server->popNewPacket();
char packetType;
packetType = packet.getPacketType();
if(packetType == (char)PacketType::ChangeStatePacket){
ChangeStatePacket statePacket;
statePacket.unpack(packet);
if(statePacket.m_gameState == GameStates::LOADING){
m_readyLoadingPlayers++;
}
}
}
PlayerSystem* playerSys = static_cast<PlayerSystem*>(
m_world->getSystem(SystemType::PlayerSystem));
if(m_readyLoadingPlayers == playerSys->getActiveEntities().size()){
/************************************************************************/
/* Generates the level here based on the existing amount of players */
/* LevelGen, LevelHandler and SpawnPoints need to be reset before */
/* generating a new level. */
/************************************************************************/
auto levelGen = static_cast<LevelGenSystem*>(
m_world->getSystem(SystemType::LevelGenSystem));
auto levelHandler = static_cast<LevelHandlerSystem*>(
m_world->getSystem(SystemType::LevelHandlerSystem));
auto spawnPointSys = static_cast<SpawnPointSystem*>(
m_world->getSystem(SystemType::SpawnPointSystem));
if (!levelGen->isLevelGenerated())
{
levelHandler->destroyLevel();
spawnPointSys->clearSpawnPoints();
levelGen->generateLevel(m_readyLoadingPlayers);
}
if (levelHandler->hasLevel() && spawnPointSys->isSpawnPointsReady())
{
/************************************************************************/
/* Send the already networkSynced objects located on the server to the */
/* newly connected client. */
/************************************************************************/
NetworkSynced* netSync;
Transform* transform;
vector<Entity*> dynamicEntities = static_cast<ServerDynamicObjectsSystem*>(
m_world->getSystem(SystemType::ServerDynamicObjectsSystem))->getActiveEntities();
for( unsigned int i=0; i<dynamicEntities.size(); i++ )
{
int entityId = dynamicEntities[i]->getIndex();
netSync = (NetworkSynced*)m_world->getComponentManager()->
getComponent( entityId, ComponentType::NetworkSynced );
transform = (Transform*)m_world->getComponentManager()->
getComponent( entityId, ComponentType::Transform );
EntityCreationPacket data;
data.entityType = static_cast<char>(netSync->getNetworkType());
data.owner = netSync->getNetworkOwner();
data.playerID = netSync->getPlayerID();
data.networkIdentity = netSync->getNetworkIdentity();
data.meshInfo = 0; //Temp
if (transform)
{
data.translation = transform->getTranslation();
data.rotation = transform->getRotation();
data.scale = transform->getScale();
}
///MESH INFO MUST BE MADE INTO A COMPONENT
//data.meshInfo = 1;
m_server->broadcastPacket( data.pack() );
}
/************************************************************************/
/* Send static objects to the newly connected client. */
/************************************************************************/
vector<Entity*> entities = static_cast<ServerStaticObjectsSystem*>(m_world->
getSystem(SystemType::ServerStaticObjectsSystem))->getStaticObjects();
for (unsigned int i= 0; i < entities.size(); i++)
{
transform = static_cast<Transform*>(entities[i]->
getComponent(ComponentType::Transform));
StaticProp* prop = static_cast<StaticProp*>(entities[i]->
getComponent(ComponentType::StaticProp));
EntityCreationPacket data;
data.entityType = static_cast<char>(EntityType::Other);
data.owner = -1; //NO OWNER
data.networkIdentity = entities[i]->getIndex();
data.translation = transform->getTranslation();
data.rotation = transform->getRotation();
data.scale = transform->getScale();
data.isLevelProp = false;//prop->isLevelPiece; // isLevelProp is no longer
// used here. MiscData is
// instead.
data.meshInfo = prop->meshInfo;
data.miscData = prop->propType;
LevelPieceRoot* root = static_cast<LevelPieceRoot*>(entities[i]->getComponent(ComponentType::LevelPieceRoot));
if (root)
{
//data.bsPos = root->boundingSphere.position;
//data.bsRadius = root->boundingSphere.radius;
/*RootBoundingSpherePacket bspacket;
bspacket.targetNetworkIdentity = entities[i]->getIndex();
bspacket.position = root->boundingSphere.position;
bspacket.radius = root->boundingSphere.radius;*/
data.networkIdentity = root->pieceId;
int miscSize = root->connectedRootPieces.size();
if (miscSize > 0)
{
data.additionalMisc.resize(miscSize);
for (int misc = 0; misc < miscSize; misc++)
data.additionalMisc[misc] = root->connectedRootPieces[misc];
}
}
m_server->broadcastPacket( data.pack() );
}
/************************************************************************/
/* Create and send the ship entities. */
/************************************************************************/
//for(unsigned int i=0; i<m_server->getActiveConnections().size(); i++)
//{
// createAndBroadCastShip(m_server->getActiveConnections().at(i), (int)i);
//}
auto playerComps = playerSys->getPlayerComponents();
for (unsigned int i = 0; i < playerComps.size(); i++)
{
if (playerComps[i])
createAndBroadCastShip(playerComps[i]->m_networkID, playerComps[i]->m_playerID);
}
// Reset the level state. This sets "ready" to true, and "level generated" to
// false.
levelGen->resetState();
ChangeStatePacket changeState;
changeState.m_serverState = ServerStates::SENTALLPACKETS;
m_server->broadcastPacket(changeState.pack());
m_stateSystem->setQueuedState(ServerStates::SENTALLPACKETS);
}
}
}
