/* Creates one Gamer and "computers" number of Ai */
void Model::createPlayers(const int &computers) {
printf("Creating players...");
players.clear();
players.reserve(computers+1);
addPlayer(new Gamer(this,0,0));
int w = MAP_SIZE-1, h = w;
for (int i=0;i<computers;++i) {
addPlayer(new Ai(this,w,h));
printf("\nNew Ai added at: x=%d y=%d \n",w,h);
w -= FIELD_SIZE;
if (w<0) {
w = MAP_SIZE-1;
h -= FIELD_SIZE;
if (h<0)
h = MAP_SIZE-2-i;
}
}
printf("Done\n");
}
/// 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;
}
}
CGarrisonDialogQuery::CGarrisonDialogQuery(const CArmedInstance *up, const CArmedInstance *down)
{
exchangingArmies[0] = up;
exchangingArmies[1] = down;
addPlayer(up->tempOwner);
addPlayer(down->tempOwner);
}
void newGame(S_game* aGame, char* playerName1, E_pawn pawnType1, char* playerName2, E_pawn pawnType2)
{
initGrid(aGame);
aGame->nbPlayers = 0;
aGame->whoMustPlay = P1;
addPlayer(aGame, playerName1, pawnType1);
addPlayer(aGame, playerName2, pawnType2);
}
//*****************************************************************************
// PUBLIC CONSTRUCTOR : Game
//*****************************************************************************
Game::Game(PlayerChoice whitePlayer, PlayerChoice blackPlayer):
_players()
{
// create the board
_board = new Board();
// create the view
_view = new AsciiView(_board);
// And now, the players!
addPlayer(whitePlayer, Board::WHITE_PIECE);
addPlayer(blackPlayer, Board::BLACK_PIECE);
}
bool AccessList::parseList(const std::string& _list)
{
playerList.clear();
guildList.clear();
expressionList.clear();
regExList.clear();
list = _list;
if(_list == "")
return true;
std::istringstream listStream(_list);
std::string line;
while(getline(listStream, line))
{
trimString(line);
trim_left(line, "\t");
trim_right(line, "\t");
trimString(line);
std::transform(line.begin(), line.end(), line.begin(), tolower);
if(line.substr(0,1) == "#" || line.length() > 100)
continue;
if(line.find("@") != std::string::npos)
{
std::string::size_type pos = line.find("@");
addGuild(line.substr(pos + 1), "");
}
else if(line.find("!") != std::string::npos || line.find("*") != std::string::npos || line.find("?") != std::string::npos)
addExpression(line);
else
addPlayer(line);
}
return true;
}
void Manager::handlePaquet(const PaquetCreateParty_SharedPtr &&paquet, const Addr &addr)
{
const std::string &name = paquet->getName();
DEBUG_MSG(*paquet);
auto &&party = _parties.findIn([&name] (auto &p) { return (p->getName() == name); });
auto &&player = _pWaiting.findIn([&addr] (auto &p) { return (p->addr() == addr); });
PaquetResponse p;
if (!party && player && name.size()) {
auto party = std::make_shared<Party>(shared_from_this(), name);
party->addPlayer(player);
_pWaiting.remove(player);
_parties.push_back(party);
p.setReturn(4);
}
else {
p.setReturn(3);
#ifdef DEBUG
if (party) {
std::cerr << "CreateParty: Party already exist" << std::endl;
}
if (!player) {
std::cerr << "CreateParty: Can't find player. Already in Game ?" << std::endl;
}
#endif // !DEBUG
}
p.createPaquet();
write(p, addr);
}
void Team::serialize(In* in, Out* out)
{
STREAM_REGISTER_BEGIN
STREAM(name);
STREAM(number);
STREAM(port);
STREAM(color);
STREAM(location);
STREAM(buildConfig);
STREAM(wlanConfig);
STREAM(volume);
STREAM(deployDevice);
std::vector<std::string> players;
if(out)
{
std::vector<Robot*> robots = getPlayersWrapped();
for(Robot* r : robots)
players.push_back(r ? r->name : "_");
}
STREAM(players);
if(in)
{
std::map<std::string, Robot*> robots = Session::getInstance().robotsByName;
for(size_t i = 0; i < players.size(); ++i)
if(players[i] != "_")
addPlayer(i % MAX_PLAYERS, i / MAX_PLAYERS, *robots[players[i]]);
}
STREAM_REGISTER_FINISH
}
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;
}
}
}
bool GameScene::init(){
Size visibleSize = Director::getInstance()->getVisibleSize();
Point origin = Director::getInstance()->getVisibleOrigin();
auto sprite = Sprite::create("bj2.jpg");
sprite->setPosition(Point(visibleSize.width/2 + origin.x, visibleSize.height/2 + origin.y));
this->addChild(sprite, -4);
auto bg1 = Sprite::create("b2.png");
bg1->setAnchorPoint(Point(0, 0));
bg1->setPosition(Point(0, 10));
this->addChild(bg1, -3);
auto bg2 = Sprite::create("b2.png");
bg2->setAnchorPoint(Point(0, 0));
bg2->setPosition(Point(bg1->getContentSize().width, 10));
this->addChild(bg2, -3);
distanceBg.pushBack(bg1);
distanceBg.pushBack(bg2);
auto bg3 = Sprite::create("b1.png");
bg3->setAnchorPoint(Point(0, 0));
bg3->setPosition(Point(0, 0));
this->addChild(bg3, -2);
auto bg4 = Sprite::create("b1.png");
bg4->setAnchorPoint(Point(0, 0));
bg4->setPosition(bg3->getContentSize().width, 0);
this->addChild(bg4, -2);
nearbyBg.pushBack(bg3);
nearbyBg.pushBack(bg4);
ParticleSystemQuad *emiter = ParticleSystemQuad::create("dirt.plist");
emiter->setPosition(visibleSize.width/2, visibleSize.height/2);
this->addChild(emiter, -3);
map = TMXTiledMap::create("map.tmx");
map->setAnchorPoint(Point(0, 0));
map->setPosition(Point(0, 0));
this->addChild(map, -1);
addPlayer(map);
addHeart(map);
playFlyToScene();
Node *ground = Node::create();
float width = map->getContentSize().width;
float height = map->getContentSize().height * 3 / 16;
auto bottomBody = PhysicsBody::createEdgeSegment(Point(0, height), Point(width, height));
ground->setPhysicsBody(bottomBody);
this->addChild(ground);
return true;
}
void Maps::newMap(Player* player){
Players::addPlayer(player);
NPCs::showNPCs(player);
addPlayer(player);
Mobs::showMobs(player);
Drops::showDrops(player);
timer->setMapTimer(player->getMap());
}
void FightMediator::OnEvent_AddPlayer( cocos2d::CCObject* sender,int msgid,cocos2d::CCObject* obj )
{
if (m_Layer)
{
EventParam* ep=(EventParam*)obj;
addPlayer(ep->intParam);
}
}
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();
}
}
CBattleQuery::CBattleQuery(const BattleInfo *Bi)
{
belligerents[0] = Bi->sides[0].armyObject;
belligerents[1] = Bi->sides[1].armyObject;
bi = Bi;
for(auto &side : bi->sides)
addPlayer(side.color);
}
void addItemsToInfoWindow(InfoInterface *gui) {
// creates horizontal box to hold everything
GtkWidget *parentHbox;
parentHbox = gtk_hbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (gui->window), parentHbox);
// adds timer, hints and input text boxes
addPlayer(&(gui->playerLabel), parentHbox);
addInfoLabel(gui, parentHbox);
addQuitButton(gui, parentHbox);
}
//************************************
// Method: initGame -initialize a new game
// FullName: Game::initGame
// Access: private
// Returns: void
// Qualifier:
//************************************
void Game::initGame()
{
m_endGame=false;
m_numberOfRounds=0;
int shuffleDepth;
UIs::UI::plotWelcomeScreen();
char* userName=NULL;
int numOfJokers=UIs::UI::getMainScreenUserInput(m_numberOfplayers,shuffleDepth,userName);
m_gameDeck.shuffle(shuffleDepth);
addPlayer(userName,true);//add a human player
delete []userName;//a copy is made in player- release the allocation
char name[6]="comp";
name[5]='\0';
for (unsigned int i=1; i<m_numberOfplayers; i++)//define computer players
{
name[4]='0'+i;
addPlayer(name); //Add a computer player
}
m_lastWinner=rand()%m_numberOfplayers;//decide who starts(since there is only one human player he starts at a random place and the computer order doesn't count)
}
Game::Game(const int newPlayers) {
numGames++;
if(numGames > 1) {
throw game_singleton_err();
}
srand( time(NULL) );
numPlayers = 0;
playerList = new Player[newPlayers + 1 /* the bank */];
addPlayer("Bank");
}
void Game::starNewGame(Player* player1, Player* player2, bool restart)
{
CCScene *pScene = GameLayer::scene();
GameLayer* gameLayer = (GameLayer*)pScene->getChildByTag(1337);
if(!restart) {
addPlayer(player1);
addPlayer(player2);
}
gameLayer->startGame(player1, player2);
if(CCDirector::sharedDirector()->getRunningScene()){
CCDirector::sharedDirector()->replaceScene(pScene);
}else{
CCDirector::sharedDirector()->runWithScene(pScene);
}
setCurrentScreen(GAME_SCREEN);
currentGameType = player2->isAI() ? VS_AI : VS_HUMAN;
}
Player *Game::addPlayer(const QUuid &uuid, const QString &name) {
Player *player = new Player(uuid, name, this);
Player *addedPlayer = addPlayer(player);
if (addedPlayer != player) {
delete player;
return addedPlayer;
}
return player;
}
/**
* Handles mouse up events
*/
void WindowPlayers::mouseUp(SDL_MouseButtonEvent button) {
//Find out if a button was hit
UIComponent *component = findComponent(button.x, button.y);
//'Start game' button
if (component == buttonStart) {
this->sounds.playSound(SOUND_CLICK);
this->startGame();
}
//'Add player' button
else if (component == butAdd) {
addPlayer();
}
//Player type (increase)
else if (component == butIncrType) {
newPlayerType++;
if (newPlayerType > 3)
newPlayerType = 0;
this->sounds.playSound(SOUND_CLICK);
updatePlayerType();
}
//Player type (decrease)
else if (component == butDecrType) {
newPlayerType--;
if (newPlayerType < 0)
newPlayerType = 3;
this->sounds.playSound(SOUND_CLICK);
updatePlayerType();
}
//'Remove all' button
else if (component == butRemoveAll) {
gameEngine.removeAllPlayers();
this->humanNumbering = 1;
this->aiNumbering = 1;
this->playerCount = 0;
this->sounds.playSound(SOUND_TICK);
updatePlayers();
}
redraw();
}
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;
}
bool TollgateScene::init()
{
if (!Layer::init()) {
return false;
}
TMXTiledMap* map = TMXTiledMap::create("level01.tmx");
this->addChild(map);
//加载玩家
addPlayer(map);
return true;
}
void IntoGame(Game * g, Player * p)
{
if (p == NULL || g == NULL)
return;
if (p->game != NULL && p->game == g)
return;
if (p->game == NULL)
delNilPlayer(p);
else
delPlayer(p);
addPlayer(g, p);
}
Player* PlayerManager::createPlayer(uint64 playerId, GameSession* session)
{
if (session != nullptr)
{
Player* player = _playerPool.acquire(playerId, session);
if (player != nullptr)
{
addPlayer(player);
}
return player;
}
return nullptr;
}
MprisControlPlugin::MprisControlPlugin(QObject* parent, const QVariantList& args)
: KdeConnectPlugin(parent, args)
, prevVolume(-1)
{
m_watcher = new QDBusServiceWatcher("org.mpris.MediaPlayer2", QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this);
connect(m_watcher, &QDBusServiceWatcher::serviceRegistered, this, &MprisControlPlugin::addPlayer);
connect(m_watcher, &QDBusServiceWatcher::serviceUnregistered, this, &MprisControlPlugin::removePlayer);
//Add existing interfaces
QStringList interfaces = QDBusConnection::sessionBus().interface()->registeredServiceNames().value();
Q_FOREACH (const QString& iface, interfaces) {
if (iface.startsWith("org.mpris.MediaPlayer2")) {
addPlayer(iface);
}
}
}
void OnlineRaceLogic::onGameState(const Net::GameState &p_gameState)
{
// load level
const CL_String &levelName = p_gameState.getLevel();
getLevel().initialize();
getLevel().load(levelName);
// initialize progress object
getProgress().initialize();
getProgress().resetClock();
// add rest of players
const unsigned playerCount = p_gameState.getPlayerCount();
Player *player;
Car *car;
for (unsigned i = 0; i < playerCount; ++i) {
const CL_String &playerName = p_gameState.getPlayerName(i);
if (playerName == m_localPlayer.getName()) {
// this is local player, so it exists now
player = &m_localPlayer;
} else {
// this is remote player
m_remotePlayers.push_back(
CL_SharedPtr<RemotePlayer>(new RemotePlayer(playerName))
);
player = m_remotePlayers.back();
}
// put player to player list
addPlayer(player);
// prepare car and put it to level
car = &player->getCar();
car->deserialize(p_gameState.getCarState(i).getSerializedData());
getLevel().addCar(&player->getCar());
}
}
void MainWindow::createActions() {
// exit app
exitAct = new QAction(tr("E&xit"), this);
exitAct->setShortcuts(QKeySequence::Quit);
exitAct->setStatusTip(tr("Esci da applicazione"));
connect(exitAct, SIGNAL( triggered() ), this, SLOT(close()));
// Aggiungi Personaggio
addPersAct = new QAction(tr("Aggiungi nuovo"), this);
addPersAct -> setStatusTip(tr("Avvia creatore di Personaggio"));
connect(addPersAct, SIGNAL(triggered()), this, SLOT(addPlayer()));
// Rimuovi personaggio
rmPersAct = new QAction(tr("Rimuovi"), this);
rmPersAct -> setStatusTip(tr("Scegli e Rimuovi un personaggio"));
connect(rmPersAct, SIGNAL(triggered()), this, SLOT(delPlayer()));
// Edit Database
editTableAbilitaAct = new QAction(tr("Abilita"), this);
editTableAbilitaAct -> setStatusTip(tr("Mostra e Modifica le Abilita"));
editTableTrucchiAct = new QAction(tr("Trucchi"), this);
editTableTrucchiAct -> setStatusTip(tr("Mostra e Modifica i Trucchi"));
editTableDmgAct = new QAction(tr("Danni"), this);
editTableDmgAct -> setStatusTip(tr("Mostra e Modifica i tipi del danno"));
editTableItemsAct = new QAction(tr("Oggetti"), this);
editTableItemsAct -> setStatusTip(tr("Mostra e Modifica i oggetti"));
connect(editTableAbilitaAct, SIGNAL(triggered()), this, SLOT(editTableAbilita()));
connect(editTableTrucchiAct, SIGNAL(triggered()), this, SLOT(editTableTrucchi()));
connect(editTableDmgAct, SIGNAL(triggered()), this, SLOT(editTableDmg()));
connect(editTableItemsAct, SIGNAL(triggered()), this, SLOT(editTableItems()));
// About
aboutAct = new QAction(tr("&About"), this);
aboutAct->setStatusTip(tr("Su applicazione"));
connect(aboutAct, SIGNAL( triggered() ), this, SLOT(about()));
// About Qt
aboutQtAct = new QAction(tr("Su &Qt"), this);
aboutQtAct->setStatusTip(tr("Informazioni su Qt"));
connect(aboutQtAct, SIGNAL( triggered() ), qApp, SLOT(aboutQt()));
}
void GamePan::doOpen()
{
GUIBase::doOpen();
isCheckWin=false;
_isPlayer = true;
addNpc(DBManager::sharedDBManager()->getActor(1));
addPlayer(DBManager::sharedDBManager()->getActor(2));
initWordList();
refreshWorldPad();
showHideConfirmPad(false);
_curTime = TIME_OUT;
CCNode* pBaseNode = m_pCcbNode->getChildByTag(kTagGamePanBg);
CCLabelBMFont* timerTxt = dynamic_cast<CCLabelBMFont*>(pBaseNode->getChildByTag(kTagGamePanBgTimer));
int timeStr = (int)_curTime;
timerTxt->setString(Utils::itos(timeStr).c_str());
changeSide();
}
void GameStateOne::handleEvents(sf::Event theEvent)
{
// Exit program if Escape key is pressed
if((theEvent.type == sf::Event::KeyReleased) &&
(theEvent.key.code == sf::Keyboard::Escape))
{
mApp.quit(GQE::StatusAppOK);
}
else if((theEvent.type == sf::Event::KeyReleased) &&
(theEvent.key.code == sf::Keyboard::B))
{
if(mPlayer)
{
deactivateEntity( mPlayer->mProperties.get<GQE::IEntity*>(ACTOR));
}
}
else if((theEvent.type == sf::Event::KeyReleased) &&
(theEvent.key.code == sf::Keyboard::A))
{
}
else
{
for(int i = 0; i < 8; i++)
{
if(sf::Joystick::isConnected(i) && sf::Joystick::isButtonPressed(i, 0))
if(!mPlayer)
{
mPlayer = addPlayer(i, BASIC_SHIP_PROTO, Position2D(40, 160, 90 * TORAD));
GQE::IEntity* actor = mPlayer->mProperties.get<GQE::IEntity*>(ACTOR);
GQE::Prototype* propeller = mPrototypes.getPrototype(SHIP_PROPELLER_PROTO);
propeller->mProperties.add<GQE::IEntity*>(PARENT, actor);
propeller->makeInstance();
GQE::Prototype* prototype = mPrototypes.getPrototype(MACHINEGUN_PROTO);
prototype->mProperties.add<GQE::IEntity*>(PARENT, actor);
prototype->mProperties.set<GQE::typePropertyID>(ANCHOR_POINT, LEFT_ANCHOR);
prototype->makeInstance();
prototype->mProperties.set<GQE::typePropertyID>(ANCHOR_POINT, RIGHT_ANCHOR);
prototype->makeInstance();
}
}
}
}
void OnlineRaceLogic::onPlayerJoined(const CL_String &p_name)
{
// check player existence
if (!hasPlayer(p_name)) {
// create new player
m_remotePlayers.push_back(
CL_SharedPtr<RemotePlayer>(new RemotePlayer(p_name))
);
RemotePlayer &player = *m_remotePlayers.back();
addPlayer(&player);
// add his car to the level
getLevel().addCar(&player.getCar());
display(cl_format(_("Player %1 joined"), p_name));
} else {
cl_log_event(LOG_ERROR, "Player named '%1' already in list", p_name);
}
}
