Пример #1
0
bool Commands::getInfo(Creature* creature, const std::string& cmd, const std::string& param)
{
	Player* player = creature->getPlayer();
	if(!player)
		return true;

	Player* paramPlayer = g_game.getPlayerByName(param);
	if(paramPlayer) {
		std::stringstream info;
		if(paramPlayer->getAccessLevel() >= player->getAccessLevel() && player != paramPlayer){
			player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "You can not get info about this player.");
			return true;
		}
		
		uint8_t ip[4];
		*(uint32_t*)&ip = paramPlayer->lastip;
		info << "name:   " << paramPlayer->getName() << std::endl <<
				"access: " << paramPlayer->getAccessLevel() << std::endl <<
				"level:  " << paramPlayer->getPlayerInfo(PLAYERINFO_LEVEL) << std::endl <<
				"maglvl: " << paramPlayer->getPlayerInfo(PLAYERINFO_MAGICLEVEL) << std::endl <<
				"speed:  " <<  paramPlayer->getSpeed() <<std::endl <<
				"position " << paramPlayer->getPosition() << std::endl <<
				"ip: " << ipText(ip);
		player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, info.str().c_str());
	}
	else{
		player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Player not found.");
	}

	return true;
}
Пример #2
0
//====================================
//PASS
//======================================
void Match::pass(Player *p)
{
    int randRating = Player::maxRating + 1;
    //cout << " Pass ";
    int passRoll =(rand()%randRating + 1) + p->getPass();
    Player* target = getTeammate(p);

    if(passRoll > 21)
    {
        //cout << "To " << target->getName() << endl;

        screen->updatePass(p, target);
        updateBall(target);
        setPlayerStatus(target);
        setPlayerStatus(p);
    }
    else
    {
        stringstream message ;
        message << p->getName() << " missed with a bad pass to " << target->getName();
        screen->updateMissPass(p, target);
        //cout << "Misses pass to " << target->getName() << " , Loose Ball!!" << endl;
        ball->drop();
        setMissPass(target->getPosX(), target->getPosY());
        setAllStatus();
    }
}
Пример #3
0
void HashTable::insert(Player& aPlayer)
{
	char* key;		//NEED TO DESTROY??
	//key = new char[strlen(aPlayer.getName())];	//get the name and use it as the key
	key = aPlayer.getName();

	//calculate the insertion position (the index of the array)
	size_t index = calculatedIndex(key);	
	
	//check if player exists already
	if(retrieve(key) != NULL)	//if player already exists
	{
		cout << "Attempting to add player " << '"' << key << '"' << " to the database -- Failed." << endl;
	}
	else
	{
		//create new node to hold the data
		node * newNode = new node(aPlayer);		//NEED TO DESTROY??

		//insert the new node at the beginning of the linked list
		newNode->next = table[index];	//set what the newNode points to, which is the table index (or rather what table[index] points to
									//the index will be a number within capacity once it goes through the calculatedIndex function
		table[index] = newNode;		//set table[index] to point to the newNode so it's the first node now
		size++;						//for every node increment size
		cout << "Attempting to add player " << '"' << key << '"' << " to the database -- Success!" << endl;
	}
	key = NULL;
	delete key;
}
Пример #4
0
Player::Player(const Player& p) : GameObject(p),
  mName(p.getName()),
  mLifes(p.getLifes()),
  mId(p.getId()),
  mSize(p.getSize()),
  mType(p.getType())
{}
Пример #5
0
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);
		}
	}
}
Пример #6
0
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 AnimationCommandLayer::onFrameEvent(Frame * frame)
	{

		EventFrame* evnt = dynamic_cast<EventFrame*>(frame);
		std::string aniStr = evnt->getEvent();

		if (!evnt)
		{
			return;
		}

		Sprite* sp = (Sprite*)evnt->getNode();
		if (aniStr != "")//spine动画 compare(0, 3, "spi")
		{
			Player * player = (Player *)sp->getChildByTag(SPINE_ANIMATION_PLAYER_TAG);
			player->playRoleAction(aniStr.c_str(), true);
			CCLOG("%s Spine Animation is %s", player->getName().c_str(), aniStr.c_str());
		}
//暂时去掉下面的代码,如果以后需要执行cocos studio做不出来的动画,那么修改规则,用下面的代码 cuihanbing
// 		else if (str.compare(0, 3, "act") == 0)//需要cocos2d执行的动画
// 		{
// 			if (str == "act_chuxian")
// 			{
// 				evnt->getNode()->setOpacity(256);
// 				CCLOG("Action is %s", str.c_str());
// 			}
// 		}
	}
