void House::cleanHouse()
{
transferToDepot();
PlayerVector to_kick;
HouseTile* houseTile;
for(HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it){
houseTile = (*it);
for(CreatureConstIterator cit = houseTile->creatures_begin(); cit != houseTile->creatures_end(); ++cit){
if((*cit)->getPlayer()){
to_kick.push_back((*cit)->getPlayer());
}
}
}
while(!to_kick.empty()){
Player* c = to_kick.back();
to_kick.pop_back();
kickPlayer(NULL, c->getName());
}
// we need to remove players from beds
for(HouseBedItemList::iterator it = bedsList.begin(); it != bedsList.end(); ++it){
if((*it)->getSleeper() != 0){
(*it)->wakeUp();
}
}
}
void House::setAccessList(uint32_t listId, const std::string& textlist)
{
if (listId == GUEST_LIST) {
guestList.parseList(textlist);
} else if (listId == SUBOWNER_LIST) {
subOwnerList.parseList(textlist);
} else {
Door* door = getDoorByNumber(listId);
if (door) {
door->setAccessList(textlist);
}
// We dont have kick anyone
return;
}
//kick uninvited players
for (HouseTile* tile : houseTiles) {
if (CreatureVector* creatures = tile->getCreatures()) {
for (int32_t i = creatures->size(); --i >= 0;) {
Player* player = (*creatures)[i]->getPlayer();
if (player && !isInvited(player)) {
kickPlayer(nullptr, player);
}
}
}
}
}
void House::cleanHouse()
{
transferToDepot();
PlayerVector to_kick;
for(HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it) {
for(uint32_t i = 0; i < (*it)->getThingCount(); ++i) {
Creature* creature = (*it)->__getThing(i)->getCreature();
if(creature != NULL && creature->getPlayer()) {
to_kick.push_back(creature->getPlayer());
}
}
}
while(to_kick.empty() == false) {
Player* c = to_kick.back();
to_kick.pop_back();
kickPlayer(NULL, c->getName());
}
// we need to remove players from beds
HouseBedItemList::iterator bit;
for(bit = bedsList.begin(); bit != bedsList.end(); ++bit) {
if((*bit)->getSleeper() != 0) {
(*bit)->wakeUp(NULL);
}
}
}
bool my::GateServer::kickConnection(ConnectionPtr conn)
{
int netId = conn->getNetId();
if (netId < 0)
{
//server, don't do anything stupid
}
else
{
boost::recursive_mutex::scoped_lock lock(mtx);
ConnectionMap::iterator it = m_ConnMap.find(netId);
if (it != m_ConnMap.end())
{
ConnectionPtr tmpConn = it->second;
m_ConnMap.erase(it);//应检查conn和tmpConn是否相同
m_nConnCount--;
int playerId = conn->getPlayerId();
kickPlayer(playerId, netId);
tmpConn->stop();
LogD << "erase from connMap" << LogEnd;
return true;
}
}
return false;
}
void House::setHouseOwner(uint32_t guid)
{
if(isLoaded && houseOwner == guid)
return;
isLoaded = true;
if(houseOwner){
//send items to depot
transferToDepot();
PlayerVector to_kick;
for(HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it){
for(uint32_t i = 0; i < (*it)->getThingCount(); ++i){
Creature* creature = (*it)->__getThing(i)->getCreature();
if(creature != NULL && creature->getPlayer())
to_kick.push_back(creature->getPlayer());
}
}
while(to_kick.empty() == false) {
Player* c = to_kick.back();
to_kick.pop_back();
kickPlayer(NULL, c->getName());
}
// we need to remove players from beds
HouseBedItemList::iterator bit;
for(bit = bedsList.begin(); bit != bedsList.end(); ++bit) {
if((*bit)->getSleeper() != 0) {
(*bit)->wakeUp(NULL);
}
}
//clean access lists
houseOwner = 0;
setAccessList(SUBOWNER_LIST, "");
setAccessList(GUEST_LIST, "");
for(HouseDoorList::iterator it = doorList.begin(); it != doorList.end(); ++it){
(*it)->setAccessList("");
}
//reset paid date
paidUntil = 0;
rentWarnings = 0;
}
std::string name;
if(guid != 0 && IOPlayer::instance()->getNameByGuid(guid, name)){
houseOwner = guid;
houseOwnerName = name;
}
updateDoorDescription();
setLastWarning(std::time(NULL)); //So the new owner has one day before he start the payment
}
// ////////////////////////////////////////////////////////////////////////////
// A Remote Player has joined the game.
bool MultiPlayerJoin(UDWORD playerIndex)
{
if(widgGetFromID(psWScreen,IDRET_FORM)) // if ingame.
{
audio_QueueTrack( ID_CLAN_ENTER );
}
if(widgGetFromID(psWScreen,MULTIOP_PLAYERS)) // if in multimenu.
{
if (!multiRequestUp && (bHosted || ingame.localJoiningInProgress))
{
addPlayerBox(true); // update the player box.
}
}
if(NetPlay.isHost) // host responsible for welcoming this player.
{
// if we've already received a request from this player don't reallocate.
if (ingame.JoiningInProgress[playerIndex])
{
return true;
}
ASSERT(NetPlay.playercount <= MAX_PLAYERS, "Too many players!");
// setup data for this player, then broadcast it to the other players.
setupNewPlayer(playerIndex); // setup all the guff for that player.
if (bHosted)
{
sendOptions();
}
// if skirmish and game full, then kick...
if (NetPlay.playercount > game.maxPlayers)
{
kickPlayer(playerIndex, "the game is already full.", ERROR_FULL);
}
// send everyone's stats to the new guy
{
int i;
for (i = 0; i < MAX_PLAYERS; i++)
{
if (NetPlay.players[i].allocated)
{
setMultiStats(i, getMultiStats(i), false);
}
}
}
}
return true;
}
bool recvDataCheck(NETQUEUE queue)
{
int i = 0;
uint32_t player = queue.index;
uint32_t tempBuffer[DATA_MAXDATA] = {0};
NETbeginDecode(queue, NET_DATA_CHECK);
for(i = 0; i < DATA_MAXDATA; i++)
{
NETuint32_t(&tempBuffer[i]);
}
NETend();
if (player >= MAX_PLAYERS) // invalid player number.
{
debug(LOG_ERROR, "invalid player number (%u) detected.", player);
return false;
}
debug(LOG_NET, "** Received NET_DATA_CHECK from player %u", player);
if (NetPlay.isHost)
{
if (memcmp(DataHash, tempBuffer, sizeof(DataHash)))
{
char msg[256] = {'\0'};
for (i=0; i<DATA_MAXDATA; i++)
{
if (DataHash[i] != tempBuffer[i]) break;
}
sprintf(msg, _("%s (%u) has an incompatible mod, and has been kicked."), getPlayerName(player), player);
sendTextMessage(msg, true);
addConsoleMessage(msg, LEFT_JUSTIFY, NOTIFY_MESSAGE);
kickPlayer(player, "your data doesn't match the host's!", ERROR_WRONGDATA);
debug(LOG_WARNING, "%s (%u) has an incompatible mod. ([%d] got %x, expected %x)", getPlayerName(player), player, i, tempBuffer[i], DataHash[i]);
debug(LOG_POPUP, "%s (%u), has an incompatible mod. ([%d] got %x, expected %x)", getPlayerName(player), player, i, tempBuffer[i], DataHash[i]);
return false;
}
else
{
debug(LOG_NET, "DataCheck message received and verified for player %s (slot=%u)", getPlayerName(player), player);
ingame.DataIntegrity[player] = true;
}
}
return true;
}
void HandleBadParam(const char *msg, const int from, const int actual)
{
char buf[255];
LOBBY_ERROR_TYPES KICK_TYPE = ERROR_INVALID;
ssprintf(buf, "!!>Msg: %s, Actual: %d, Bad: %d", msg, actual, from);
NETlogEntry(buf, SYNC_FLAG, actual);
if (NetPlay.isHost)
{
ssprintf(buf, "Auto kicking player %s, invalid command received.", NetPlay.players[actual].name);
sendTextMessage(buf, true);
kickPlayer(actual, buf, KICK_TYPE);
}
}
void House::setOwner(uint32_t guid, bool updateDatabase/* = true*/, Player* player/* = nullptr*/)
{
if (updateDatabase && owner != guid) {
Database* db = Database::getInstance();
std::ostringstream query;
query << "UPDATE `houses` SET `owner` = " << guid << ", `bid` = 0, `bid_end` = 0, `last_bid` = 0, `highest_bidder` = 0 WHERE `id` = " << id;
db->executeQuery(query.str());
}
if (isLoaded && owner == guid) {
return;
}
isLoaded = true;
if (owner != 0) {
//send items to depot
if (player) {
transferToDepot(player);
} else {
transferToDepot();
}
for (HouseTile* tile : houseTiles) {
if (const CreatureVector* creatures = tile->getCreatures()) {
for (int32_t i = creatures->size(); --i >= 0;) {
kickPlayer(nullptr, (*creatures)[i]->getPlayer());
}
}
}
// Remove players from beds
for (BedItem* bed : bedsList) {
if (bed->getSleeper() != 0) {
bed->wakeUp(nullptr);
}
}
//clean access lists
owner = 0;
setAccessList(SUBOWNER_LIST, "");
setAccessList(GUEST_LIST, "");
for (Door* door : doorList) {
door->setAccessList("");
}
//reset paid date
paidUntil = 0;
rentWarnings = 0;
}
std::string name;
if (guid != 0 && IOLoginData::getNameByGuid(guid, name)) {
owner = guid;
ownerName = name;
}
updateDoorDescription();
}
void House::setHouseOwner(uint32_t guid, bool updateDatabase/* = true*/, Player* player/* = NULL*/)
{
if (updateDatabase) {
Database* db = Database::getInstance();
std::ostringstream query;
query << "UPDATE `houses` SET `owner` = " << guid << " WHERE `id` = " << houseid;
db->executeQuery(query.str());
}
if (isLoaded && houseOwner == guid) {
return;
}
isLoaded = true;
if (houseOwner) {
//send items to depot
if (player) {
transferToDepot(player);
} else {
transferToDepot();
}
PlayerVector toKick;
for (HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it) {
if (const CreatureVector* creatures = (*it)->getCreatures()) {
for (CreatureVector::const_iterator cit = creatures->begin(), cend = creatures->end(); cit != cend; ++cit) {
Player* player = (*cit)->getPlayer();
if (player) {
toKick.push_back(player);
}
}
}
}
while (!toKick.empty()) {
Player* c = toKick.back();
toKick.pop_back();
kickPlayer(NULL, c->getName());
}
// we need to remove players from beds
HouseBedItemList::iterator bit;
for (bit = bedsList.begin(); bit != bedsList.end(); ++bit) {
if ((*bit)->getSleeper() != 0) {
(*bit)->wakeUp(NULL);
}
}
//clean access lists
houseOwner = 0;
setAccessList(SUBOWNER_LIST, "");
setAccessList(GUEST_LIST, "");
for (HouseDoorList::iterator it = doorList.begin(); it != doorList.end(); ++it) {
(*it)->setAccessList("");
}
//reset paid date
paidUntil = 0;
rentWarnings = 0;
}
std::string name;
if (guid != 0 && IOLoginData::getInstance()->getNameByGuid(guid, name)) {
houseOwner = guid;
houseOwnerName = name;
}
updateDoorDescription();
}
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// MultiPlayer main game loop code.
bool multiPlayerLoop(void)
{
UDWORD i;
UBYTE joinCount;
joinCount =0;
for(i=0;i<MAX_PLAYERS;i++)
{
if(isHumanPlayer(i) && ingame.JoiningInProgress[i] )
{
joinCount++;
}
}
if(joinCount)
{
setWidgetsStatus(false);
bDisplayMultiJoiningStatus = joinCount; // someone is still joining! say So
// deselect anything selected.
selDroidDeselect(selectedPlayer);
if(keyPressed(KEY_ESC) )// check for cancel
{
bDisplayMultiJoiningStatus = 0;
setWidgetsStatus(true);
setPlayerHasLost(true);
}
}
else //everyone is in the game now!
{
if(bDisplayMultiJoiningStatus)
{
bDisplayMultiJoiningStatus = 0;
setWidgetsStatus(true);
}
if (!ingame.TimeEveryoneIsInGame)
{
ingame.TimeEveryoneIsInGame = gameTime;
debug(LOG_NET, "I have entered the game @ %d", ingame.TimeEveryoneIsInGame );
if (!NetPlay.isHost)
{
debug(LOG_NET, "=== Sending hash to host ===");
sendDataCheck();
}
}
if (NetPlay.bComms)
{
sendPing();
}
// Only have to do this on a true MP game
if (NetPlay.isHost && !ingame.isAllPlayersDataOK && NetPlay.bComms)
{
if (gameTime - ingame.TimeEveryoneIsInGame > GAME_TICKS_PER_SEC * 60)
{
// we waited 60 secs to make sure people didn't bypass the data integrity checks
int index;
for (index=0; index < MAX_PLAYERS; index++)
{
if (ingame.DataIntegrity[index] == false && isHumanPlayer(index) && index != NET_HOST_ONLY)
{
char msg[256] = {'\0'};
sprintf(msg, _("Kicking player %s, because they tried to bypass data integrity check!"), getPlayerName(index));
sendTextMessage(msg, true);
addConsoleMessage(msg, LEFT_JUSTIFY, NOTIFY_MESSAGE);
NETlogEntry(msg, SYNC_FLAG, index);
#ifndef DEBUG
kickPlayer(index, "invalid data!", ERROR_INVALID);
#endif
debug(LOG_WARNING, "Kicking Player %s (%u), they tried to bypass data integrity check!", getPlayerName(index), index);
}
}
ingame.isAllPlayersDataOK = true;
}
}
}
// if player has won then process the win effects...
if(testPlayerHasWon())
{
multiplayerWinSequence(false);
}
return true;
}
// ////////////////////////////////////////////////////////////////////////////
// process clicks made by user.
void intProcessMultiMenu(UDWORD id)
{
UBYTE i;
//close
if (id == MULTIMENU_CLOSE)
{
intCloseMultiMenu();
}
//alliance button
if(id >=MULTIMENU_ALLIANCE_BASE && id<MULTIMENU_ALLIANCE_BASE+MAX_PLAYERS)
{
i =(UBYTE)( id - MULTIMENU_ALLIANCE_BASE);
switch(alliances[selectedPlayer][i])
{
case ALLIANCE_BROKEN:
requestAlliance((UBYTE)selectedPlayer,i,true,true); // request an alliance
break;
case ALLIANCE_INVITATION:
formAlliance((UBYTE)selectedPlayer,i,true,true,true); // form an alliance
break;
case ALLIANCE_REQUESTED:
breakAlliance((UBYTE)selectedPlayer,i,true,true); // break an alliance
break;
case ALLIANCE_FORMED:
breakAlliance((UBYTE)selectedPlayer,i,true,true); // break an alliance
break;
default:
break;
}
}
//channel opens.
if(id >=MULTIMENU_CHANNEL && id<MULTIMENU_CHANNEL+MAX_PLAYERS)
{
i = id - MULTIMENU_CHANNEL;
openchannels[i] = !openchannels[i];
if(mouseDown(MOUSE_RMB) && NetPlay.isHost) // both buttons....
{
char buf[250];
// Allow the host to kick the AI only in a MP game, or if they activated cheats in a skirmish game
if ((NetPlay.bComms || Cheated) && (NetPlay.players[i].allocated || (NetPlay.players[i].allocated == false && NetPlay.players[i].ai != AI_OPEN)))
{
inputLoseFocus();
ssprintf(buf, _("The host has kicked %s from the game!"), getPlayerName((unsigned int) i));
sendTextMessage(buf, true);
ssprintf(buf, _("kicked %s : %s from the game, and added them to the banned list!"), getPlayerName((unsigned int) i), NetPlay.players[i].IPtextAddress);
NETlogEntry(buf, SYNC_FLAG, (unsigned int) i);
kickPlayer((unsigned int) i, "you are unwanted by the host.", ERROR_KICKED);
return;
}
}
}
//radar gifts
if(id >= MULTIMENU_GIFT_RAD && id< MULTIMENU_GIFT_RAD +MAX_PLAYERS)
{
sendGift(RADAR_GIFT, id - MULTIMENU_GIFT_RAD);
}
// research gift
if(id >= MULTIMENU_GIFT_RES && id<MULTIMENU_GIFT_RES +MAX_PLAYERS)
{
sendGift(RESEARCH_GIFT, id - MULTIMENU_GIFT_RES);
}
//droid gift
if(id >= MULTIMENU_GIFT_DRO && id< MULTIMENU_GIFT_DRO +MAX_PLAYERS)
{
sendGift(DROID_GIFT, id - MULTIMENU_GIFT_DRO);
}
//power gift
if(id >= MULTIMENU_GIFT_POW && id< MULTIMENU_GIFT_POW +MAX_PLAYERS)
{
sendGift(POWER_GIFT, id - MULTIMENU_GIFT_POW);
}
}
