void NetManager::readServerPacket(ENetEvent& event)
{
FAWorld::World& world = *FAWorld::World::get();
size_t position = 0;
ServerPacketHeader header;
readFromPacket(event.packet, position, header);
if(header.tick > mLastServerTickProcessed)
{
for(size_t i = 0; i < header.numPlayers; i++)
{
uint32_t playerId;
readFromPacket<uint32_t>(event.packet, position, playerId);
auto player = world.getPlayer(playerId);
if(player == NULL)
{
spawnPlayer(playerId);
player = world.getPlayer(playerId);
}
position = player->readFrom(event.packet, position);
}
}
}
bool Map::initPlayer (Player* player)
{
if (!_mapRunning)
return false;
if (getPlayer(player->getClientId()) != nullptr)
return false;
assert(_entityRemovalAllowed);
INetwork& network = _serviceProvider->getNetwork();
const ClientId clientId = player->getClientId();
info(LOG_SERVER, "init player " + player->toString());
const int clientMask = ClientIdToClientMask(clientId);
const MapSettingsMessage mapSettingsMsg(_settings, _startPositions.size());
network.sendToClient(clientId, mapSettingsMsg);
GameEvent.sendWaterUpdate(clientMask, *_water);
const InitDoneMessage msgInit(player->getID(), getPackageCount(), player->getLives(), player->getHitpoints());
network.sendToClient(clientId, msgInit);
sendSound(0, SoundTypes::SOUND_PLAYER_SPAWN);
network.sendToClient(clientId, InitWaitingMapMessage());
updateVisMask();
sendMapToClient(clientId);
if (!_players.empty()) {
const bool spawned = spawnPlayer(player);
updateVisMask();
return spawned;
}
info(LOG_SERVER, "delay spawn of player");
_playersWaitingForSpawn.push_back(player);
return true;
}
bool Map::initPlayer (Player* player)
{
if (!_mapRunning)
return false;
if (getPlayer(player->getClientId()) != nullptr)
return false;
assert(_entityRemovalAllowed);
INetwork& network = _serviceProvider->getNetwork();
const ClientId clientId = player->getClientId();
info(LOG_SERVER, "init player " + player->toString());
const MapSettingsMessage mapSettingsMsg(_settings, _startPositions.size());
network.sendToClient(clientId, mapSettingsMsg);
const InitDoneMessage msgInit(player->getID(), 0, 0, 0);
network.sendToClient(clientId, msgInit);
network.sendToClient(clientId, InitWaitingMapMessage());
sendMapToClient(clientId);
if (!_players.empty()) {
const bool spawned = spawnPlayer(player);
return spawned;
}
_playersWaitingForSpawn.push_back(player);
return true;
}
void PlayerInterface::spawnPlayer( unsigned short player_index, const iXY &location )
{
assert( player_index < max_players );
spawnPlayer( player_lists[ player_index ].getPlayerID(),
location
);
}
void Map::startMap ()
{
info(LOG_SERVER, "start the map and spawn pending players");
for (PlayerListIter i = _playersWaitingForSpawn.begin(); i != _playersWaitingForSpawn.end(); ++i) {
spawnPlayer(*i);
}
_playersWaitingForSpawn.clear();
updateVisMask();
INetwork& network = _serviceProvider->getNetwork();
network.sendToAllClients(StartMapMessage());
}
void Session::collision_player_mob()
{
Command cmd(_game_n);
Object *obj;
Object *obj2;
std::list<Object *>::iterator it;
std::list<Object *>::iterator it2;
int j;
it = _listObj.begin();
while (it != _listObj.end())
{
j = 0;
obj = *it;
while (j <= 3)
{
if (_tabPlayer[j] != NULL && obj->getType() != 5 &&
obj->getX() < _tabPlayer[j]->getPosx() + 2 && obj->getX() > _tabPlayer[j]->getPosx() - 2 &&
obj->getY() < _tabPlayer[j]->getPosy() + 2 && obj->getY() > _tabPlayer[j]->getPosy() - 2)
{
if (obj->getType() == 26)
{
std::cout << "Collison avec coeur !!!" << std::endl;
_tabPlayer[j]->setLife(_tabPlayer[j]->getLife() + 1);
cmd.sendLife(_tabPlayer[j], _p);
cmd.sendDestroy(obj->getId() , 0, _p);
_listObj.erase(it);
it = _listObj.begin();
}
else if ((_tabPlayer[j]->getLife() - 1) > 0)
{
std::cout << "ca pas Collison avec coeur !!!" << std::endl;
_tabPlayer[j]->setLife(_tabPlayer[j]->getLife() - 1);
cmd.sendLife(_tabPlayer[j], _p);
if (obj->getType() != 9 && obj->getType() != 21 && obj->getType() != 22 && obj->getType() != 24) // Les murs et les boss ne se detruisent pas
{
cmd.sendDestroy(obj->getId() , 0, _p);
_listObj.erase(it);
it = _listObj.begin();
}
spawnPlayer(_tabPlayer[j]);
}
else
_pingTime[j] = 0;
}
j++;
}
it++;
}
}
void GameManager::respawnAllPlayers()
{
PlayerState *player_state;
unsigned short max_players;
unsigned short player_index;
max_players = PlayerInterface::getMaxPlayers();
for( player_index = 0; player_index < max_players; player_index++ ) {
player_state = PlayerInterface::getPlayerState( player_index );
if ( player_state->getStatus() == _player_state_active ) {
spawnPlayer( player_state->getPlayerID() );
}
}
}
GameScene::GameScene(QObject *parent)
: QGraphicsScene(0, 0, 600, 800, parent)
, m_hudObject(new GraphicsHudObject(PLAYER_HEALTH))
{
addItem(new GraphicsBackgroundItem);
addItem(m_hudObject);
connect(m_hudObject, &GraphicsHudObject::gameOver, this,
&GameScene::showGameOverText);
auto timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &GameScene::update);
timer->start(1000 / FPS);
spawnPlayer();
}
void Session::sessionthread()
{
int session = _session_n;
Command cmd(_game_n);
_pingTime[session] = MAX_PING_TIME;
_tabPlayer[session] = new Player(session +1);
std::cout << "New player assign on slot " << session << "... Partie " << _game_n << std::endl;
spawnPlayer(_tabPlayer[session]);
cmd.sendConnect(_tabPlayer[session], _p);
cmd.sendLife(_tabPlayer[session], _p);
cmd.sendScore(_score, _p);
// cmd.sendMove(_tabPlayer[session], _p);
// std::cout << "En attente des nouvelles positions du client..." << std::endl;
while (_pingTime[session] > 0)
{
//Pas de recv dans les threads
//Le recv est gerer dans la boucle principal en dehors des threads
//Ici c' est la boucle du thread
//Lis dans le _tabPlayer et autre et envoit les infos avec _cmd.send****(***)
//A 20 tours de boucles On fait un ping avec _cmd.sendPing()
//Si la boucle recv principal ne recoit rien, on deco et on kill la thread
if (_pingTime[session] % 100 == 0)
cmd.sendMove(_tabPlayer[session], _p);
if (_pingTime[session] == MID_PING_TIME)
{
cmd.sendPing(_tabPlayer[session], _p);
std::cout << "Sending ping to client (player " << session + 1 << ")..." << std::endl;
}
if (_pingTime[session] == WARN_PING_TIME)
{
cmd.sendPing(_tabPlayer[session], _p);
std::cout << "Sending ping to client (player " << session + 1 << ") (WARNING LAST PING BEFORE DISCONNECT)..." << std::endl;
}
_pingTime[session] -= 1;
_th->ASleep(500);
}
cmd.sendDestroy(_tabPlayer[session]->getId(), 0, _p);
cmd.sendDisconnect(_tabPlayer[session], _p);
std::cout << "Disconnecting client (player " << session + 1 << ") on slot " << session << "." << std::endl;
std::cout << "The slot " << session << " is now free." << std::endl;
_th->AExitThread(handles[session]);
}
void GameManager::respawnAllPlayers()
{
PlayerState *player_state;
PlayerID max_players;
PlayerID player_index;
max_players = PlayerInterface::getMaxPlayers();
for( player_index = 0; player_index < max_players; ++player_index )
{
player_state = PlayerInterface::getPlayer( player_index );
if ( player_state->getStatus() == _player_state_active )
{
spawnPlayer( player_index );
}
}
}
void NetManager::update()
{
mTick++;
ENetEvent event;
while(enet_host_service(mHost, &event, 0))
{
switch(event.type)
{
case ENET_EVENT_TYPE_CONNECT:
{
if(mIsServer)
{
spawnPlayer(event.peer->connectID);
mClients.push_back(event.peer);
}
break;
}
case ENET_EVENT_TYPE_RECEIVE:
{
if(mIsServer)
readClientPacket(event);
else
readServerPacket(event);
break;
}
default:
{
break;
}
}
}
if(mIsServer && mClients.size() > 0)
sendServerPacket();
else if(mServerPeer != NULL)
sendClientPacket();
enet_host_flush(mHost);
}
void Player_listen(void *self) {
Player *player = self;
for(;;) {
if (pthread_mutex_lock(&player->queue->queue_lock) != 0) {
syslog(LOG_ERR,"Animationplayer: Can't get the lock on the queue.");
}
if (player->queue->current == NULL) {
syslog(LOG_DEBUG,"Waiting...");
pthread_cond_wait(&player->queue->queue_not_empty, &player->queue->queue_lock);
}
syslog(LOG_DEBUG, "Working.....");
Command *command = player->queue->current->command;
if (command->action == play) {
if (player->run == 1 && player->currentAnimation != NULL && player->currentAnimation->repeat == -1) {
set_run_state(0);
void* result;
if (pthread_join(runner, &result) != 0) {
syslog(LOG_ERR,"Animationplayer: failed to wait for current player thread.");
}
}
if (player->run == 0) {
set_run_state(1);
spawnPlayer((Animation*) command->value);
popQueue();
}
}
if (command->action == stop || command->action == halt) {
syslog(LOG_ERR,"Animationplayer: halting current animation %s.", player->currentAnimation->name);
set_run_state(0);
void* result;
if (pthread_join(runner, &result) != 0) {
syslog(LOG_ERR,"Animationplayer: failed to wait for current player thread.");
}
popQueue();
}
if (pthread_mutex_unlock(&player->queue->queue_lock) != 0) {
syslog(LOG_ERR,"Animationplayer: Can't release the lock on the queue.");
}
}
}
void GameState::loadLevel(int num) {
if(Root().game_state.m_player) Root().game_state.m_player->m_walkSound.pause();
if(num < 0 || num >= m_levels.size()) {
Root().menu_state.setGameOver(num > 0);
Root().states.pop();
return;
}
m_currentLevel = num;
m_currentLevelName = m_levels[m_currentLevel].first;
m_helpProgress = 0.f;
m_currentHelp = "";
std::string filename = m_currentLevelName + ".dat";
loadFromFile("levels/" + filename);
// spawn something
auto spawn = getMarker(Marker::SPAWN);
m_player = nullptr;
auto pos = glm::vec2(0, 0);
if(spawn) {
pos = spawn->position();
} else {
std::cout << "Warning: level " << filename << " does not contain any spawn marker. Spawning at (0, 0)." << std::endl;
}
if(m_currentLevelName == "spawn") {
spawnEgg(pos);
} else {
spawnPlayer(pos);
}
m_levelFade = 1.f;
tween::TweenerParam p2(1000, tween::SINE, tween::EASE_IN_OUT);
p2.addProperty(&m_levelFade, 0.f);
m_tweener.addTween(p2);
if(Root().debug && m_debugDrawEnabled) {
message(m_currentLevelName);
}
}
void Player::killPlayer()
{
if (fireReady == false)
{
delete reloadAnim;
fireReady = true;
}
deleteTank();
// координата Х в центре экрана
int x1 = centralX();
// координата Y в центре экрана
int y1 = centralY();
// плашка смерти
QString image1 = ":/images/images/died.png";
died = new Caution(image1, "DEAD");
died->setPos(x1-200,y1-88);
game->scene->addItem(died);
QTimer::singleShot(2000, this, SLOT(spawnPlayer()));
}
void Map::startMap ()
{
rebuildField();
for (PlayerListIter i = _playersWaitingForSpawn.begin(); i != _playersWaitingForSpawn.end(); ++i) {
spawnPlayer(*i);
}
_playersWaitingForSpawn.clear();
INetwork& network = _serviceProvider->getNetwork();
network.sendToAllClients(StartMapMessage());
for (int row = 0; row < _height; ++row) {
for (int col = 0; col < _width; ++col) {
StateMapConstIter i = _state.find(INDEX(col, row));
if (i == _state.end())
continue;
const char c = i->second;
if (c != Sokoban::PACKAGEONTARGET)
continue;
getPackage(col, row)->setState(CavePackerEntityStates::DELIVERED);
}
}
}
void PlayerSpawner::startGame()
{
if(NetworkManager::instance()->isServer())
{
if(GameState::instance()->team_mode == TEAM && GameState::instance()->game_mode != PINTO)
{
uint32_t prev_team = BLUE_TEAM;
for(std::map<int,bool>::iterator iter = GameState::instance()->playerConnections.begin();
iter != GameState::instance()->playerConnections.end(); ++iter)
{
int i = iter->first;
if(prev_team == BLUE_TEAM)
{
NetworkManager::instance()->player_team_id_map[i] = RED_TEAM;
prev_team = RED_TEAM;
}
else
{
NetworkManager::instance()->player_team_id_map[i] = BLUE_TEAM;
prev_team = BLUE_TEAM;
}
}
std::vector<Ogre::Vector3> spawned_positions_blue;
std::vector<Ogre::Vector3> spawned_positions_red;
for(std::map<int,bool>::iterator iter = GameState::instance()->playerConnections.begin();
iter != GameState::instance()->playerConnections.end(); ++iter)
{
int i = iter->first;
uint32_t version = RAND_RANGE(0, 5);
float rand_x = RAND_RANGE(0, SPAWN_RAND_RADIUS_MAX) - SPAWN_RAND_RADIUS_MAX;
float rand_z = RAND_RANGE(0, SPAWN_RAND_RADIUS_MAX) - SPAWN_RAND_RADIUS_MAX;
Ogre::Vector3 position;
if(NetworkManager::instance()->player_team_id_map[i] == RED_TEAM)
{
position = red_position;
position.x = position.x + rand_x;
position.z = position.z + rand_z;
}
else
{
position = blue_position;
position.x = position.x + rand_x;
position.z = position.z + rand_z;
}
spawnPlayer(position.x, position.y, position.z, i, NetworkManager::instance()->player_team_id_map[i], version, false);
NetworkManager::instance()->vital->setPlayerRespawn(position.x, position.y, position.z, i, NetworkManager::instance()->player_team_id_map[i], version, false);
}
}
else
{
uint32_t pinto_index = 100;
if(GameState::instance()->game_mode == PINTO)
{
pinto_index = RAND_RANGE(0, GameState::instance()->num_player);
int loop = 0;
for(std::map<int,bool>::iterator iter = GameState::instance()->playerConnections.begin();
iter != GameState::instance()->playerConnections.end(); ++iter) {
if (loop == pinto_index) { pinto_index = iter->first; break; }
loop++;
}
}
std::vector<Ogre::Vector3> spawned_positions;
for(int i = 0; i < GameState::instance()->num_player; ++i)
{
uint32_t version = RAND_RANGE(0, 5);
Ogre::Vector3 position;
do
{
position = free_positions[RAND_RANGE(0, free_positions.size())];
}while(std::find(spawned_positions.begin(), spawned_positions.end(), position) != spawned_positions.end());
spawned_positions.push_back(position);
bool is_pinto = false;
if(i == pinto_index)
{
is_pinto = true;
}
spawnPlayer(position.x, position.y, position.z, i, NetworkManager::instance()->player_team_id_map[i], version, is_pinto);
NetworkManager::instance()->vital->setPlayerRespawn(position.x, position.y, position.z, i, NetworkManager::instance()->player_team_id_map[i], version, is_pinto);
}
}
}
}
void NetManager::update()
{
mTick++;
ENetEvent event;
// TODO: remove this block when we handle level switching properly
auto player = FAWorld::World::get()->getCurrentPlayer();
if(player->getLevel())
mLevelIndexTmp = player->getLevel()->getLevelIndex();
else
mLevelIndexTmp = -1;
while(enet_host_service(mHost, &event, 0))
{
switch(event.type)
{
case ENET_EVENT_TYPE_CONNECT:
{
if(mIsServer)
{
auto player = spawnPlayer(-1);
// send the client its player id
auto packet = enet_packet_create(NULL, sizeof(size_t), ENET_PACKET_FLAG_RELIABLE);
size_t position = 0;
writeToPacket(packet, position, player->getId());
enet_peer_send(event.peer, RELIABLE_CHANNEL_ID, packet);
sendLevel(0, event.peer);
sendLevel(1, event.peer);
mClients.push_back(event.peer);
mServerPlayerList[event.peer->connectID] = player;
}
break;
}
case ENET_EVENT_TYPE_RECEIVE:
{
if(mIsServer)
readClientPacket(event);
else
readServerPacket(event);
break;
}
default:
{
break;
}
}
}
if(mIsServer && mClients.size() > 0)
sendServerPacket();
else if(mServerPeer != NULL)
sendClientPacket();
enet_host_flush(mHost);
}
void GameScene::update()
{
Q_ASSERT(sender() == findChild<QTimer*>());
if(m_paused) return;
GraphicsPlayerObject* player = nullptr;
QList<AbstractGraphicsPlaneObject*> planes;
for(auto item : items()) // find planes
{
switch(item->type())
{
case PlayerType:
player = qgraphicsitem_cast<GraphicsPlayerObject*>(item);
case EnemyType:
planes.append(dynamic_cast<AbstractGraphicsPlaneObject*>(item));
}
}
if(player && !player->isInvencible())
{
Q_ASSERT(player == m_player);
const auto playerRect = player->sceneBoundingRect();
for(auto plane : planes)
{
if(plane != player)
{
const auto enemyRect = plane->sceneBoundingRect();
if (playerRect.intersects(enemyRect))
player->impact(std::numeric_limits<qint32>::max());
}
}
}
for(auto item : items())
{
if(item->type() == BulletType || item->type() == EnemyBulletType)
{
const auto rect = item->boundingRect().translated(item->pos());
if(!sceneRect().contains(rect))
delete item;
else
{
bool impacted = false;
for(auto it = planes.begin(); it != planes.end() && !impacted;
++it)
{
const auto planeRect = (*it)->sceneBoundingRect();
auto plane = qgraphicsitem_cast<
AbstractGraphicsPlaneObject*>(*it);
const auto status = plane->status();
if(status == AbstractGraphicsPlaneObject::Status::Alive
&& planeRect.contains(rect))
{
plane->impact(100);
impacted = true;
}
}
if(impacted) delete item;
}
}
}
if(--m_spawnEnemiesTicks == 0) // Spawn enemies
{
if(!(qrand() % 24)) // 1/25
spawnEnemies(GraphicsEnemyObject::EnemyType::Boss, true);
else
spawnEnemies(GraphicsEnemyObject::EnemyType::White, true);
m_spawnEnemiesTicks = m_spawnEnemiesMaxTicks;
}
else if(m_spawnEnemiesTicks == m_spawnEnemiesMaxTicks / 2)
{
if(!(qrand() % 24)) // 1/25
spawnEnemies(GraphicsEnemyObject::EnemyType::Boss, false);
else
spawnEnemies(GraphicsEnemyObject::EnemyType::Green, false);
}
if(m_respawnTicks && --m_respawnTicks == 0)
spawnPlayer();
QGraphicsScene::advance();
}
void loadStage(char *filename)
{
FILE* file;
char buf[200];
int numheight;
int h,w;
currentStage.ingame = 1;
InitEntityList();
numheight=0;
file = fopen(filename, "r");
if(!file)
{
fprintf(stderr, "failed to open scene file %s\n", filename);
exit(1);
}
while(fscanf(file, "%s", buf) != EOF)
{
switch(buf[0])
{
case 's':
fscanf(file, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", ¤tStage.tilemap[numheight][0], ¤tStage.tilemap[numheight][1], ¤tStage.tilemap[numheight][2],¤tStage.tilemap[numheight][3],¤tStage.tilemap[numheight][4],¤tStage.tilemap[numheight][5],¤tStage.tilemap[numheight][6],¤tStage.tilemap[numheight][7],¤tStage.tilemap[numheight][8],¤tStage.tilemap[numheight][9],¤tStage.tilemap[numheight][10],¤tStage.tilemap[numheight][11],¤tStage.tilemap[numheight][12],¤tStage.tilemap[numheight][13],¤tStage.tilemap[numheight][14],¤tStage.tilemap[numheight][15],¤tStage.tilemap[numheight][16],¤tStage.tilemap[numheight][17],¤tStage.tilemap[numheight][18],¤tStage.tilemap[numheight][19]);
if(numheight < SPACE_H)numheight++;
break;
default:
fgets(buf, sizeof(buf), file);
break;
}
}
fclose(file);
spawnPlayer(0,-20,0);
for(h=0;h < SPACE_H;h++)
{
for(w=0;w < SPACE_W;w++)
{
if(currentStage.tilemap[h][w] == 1)
{
if(w > 10)
{
spawnEnemy1((w-10) * 4.5f,h* 14.5f, 0);
}else spawnEnemy1((float)((w-10) * 4),h* 14.5f, 0);
}
if(currentStage.tilemap[h][w] == 2)
{
if(w > 10)
{
spawnEnemy2((w-10) * 4.5f,h* 14.5f, 0);
}else spawnEnemy2((float)((w-10) * 4),h* 14.5f, 0);
}
if(currentStage.tilemap[h][w] == 3)
{
if(w > 10)
{
spawnEnemy3((w-10) * 4.5f,h* 14.5f, 0);
}else spawnEnemy3((float)((w-10) * 4),h* 14.5f, 0);
}
if(currentStage.tilemap[h][w] == 4)
{
if(w > 10)
{
spawnBoss1((w-10) * 4.5f,h* 14.5f, 0);
}else spawnBoss1((float)((w-10) * 4),h* 14.5f, 0);
}
}
}
}
// ******************************************************************
void GameManager::spawnPlayer( PlayerState *player_state )
{
spawnPlayer( player_state->getPlayerID() );
}