Пример #8
0
/*************************************************************************
* Function name: playOneTurn
* The Input: -
* The output: -
* The Function operation: prepares the current turn - one player attacks
* 			and the other handles the attack.
*************************************************************************/
void Game::playOneTurn() {
	// Get the relevant player for this turn and his enemy
	Player * currPlayer;
	Player * enemy;
	if (isPlayer1Turn) {
		currPlayer = player1;
		enemy = player2;
	} else {
		currPlayer = player2;
		enemy = player1;
	}

	// The relevant player plays his turn
	Coordinates * guess = currPlayer->makeGuess();
	HitStatus hitStatus = enemy->handleAttack(*guess);
	currPlayer->sendHitFeedback(*guess, hitStatus);

	// Print information about the turn
	showTurn(currPlayer->getName(), *guess, hitStatus);

	// If player missed - turn goes to next player
	if (hitStatus == MISS) {
		isPlayer1Turn = !isPlayer1Turn;
	}

	// Done. Free the memory of prev. guess
	delete guess;
}
Пример #9
0
bool Player::operator==(const Player& other) const {
	return true
		 && _isNameSet(mgen::SHALLOW) == other._isNameSet(mgen::SHALLOW)
		 && _isTeamSet(mgen::SHALLOW) == other._isTeamSet(mgen::SHALLOW)
		 && getName() == other.getName()
		 && getTeam() == other.getTeam();
}
Пример #10
0
bool
ServerRoom::getChairInfo( unsigned int  chairIndex,
                          std::string&  name,           // output
                          bool&         isBot,          // output
                          ChairState&   state,          // output
                          unsigned int& packsQueued,    // output
                          unsigned int& ticksRemaining  /* output */ ) const
{
    if( chairIndex < mChairCount )
    {
        Player* player = mPlayerList[chairIndex];
        state = mChairStateList[chairIndex];
        if( player != nullptr )
        {
            name = player->getName();
            isBot = mBotList.contains( (BotPlayer*)player );
            packsQueued = mDraftPtr->getPackQueueSize( chairIndex );
            ticksRemaining = mDraftPtr->getTicksRemaining( chairIndex );
        }
        else
        {
            name.clear();
            isBot = false;
            packsQueued = 0;
            ticksRemaining = 0;
        }
        return true;
    }
    else
    {
        return false;
    }
}
Пример #11
0
/**
 * Prints stats of a game session
 */
