void Player::disconnectPlayerCleanup(Player* player)
{
static QMutex playerCleanupMutex;
// Save the pony
QList<Pony> ponies = loadPonies(player);
for (int i=0; i<ponies.size(); i++)
if (ponies[i].ponyData == player->pony.ponyData)
ponies[i] = player->pony;
savePonies(player, ponies);
player->pony.saveQuests();
player->pony.saveInventory();
QString uIP = player->IP;
quint16 uPort = player->port;
Scene* scene = findScene(player->pony.sceneName);
if (scene->name.isEmpty())
logMessage(tr("UDP: Can't find scene for player cleanup"));
//app.logMessage("playerCleanup locking");
playerCleanupMutex.lock();
removePlayer(scene->players, uIP, uPort);
for (int i=0; i<scene->players.size(); i++)
sendNetviewRemove(scene->players[i], player->pony.netviewId);
player->udpDelayedSend(); // We're about to remove the player, we can't delay the send
player->udpSendReliableTimer->stop();
player->udpSendReliableGroupTimer->stop();
removePlayer(Player::udpPlayers, uIP, uPort);
delete player;
//app.logMessage("playerCleanup unlocking");
playerCleanupMutex.unlock();
}
void PlayerRelationsManager::clear()
{
StringVect *const names = getPlayers();
FOR_EACHP (StringVectCIter, it, names)
removePlayer(*it);
delete names;
}
/// Method handling the upgrade of a players ability
int upgradePlayerAbility(int id, int ability){
Player p=getPlayer(id);
removePlayer(id);
switch(ability){
case 0://strength
{
p.improveStrength(1);
addPlayer(p);
return p.getStrength();
}
case 1://velocity
{
p.improveVelocity(1);
addPlayer(p);
return p.getVelocity();
}
case 2://precision
{
p.improvePrecision(1);
addPlayer(p);
return p.getPrecision();
}
case 3://chance
{
p.improveChance(1);
addPlayer(p);
return p.getChance();
}
default:
return -1;
}
}
void GateGameClient::parseChangeGS(google::protobuf::Message* p, pb_flag_type flag)
{
message::MsgDB2GTChangeGS* msg = static_cast<message::MsgDB2GTChangeGS*>(p);
UserSession* pksession = gGTUserMgr.getUserSession(flag);
if (msg && pksession)
{
GateGameClient* pkNew = gGTGameMgr.getGameClient(msg->gameserverid());
if (!pkNew)
{
pksession->setClose();
Mylog::log_server(LOG_ERROR, "change server not found the gmae server [%u]", msg->gameserverid());
}else
{
//切换到目标图的GS上
removePlayer( pksession->getTrans());
account_type a = gGTUserMgr.getAccount(pksession->getTrans());
if (a != INVALID_ACCOUNT)
{
pksession->setGSid(msg->gameserverid());
pkNew->addNewPlayer(pksession->getTrans(), gGTUserMgr.getAccount(pksession->getTrans()));
}else
{
pksession->setClose();
Mylog::log_server(LOG_ERROR, "change server not found the Account ");
}
}
}
}
void OnlineRaceLogic::onPlayerLeaved(const CL_String &p_name)
{
// get the player
Player &player = getPlayer(p_name);
// remove from level
getLevel().removeCar(&player.getCar());
// remove from game
removePlayer(player);
TPlayerList::iterator itor;
bool found = false;
for (itor = m_remotePlayers.begin(); itor != m_remotePlayers.end(); ++itor) {
if (reinterpret_cast<unsigned> (itor->get()) == reinterpret_cast<unsigned> (&player)) {
m_remotePlayers.erase(itor);
found = true;
break;
}
}
G_ASSERT(found);
display(cl_format("Player %1 leaved", p_name));
}
void TeamHolder::handleEvent(sf::Event& event){
switch(event.type){
case sf::Event::MouseButtonPressed: {
int x = event.mouseButton.x;
int y = event.mouseButton.y;
if(addPlayerButton.clicked(x, y)){
if(players.size() < maxPlayers){
PlayerHolder* player = new PlayerHolder("Player", _body.getPosition().x + 12, _body.getPosition().y + 4 + 73*players.size());
addPlayer(player);
}
}
for(int i = 0; i < players.size(); i++){
if(players.at(i)->removeButton.clicked(x, y)){
removePlayer(i);
}
}
break;
}
}
}
GHS_Lobby::~GHS_Lobby(void)
{
for(MAP_PLAYER_ITOR itor=m_players.begin();itor!=m_players.end();++itor)
{
if(itor->second)
removePlayer(itor->second->getSerial());
}
}
void Map::disconnect (ClientId clientId)
{
removePlayer(clientId);
_serviceProvider->getNetwork().disconnectClientFromServer(clientId);
if (_players.size() == 1 && _playersWaitingForSpawn.empty())
resetCurrentMap();
}
// Frees all memory previously allocated for the GameView toBeDeleted
void disposeGameView(GameView toBeDeleted)
{
//printf("called disposeGameView\n");
/*free(toBeDeleted->Lord_Godalming);
free(toBeDeleted->Dr_Seward);
free(toBeDeleted->Van_Helsing);
free(toBeDeleted->Mina_Harker);
free(toBeDeleted->Dracula);
free(toBeDeleted->europe);*/
removePlayer( toBeDeleted->Lord_Godalming );
removePlayer( toBeDeleted->Dr_Seward );
removePlayer( toBeDeleted->Van_Helsing );
removePlayer( toBeDeleted->Mina_Harker );
removePlayer( toBeDeleted->Dracula );
disposeMap( toBeDeleted->europe );
free( toBeDeleted );
}
void PlayerManager::removePlayer(Player* player)
{
if (player == nullptr)
{
error_log("failed to remove player, nullptr.");
return;
}
removePlayer(player->playerId());
}
void HostLobby::processPackets()
{
Packet *packet = network->getNextPacket();
while(packet != NULL)
{
int packetType = packet->getInt();
switch(packetType)
{
// These are all received by the host.
case msg_lobby_chat: {
std::string chatText = packet->getString();
std::string playerName = packet->getString();
messages.println(formatChatText(playerName, chatText));
// Now forward to clients...
Packet *chatPacket = new Packet(msg_lobby_chat);
chatPacket->putString(chatText);
chatPacket->putString(playerName);
network->sendToAll(chatPacket);
break;
}
case msg_join_lobby: {
if (!isFull())
{
std::string name = packet->getString();
addPlayer(name);
}
else
{
sendMessage("A player tried to join, but the game is full.");
int destNodeId = network->getLastNodeId();
Packet *joinFailed = new Packet(msg_join_failed);
network->sendTo(joinFailed, destNodeId);
network->getNode(destNodeId)->disconnect();
}
break;
}
case msg_disconnect: {
int nodeId = packet->getInt();
std::string name = packet->getString();
removePlayer(name);
network->getNode(nodeId)->disconnect();
sendMessage(name + " has left the game.");
break;
}
default:
logger.log("Lobby host unhandled msg: %d\n", packetType);
break;
}
delete packet;
packet = network->getNextPacket();
}
}
bool CLounge::logout(SOCKET sd,
CPlayer* player,
bool force)
{
if (force)
{ // will be logged out with no questions asked
removePlayer(player, force);
}
else
{
// XXX
// if player is not playing in any table,
// loggingOut_.push_back(PlayerPtr(player));
// else
// send CpduLogoutWarning
removePlayer(player);
}
return true;
}
bool Game::loseLife(Character* character, int life_lost)
{
character->setLife(character->life() - life_lost);
if (character->life() <= 0) {
ui->announce("The " + character->name() + " has perished!");
removePlayer(character);
return false;
}
return true;
}
void SetupScreen::playerSwitchRole(std::string uniqueId, std::string name, std::string oldRole, std::string newRole)
{
PlayerObj player;
player.uniqueId = uniqueId;
player.name = name;
player.role = oldRole;
removePlayer(player);
player.role = newRole;
updatePlayer(player);
}
//-----------------------------------------------------------------------------------------
//kick the player from the game if he's ran out of money
void dealerLib::kickBrokePlayer()
{
std::vector<player>::iterator playerIt;
//iterate through all players and check if they've lost then kick if true
for(playerIt = m_table.begin();playerIt != m_table.end(); playerIt++)
{
if(checkIfLost(*playerIt)) {removePlayer(playerIt);}
}
}
bool House::kickPlayer(Player* player, Player* target)
{
if(!target || target->isRemoved())
return false;
HouseTile* houseTile = target->getTile()->getHouseTile();
if(!houseTile || houseTile->getHouse() != this)
return false;
if(player == target)
{
removePlayer(target, true);
return true;
}
if(getHouseAccessLevel(player) >= getHouseAccessLevel(target))
{
removePlayer(target, false);
return true;
}
return false;
}
void PlayerSetupDialog::setupUI()
{
connect(ui->addPlayerBtn, SIGNAL(clicked()), this, SLOT(newPlayer()));
connect(ui->removePlayerBtn, SIGNAL(clicked()), this, SLOT(removePlayer()));
connect(ui->newSubviewBtn, SIGNAL(clicked()), this, SLOT(newSubview()));
connect(ui->delSubviewBtn, SIGNAL(clicked()), this, SLOT(removeSubview()));
connect(ui->testConnectionBtn, SIGNAL(clicked()), this, SLOT(testConnection()));
connect(ui->connectBtn, SIGNAL(clicked()), this, SLOT(connectPlayer()));
connect(ui->autoconnectBox, SIGNAL(toggled(bool)), this, SLOT(autoconBoxChanged(bool)));
connect(ui->playerListview, SIGNAL(activated(const QModelIndex &)), this, SLOT(playerSelected(const QModelIndex &)));
connect(ui->playerListview, SIGNAL(clicked(const QModelIndex &)), this, SLOT(playerSelected(const QModelIndex &)));
connect(ui->subviewListview, SIGNAL(activated(const QModelIndex &)), this, SLOT(subviewSelected(const QModelIndex &)));
connect(ui->subviewListview, SIGNAL(clicked(const QModelIndex &)), this, SLOT(subviewSelected(const QModelIndex &)));
connect(ui->aphaMaskBrowseBtn, SIGNAL(clicked()), this, SLOT(alphamaskBrowse()));
connect(ui->keyTLx, SIGNAL(valueChanged(int)), this, SLOT(subviewTopLeftXChanged(int)));
connect(ui->keyTLy, SIGNAL(valueChanged(int)), this, SLOT(subviewTopLeftYChanged(int)));
connect(ui->keyTRx, SIGNAL(valueChanged(int)), this, SLOT(subviewTopRightXChanged(int)));
connect(ui->keyTRy, SIGNAL(valueChanged(int)), this, SLOT(subviewTopRightYChanged(int)));
connect(ui->keyBLx, SIGNAL(valueChanged(int)), this, SLOT(subviewBottomLeftXChanged(int)));
connect(ui->keyBLy, SIGNAL(valueChanged(int)), this, SLOT(subviewBottomLeftYChanged(int)));
connect(ui->keyBRx, SIGNAL(valueChanged(int)), this, SLOT(subviewBottomRightXChanged(int)));
connect(ui->keyBRy, SIGNAL(valueChanged(int)), this, SLOT(subviewBottomRightYChanged(int)));
connect(ui->outputX, SIGNAL(valueChanged(int)), this, SLOT(screenXChanged(int)));
connect(ui->outputY, SIGNAL(valueChanged(int)), this, SLOT(screenYChanged(int)));
connect(ui->outputWidth, SIGNAL(valueChanged(int)), this, SLOT(screenWChanged(int)));
connect(ui->outputHeight, SIGNAL(valueChanged(int)), this, SLOT(screenHChanged(int)));
connect(ui->viewportX, SIGNAL(valueChanged(int)), this, SLOT(viewportXChanged(int)));
connect(ui->viewportY, SIGNAL(valueChanged(int)), this, SLOT(viewportYChanged(int)));
connect(ui->viewportWidth, SIGNAL(valueChanged(int)), this, SLOT(viewportWChanged(int)));
connect(ui->viewportHeight, SIGNAL(valueChanged(int)), this, SLOT(viewportHChanged(int)));
connect(ui->optIgnoreAR, SIGNAL(toggled(bool)), this, SLOT(ignoreArBoxChanged(bool)));
connect(ui->aphaMaskBrowseBtn, SIGNAL(clicked()), this, SLOT(alphamaskBrowse()));
connect(ui->alphaMaskFile, SIGNAL(textChanged(QString)), this, SLOT(showAlphaMaskPreview(QString)));
connect(ui->brightnessResetBtn, SIGNAL(clicked()), this, SLOT(brightReset()));
connect(ui->contrastResetBtn, SIGNAL(clicked()), this, SLOT(contReset()));
connect(ui->hueResetBtn, SIGNAL(clicked()), this, SLOT(hueReset()));
connect(ui->saturationResetBtn, SIGNAL(clicked()), this, SLOT(satReset()));
}
bool Server_Game::kickPlayer(int playerId)
{
QMutexLocker locker(&gameMutex);
Server_Player *playerToKick = players.value(playerId);
if (!playerToKick)
return false;
GameEventContainer *gec = prepareGameEvent(Event_Kicked(), -1);
playerToKick->sendGameEvent(*gec);
delete gec;
removePlayer(playerToKick);
return true;
}
bool House::kickPlayer(Player* player, Player* target)
{
if(!target || target->isRemoved())
return false;
HouseTile* houseTile = target->getTile()->getHouseTile();
if(!houseTile || houseTile->getHouse() != this)
return false;
bool self = player == target;
if(getHouseAccessLevel(player) < getHouseAccessLevel(target) && !self)
return false;
removePlayer(target, self);
return true;
}
err_t Room::leavePlayer(Player* player)
{
Player* old = removePlayer(player->pid());
err_t err = 0;
if (!old)
{
err = MSG_ERR_NOT_IN_ROOM_1003;
}
else if (old != player)
{
//??
}
else
{
}
return err;
}
void IRoom::playerDoLeaveRoom( stStandPlayer* pp )
{
// send msg to data svr tell player leave room ;
if ( pp )
{
if ( getDelegate() )
{
getDelegate()->onPlayerWillDoLeaveRoom(this,pp) ;
}
LOGFMTD("uid = %d , do leave this room ",pp->nUserUID) ;
removePlayer(pp);
}
else
{
LOGFMTE("player , not in this room can not do leave room" ) ;
}
}
//
// Table accepted the player - seat him.
//
void CWaitingList::seatPlayer(CPlayer* player, CTable* table)
{
// Remove player from waiting list
bool rc = removePlayer(*player);
// broadcast queue update
if (rc)
{
CpduQueueUpdate pdu;
pdu.sendQueueServiced(getQueueNumber(), player);
}
CpduSitting pdu;
pdu.sendSitting(player,
table->getNumber(),
table->getPort(),
table->getAddr());
}
void Maps::changeMap(Player* player, int mapid, int pos){
removePlayer(player);
player->setMap(mapid);
player->setMappos(pos);
player->setType(0);
player->setChair(0);
Pos cpos;
if((unsigned int)pos<info[mapid].Portals.size()){
cpos.x = info[mapid].Portals[pos].x;
cpos.y = info[mapid].Portals[pos].y;
}
else if(info[mapid].Portals.size() > 0){
cpos.x = info[mapid].Portals[0].x;
cpos.y = info[mapid].Portals[0].y;
}
else{
cpos.x = 0;
cpos.y = 0;
}
player->setPos(cpos);
MapPacket::changeMap(player);
newMap(player);
}
void GameManager::handleCollision( Player &player, const char &collisionSign )
{
// TODO - handle to players that jump against each other - this is a collision.
switch (collisionSign)
{
case FOOD_SIGN:
player.setPower(player.getPower() + 200);
break;
case ARROWS_SIGN:
player.setArrowsCount(player.getArrowsCount() + 3);
break;
case BOOM_SIGN:
player.setPower(player.getPower() - 750);
break;
}
if (player.getPower() <= 0)
{
removePlayer(&player);
}
m_gameBoard.printSummary();
}
err_t Room::enterPlayer(Player* player)
{
Player* old = removePlayer(player->pid());
err_t err = 0;
if (!old)
{
addPlayer(player->pid(),player);
}
else if (old == player)
{
err = MSG_ERR_ALREADY_IN_1002;
}
else//log in different places. to do
{
addPlayer(player->pid(), player);
old;//to do something;
}
if (!err)
{
player->setChanelId(nCid);
}
return err;
}
void House::removePlayers(bool ignoreInvites)
{
PlayerVector kickList;
for(HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it)
{
CreatureVector* creatures = (*it)->getCreatures();
if(!creatures)
continue;
Player* player = NULL;
for(CreatureVector::iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if((player = (*cit)->getPlayer()) && !player->isRemoved()
&& (ignoreInvites || !isInvited(player)))
kickList.push_back(player);
}
}
if(kickList.empty())
return;
for(PlayerVector::iterator it = kickList.begin(); it != kickList.end(); ++it)
removePlayer((*it), false);
}
inline void removePlayer(const std::string& playerName)
{ removePlayer(getPlayer(playerName)); }
inline void removePlayer(const PlayerPtr player)
{ removePlayer(player ? player->getID() : 0); }
bool CLounge::logoutCertain(SOCKET sd,
CPlayer* player)
{
removePlayer(player);
return true;
}
void removePlayerFromRoom(Room room, Player player) {
removePlayer(room->playerList, player);
}