void Game::dumpstats()
{
	Player* pl;
	Uint8 h, m, s, i;
	Uint32 uptime;

	uptime = p::aequeue->getElapsedTime();
	uptime /= 1000;
	h = uptime/3600;
	uptime %= 3600;
	m = uptime/60;
	s = uptime%60;

	logger->renderGameMsg(false);
	logger->gameMsg("Time wasted: %i hour%s%i minute%s%i second%s", h,
			(h!=1 ? "s " : " "), m, (m!=1 ? "s " : " "), s, (s!=1 ? "s " : " "));
	for (i = 0; i < p::ppool->getNumPlayers(); i++)
	{
		pl = p::ppool->getPlayer(i);
		logger->gameMsg("%s\nUnit kills:  %i\n     losses: %i\n"
			"Structure kills:  %i\n          losses: %i\n", pl->getName(),
				pl->getUnitKills(), pl->getUnitLosses(),
				pl->getStructureKills(), pl->getStructureLosses());
	}
}
void Client::sendChangePassword(const std::wstring oldpassword,
		const std::wstring newpassword)
{
	Player *player = m_env.getLocalPlayer();
	if(player == NULL)
		return;

	std::string playername = player->getName();
	std::string oldpwd = translatePassword(playername, oldpassword);
	std::string newpwd = translatePassword(playername, newpassword);

	std::ostringstream os(std::ios_base::binary);
	u8 buf[2+PASSWORD_SIZE*2];
	/*
		[0] u16 TOSERVER_PASSWORD
		[2] u8[28] old password
		[30] u8[28] new password
	*/

	writeU16(buf, TOSERVER_PASSWORD);
	for(u32 i=0;i<PASSWORD_SIZE-1;i++)
	{
		buf[2+i] = i<oldpwd.length()?oldpwd[i]:0;
		buf[30+i] = i<newpwd.length()?newpwd[i]:0;
	}
	buf[2+PASSWORD_SIZE-1] = 0;
	buf[30+PASSWORD_SIZE-1] = 0;
	os.write((char*)buf, 2+PASSWORD_SIZE*2);

	// Make data buffer
	std::string s = os.str();
	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
	// Send as reliable
	Send(0, data, true);
}
Пример #13
0
bool Holdem::checkEarlyEnd() {
	//calculate how many player not folded / all-in
	player_num nFoldNum = 0;
	player_num nAllInNum = 0;
	Player *notFolded;
	for (vector<Player*>::iterator iter = players.begin(); iter != players.end(); ++iter) {
		if (!(*iter)->isFolded()) {
			++nFoldNum;
			notFolded = *iter;
		}
		if (!(*iter)->isAllIn()) {
			++nAllInNum;
		}
	}
	//if all (or all but one) players are all-in, skip betting
	if (nAllInNum <= 1) {
		gotoShowDown = true;
	}
	//if more than one players not folded, game goes on
	if (nFoldNum > 1) {
		return false;
	}

	//if only one player left, he wins the whole pot
	notFolded->win(pot);
	cout << endl;
	cout << notFolded->getName() << " is/are the only player left, thus win(s) " << pot << endl;
	return true;
}
Пример #14
0
void Mud::removeInactivePlayers()
{
    PlayerList toRemove = PlayerList();
    for (auto iterator : mudPlayers)
    {
        // Proceed only if the player is not connected and is closing.
        if (!iterator->checkConnection() || iterator->closing)
        {
            // Add the player to the list of players that have to be removed.
            toRemove.insert(iterator);
        }
    }
    for (auto iterator = toRemove.begin(); iterator != toRemove.end(); ++iterator)
    {
        // Get the player at the given position.
        Player * player = *iterator;
        // Log the action of removing.
        Logger::log(LogLevel::Global, "Removing inactive player : " + player->getName());
        // Only if the player has successfully logged in, save its state on DB.
        if (player->logged_in)
        {
            SQLiteDbms::instance().beginTransaction();
            player->updateOnDB();
            SQLiteDbms::instance().endTransaction();
        }
        // Remove the player from the list of players.
        remPlayer(player);
        // Delete the player.
        delete (player);
    }
}
Пример #15
0
void saveHighScore(Player &winner, Player &loser, float score, int scorePlace) {
    char dummy;
    ifstream oldScores;
    scoreLine tempLine;
    vector<scoreLine> scoresList;
    ofstream newScores;
    oldScores.open("Top10 Scores.txt");
    for (int i = 0; i < 10; i++) {
        if (i == scorePlace) {
            tempLine.playerName = winner.getName();
            tempLine.score = score;
            tempLine.numLines = loser.getBoard().getNumLines();
            tempLine.numColumns = loser.getBoard().getNumColumns();
            tempLine.shipArea = loser.getShipArea();
        }
        else {
            tempLine.playerName = "";
            getline(oldScores, tempLine.playerName, ':');
            if (!(tempLine.playerName == "")) {
                oldScores >> tempLine.score >> tempLine.numLines >> dummy >> tempLine.numColumns >>
                tempLine.shipArea;
                oldScores.ignore(1000, '\n');
            }
            else
                break;
        }
Пример #16
0
void GuildPacket::addGuildInformation(PacketCreator &packet, Guild *guild) {
	// Initializing the leader
	Player *leader = PlayerDataProvider::Instance()->getPlayer(guild->getLeader(), true);

	if (leader == nullptr) {
		std::cout << "Leader not found in the server. Leader ID: " << guild->getLeader() << std::endl;
	}
	packet.add<int32_t>(guild->getId());
	packet.addString(guild->getName());

	for (uint8_t i = 1; i <= GuildsAndAlliances::RankQuantity; i++) {
		packet.addString(guild->getTitle(i));
	}

	packet.add<uint8_t>(guild->m_players.size());

	if (leader != nullptr) {
		packet.add<int32_t>(leader->getId());
	}

	for (unordered_map<int32_t, Player *>::iterator iter = guild->m_players.begin(); iter != guild->m_players.end(); iter++) {
		if (iter->second->getId() != guild->getLeader()) {
			packet.add<int32_t>(iter->second->getId());
		}
	}

	// Adding the information of the players
	if (leader != nullptr) {
		packet.addString(leader->getName(), 13);
		packet.add<int32_t>(leader->getJob());
		packet.add<int32_t>(leader->isOnline() ? leader->getLevel() : -1); // FIXME
		packet.add<int32_t>(leader->getGuildRank());
		packet.add<int32_t>(leader->isOnline() ? 1 : 0);
		packet.addBytes("91940491");
		packet.add<int32_t>(leader->getAllianceRank());
	}

	for (unordered_map<int32_t, Player *>::iterator iter = guild->m_players.begin(); iter != guild->m_players.end(); iter++) {
		if (iter->second->getId() != guild->getLeader()) {
			packet.addString(iter->second->getName(), 13);
			packet.add<int32_t>(iter->second->getJob());
			packet.add<int32_t>(iter->second->isOnline() ? iter->second->getLevel() : -1); // FIXME
			packet.add<int32_t>(iter->second->getGuildRank());
			packet.add<int32_t>(iter->second->isOnline() ? 1 : 0);
			packet.addBytes("91940491");
			packet.add<int32_t>(iter->second->getAllianceRank());
		}
	}

	// Adding Guild info
	GuildLogo logo = guild->getLogo();
	packet.add<int32_t>(guild->getCapacity());
	packet.add<int16_t>(logo.background);
	packet.add<uint8_t>(logo.backgroundColor);
	packet.add<int16_t>(logo.logo);
	packet.add<uint8_t>(logo.color);
	packet.addString(guild->getNotice());
	packet.add<int32_t>(guild->getGuildPoints());
	packet.add<int32_t>(guild->getAlliance() == nullptr ? 0 : guild->getAlliance()->getId());
}
Пример #17
0
void GameManager::printWinner()const
{
	Player *player;
	int		i;
	for (i = 0; i < MAX_PLAYERS_COUNT; i++)
	{
		if (m_players[i])
		{
			player = m_players[i];
			break;
		}
	}

	i = 0;
	Util::clrscr();
	if (player)
	{
		Util::gotoxy(SYS_MSG_LOCATION_X, SYS_MSG_LOCATION_Y + i++);
		cout << "************************" << endl;
		Util::gotoxy(SYS_MSG_LOCATION_X, SYS_MSG_LOCATION_Y + i++);
		cout << "*   The Winner is: " << player->getName() << "   *" << endl;
		Util::gotoxy(SYS_MSG_LOCATION_X, SYS_MSG_LOCATION_Y + i++);
		cout << "************************" << endl;
	}
}
Пример #18
0
void cmd_privs(std::wostringstream &os,
               ServerCommandContext *ctx)
{
    if(ctx->parms.size() == 1)
    {
        // Show our own real privs, without any adjustments
        // made for admin status
        os<<L"-!- " + narrow_to_wide(privsToString(
                                         ctx->server->getPlayerAuthPrivs(ctx->player->getName())));
        return;
    }

    if((ctx->privs & PRIV_PRIVS) == 0)
    {
        os<<L"-!- You don't have permission to do that";
        return;
    }

    Player *tp = ctx->env->getPlayer(wide_to_narrow(ctx->parms[1]).c_str());
    if(tp == NULL)
    {
        os<<L"-!- No such player";
        return;
    }

    os<<L"-!- " + narrow_to_wide(privsToString(ctx->server->getPlayerAuthPrivs(tp->getName())));
}
Пример #19
0
void PrivateChatChannel::invitePlayer(const Player& player, Player& invitePlayer)
{
	if (addInvited(invitePlayer)) {
		std::ostringstream ss;
		ss << player.getName() << " invites you to " << (player.getSex() == PLAYERSEX_FEMALE ? "her" : "his") << " private chat channel.";
		invitePlayer.sendTextMessage(MSG_INFO_DESCR, ss.str());

		ss.str("");
		ss << invitePlayer.getName() << " has been invited.";
		player.sendTextMessage(MSG_INFO_DESCR, ss.str());

		for (const auto& it : users) {
			it.second->sendChannelEvent(id, invitePlayer.getName(), CHANNELEVENT_INVITE);
		}
	}
}
Пример #20
0
//Sends a fleet back to it's home planet
void TaeTurn::sendHome(uint32_t fleet) {
    Game* game = Game::getGame();
    ObjectManager* obm = game->getObjectManager();
    ObjectTypeManager* obtm = game->getObjectTypeManager();
    PlayerManager* pm = game->getPlayerManager();

    IGObject* fleetobj = obm->getObject(fleet);
    //Check to make sure it is really a fleet
    if(fleetobj->getType() != obtm->getObjectTypeByName("Fleet")) {
        return;
    }
    
    //Get all the required objects
    Fleet* f = (Fleet*) fleetobj->getObjectBehaviour();
    Player* p = pm->getPlayer(f->getOwner());
    IGObject* sys = obm->getObject(fleetobj->getParent());
    StarSystem* sysData = (StarSystem*) sys->getObjectBehaviour();

    //Remove fleet from system
    sysData->setRegion(0);
    fleetobj->removeFromParent();

    //Find it's home planet
    std::set<uint32_t> objects = obm->getAllIds();
    std::set<uint32_t>::iterator itcurr;
    for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
        IGObject * ob = obm->getObject(*itcurr);
        if(ob->getName().compare(string(p->getName() + "'s Home Planet")) == 0) {
            Planet* p = (Planet*) ob->getObjectBehaviour();
            f->setPosition(p->getPosition());
            fleetobj->addToParent(ob->getID());
        }
    }
}
Пример #21
0
void PrivateChatChannel::excludePlayer(const Player& player, Player& excludePlayer)
{
	if (removeInvited(excludePlayer)) {
		removeUser(excludePlayer);

		std::ostringstream ss;
		ss << excludePlayer.getName() << " has been excluded.";
		player.sendTextMessage(MESSAGE_INFO_DESCR, ss.str());

		excludePlayer.sendClosePrivate(getId());

		for (const auto& it : users) {
			it.second->sendChannelEvent(id, excludePlayer.getName(), CHANNELEVENT_EXCLUDE);
		}
	}
}
Пример #22
0
bool Party::invitePlayer(Player& player)
{
	if (isPlayerInvited(&player)) {
		return false;
	}

	std::ostringstream ss;
	ss << player.getName() << " has been invited.";

	if (memberList.empty() && inviteList.empty()) {
		ss << " Open the party channel to communicate with your members.";
		g_game.updatePlayerShield(leader);
		leader->sendCreatureSkull(leader);
	}

	leader->sendTextMessage(MESSAGE_INFO_DESCR, ss.str());

	inviteList.push_back(&player);

	for (Player* member : memberList) {
		g_game.updatePlayerHelpers(*member);
	}
	g_game.updatePlayerHelpers(*leader);

	leader->sendCreatureShield(&player);
	player.sendCreatureShield(leader);

	player.addPartyInvitation(this);

	ss.str(std::string());
	ss << leader->getName() << " has invited you to " << (leader->getSex() == PLAYERSEX_FEMALE ? "her" : "his") << " party.";
	player.sendTextMessage(MESSAGE_INFO_DESCR, ss.str());
	return true;
}
Пример #23
0
void Client::sendChangePassword(const std::string &oldpassword,
        const std::string &newpassword)
{
	Player *player = m_env.getLocalPlayer();
	if (player == NULL)
		return;

	std::string playername = player->getName();
	if (m_proto_ver >= 25) {
		// get into sudo mode and then send new password to server
		m_password = oldpassword;
		m_new_password = newpassword;
		startAuth(choseAuthMech(m_sudo_auth_methods));
	} else {
		std::string oldpwd = translatePassword(playername, oldpassword);
		std::string newpwd = translatePassword(playername, newpassword);

		NetworkPacket pkt(TOSERVER_PASSWORD_LEGACY, 2 * PASSWORD_SIZE);

		for (u8 i = 0; i < PASSWORD_SIZE; i++) {
			pkt << (u8) (i < oldpwd.length() ? oldpwd[i] : 0);
		}

		for (u8 i = 0; i < PASSWORD_SIZE; i++) {
			pkt << (u8) (i < newpwd.length() ? newpwd[i] : 0);
		}
		Send(&pkt);
	}
}
Пример #24
0
bool ChatChannel::addUser(Player& player)
{
	if (users.find(player.getID()) != users.end()) {
		return false;
	}

	if (!executeOnJoinEvent(player)) {
		return false;
	}

	// TODO: Move to script when guild channels can be scripted
	if (id == CHANNEL_GUILD) {
		Guild* guild = player.getGuild();
		if (guild && !guild->getMotd().empty()) {
			g_scheduler.addEvent(createSchedulerTask(150, std::bind(&Game::sendGuildMotd, &g_game, player.getID())));
		}
	}

	if (!publicChannel) {
		for (const auto& it : users) {
			it.second->sendChannelEvent(id, player.getName(), CHANNELEVENT_JOIN);
		}
	}

	users[player.getID()] = &player;
	return true;
}
void GameClient::lineRead(std::string s){
    std::cout<<"Accepting change: "<<s<<std::endl;
    std::stringstream ss;
    ss<<s;
    std::string str;
    ss>>str;
    
    if (str == "/object"){
        ss>>str;
        if (str == "player"){
            ss>>str; //str is now the ObjectID
            for (std::vector<Player*>::iterator it=players.begin(); it!=players.end(); it++){
                if ((*it)->getObjectID() == str){
                    (*it)->updateFromString(ss);
                    return;
                }
            }
            if (str == mainPlayer->getObjectID()){ //random crap
                std::cout<<"WHAT?!?!?!?\n";
                exit(0);
            }
            Player* p = new Player(&wl);
            p->setTextureManager(wl.getTextureManager());
            p->setTexturePrefix("cube_box");
            p->setObjectID(str);
            p->updateFromString(ss);
            players.push_back(p);
            std::cout<<"New player connected: "<<p->getName()<<std::endl;
        }else{
void Ownable::buy (Player& curPlayer) {
	int ans;

	cout << "You have " << curPlayer.getMoney() << endl; 
	std::cout << "Do you want to buy " <<title << " for " << cost <<"?" << endl ;

	cout << "1. Yes 2. No" << endl;
	cin >> ans;

	if ( ans == 1 && curPlayer.getMoney()>= cost ) {
		cout << "You bought " << title << "." << endl;
		curPlayer.changeMoney( -(cost) );
			curPlayer.getTower()->setBillBoard( ( bboard) );
		curPlayer.getTower()->setHeight( (*bboard).getValue() );
		cout << (*bboard).getValue() << " VALUE" << endl ;
		cout << curPlayer.getTower()->getHeight() << " out of 17 to win." << endl;	
		owned =true;

		owner = curPlayer.getId();


	} else {
		cout << curPlayer.getName() << " did not buy " << title << "." << endl;
	}


}
Пример #27
0
void Match::printer()
{
    for(int i = 0; i < 10; i++)
    {
        Player p = *playersToMove[i];
        cout<<"NAME: " << p.getName() << " X: " << p.getPosX() << " Y: " << p.getPosY() << " STATUS: " << p.getStatus() << endl;
    }
}
Пример #28
0
CCTableViewCell* RankingScene::tableCellAtIndex(CCTableView *table, unsigned int idx)
{
    CCTableViewCell *cell = table->dequeueCell();
    cell = new CCTableViewCell();
    cell->autorelease();
    
    // Player Point
    Player * p = (Player*)players->objectAtIndex(idx);
    CCString *string = CCString::createWithFormat("%d",p->getPoint());
    CCLabelTTF *Pointlabel = CCLabelTTF::create(string->getCString(), "Helvetica", 48);
    Pointlabel->setAnchorPoint(ccp(1, 0));
    Pointlabel->setPosition(ccp(500,0));
    Pointlabel->setTag(123);
    cell->addChild(Pointlabel);
    // Player Name
    std::string name = p->getName();
    CCLabelTTF *Namelabel = CCLabelTTF::create(p->getName().c_str(), "Helvetica", 48);
    Namelabel->setAnchorPoint(CCPointZero);
    Namelabel->setPosition(ccp(100, 0));
    cell->addChild(Namelabel);
    
    // Player Rank
    char rankBuf[3];
    sprintf(rankBuf, "%i.png", idx+1);
    CCSprite *rank = CCSprite::create(rankBuf);
    rank->setAnchorPoint(CCPointZero);
    rank->setPosition(CCPointZero);
    cell->addChild(rank);
    
    if (idx == 0) {
        int rewardLocal = CCUserDefault::sharedUserDefault()->getIntegerForKey("reward");
        std::string nameLocal = GameManager::sharedGameManager()->getName();
        int pointMax = CCUserDefault::sharedUserDefault()->getIntegerForKey("pointMax");
        if (p->getReward() != 0 && rewardLocal != 0 &&
            p->getName() == nameLocal && p->getPoint() == pointMax) {
            CCMenuItemImage *bt_send_email =
                CCMenuItemImage::create("Present.png","Present.png",
                                        this, menu_selector(RankingScene::clickBtSendEmail));
            CCMenu * menu = CCMenu::create(bt_send_email, NULL);
            menu->setPosition(ccp(550, 30));
            cell->addChild(menu);
        }
        
    }
    return cell;
}
Пример #29
0
void GroupObject::broadcastDeltaResetAll()
{
    mMembersUpdateCount++;
    Message* baselineBody;

    gMessageFactory->StartMessage();

    // two updates : reset all & set master looter to the new leaders'id

    gMessageFactory->addUint16(2);
    gMessageFactory->addUint16(1);
    gMessageFactory->addUint32(1);
    gMessageFactory->addUint32(mMembersUpdateCount);
    gMessageFactory->addUint8(3); //reset all
    gMessageFactory->addUint16((uint16)mMembers.size());

    PlayerList::iterator listIt;
    Player* runningPlayer;

    listIt = mMembers.begin();
    while(listIt != mMembers.end())
    {
        runningPlayer = (Player*)(*listIt);

        gMessageFactory->addUint64(runningPlayer->getCharId());
        gMessageFactory->addString(runningPlayer->getName());

        ++listIt;
    }


    // modify part 6 (master looter id)
    gMessageFactory->addUint16(6);
    gMessageFactory->addUint64(mMasterLooter);

    baselineBody = gMessageFactory->EndMessage();

    Message* newMessage;

    gMessageFactory->StartMessage();
    gMessageFactory->addUint32(0x12862153); // deltas
    gMessageFactory->addUint64(mId);
    gMessageFactory->addUint32(0x47525550); // GRUP
    gMessageFactory->addUint8(6);

    gMessageFactory->addUint32(baselineBody->getSize());
    gMessageFactory->addData(baselineBody ->getData(), baselineBody->getSize());

    newMessage = gMessageFactory->EndMessage();

    gMessageFactory->DestroyMessage(baselineBody);

    // update counter need to match the amount of modifications we did here
    mMembersUpdateCount +=  mMembers.size();

    broadcastMessage(newMessage);
}
Пример #30
0
void RemoteProcessClient::writePlayer(const Player& player) {
    writeBoolean(true);

    writeLong(player.getId());
    writeBoolean(player.isMe());
    writeString(player.getName());
    writeBoolean(player.isStrategyCrashed());
    writeInt(player.getScore());
}