Пример #1
0
void CreateBot(BotUpdate* update) {
    GameClient* client = update->GetClient();

    auto effectComponent = std::make_unique<EffectComponent>(client->GetDispatcher());
    update->AddComponent(std::move(effectComponent));

    auto jump = std::make_unique<JumpComponent>(client->GetWorld(), 200);
    update->AddComponent(std::move(jump));

    auto targeting = std::make_unique<TargetingComponent>();
    update->AddComponent(std::move(targeting));

    auto targetPlayer = std::make_shared<TargetPlayerAction>(client);

    std::shared_ptr<DecisionTreeNode> pathfindDecision = std::make_shared<RangeDecision<bool>>(
        targetPlayer, std::make_shared<WanderAction>(client), std::bind(&TargetPlayerAction::HasTarget, targetPlayer), true, true
    );

    auto meleeAction = std::make_shared<MeleeAction>(client);
    auto tree = std::make_shared<RangeDecision<double>>(
        meleeAction, pathfindDecision, std::bind(&MeleeAction::DistanceToTarget, meleeAction), 0.0, 2.0
    );

    update->SetDecisionTree(tree);
}
Пример #2
0
void GameHandler::completeServerChange(int id, const std::string &token,
                                       const std::string &address, int port)
{
    for (NetComputers::const_iterator i = clients.begin(),
         i_end = clients.end(); i != i_end; ++i)
    {
        GameClient *c = static_cast< GameClient * >(*i);
        if (c->status == CLIENT_CHANGE_SERVER &&
            c->character->getComponent<CharacterComponent>()
                ->getDatabaseID() == id)
        {
            MessageOut msg(GPMSG_PLAYER_SERVER_CHANGE);
            msg.writeString(token, MAGIC_TOKEN_LENGTH);
            msg.writeString(address);
            msg.writeInt16(port);
            c->send(msg);
            c->character->getComponent<CharacterComponent>()->disconnected(
                    *c->character);
            delete c->character;
            c->character = nullptr;
            c->status = CLIENT_LOGIN;
            return;
        }
    }
}
Пример #3
0
    bool SelectItem(s32 id) {
        mc::inventory::Inventory* inventory = m_Client->GetInventory();

        if (!inventory) return false;

        auto& hotbar = m_Client->GetHotbar();
        auto slot = hotbar.GetCurrentItem();

        if (slot.GetItemId() != id) {
            s32 itemIndex = inventory->FindItemById(id);

            std::cout << "Selecting item id " << id << std::endl;
            if (itemIndex == -1) {
                std::cout << "Not carrying item with id of " << id << std::endl;
                return false;
            } else {
                std::cout << "Item is in index " << itemIndex << std::endl;
            }

            s32 hotbarIndex = itemIndex - mc::inventory::Inventory::HOTBAR_SLOT_START;
            if (hotbarIndex >= 0)
                hotbar.SelectSlot(hotbarIndex);
        }

        return true;
    }
Пример #4
0
void GameSocket::OnRawData( const char *pData,size_t len,struct sockaddr *sa_from,socklen_t sa_len )
{
	struct sockaddr_in inc_addr;
	memcpy(&inc_addr,sa_from,sa_len);
	Ipv4Address theAddr(inc_addr);

	if (theAddr.IsValid() == false)
		return;

	string IPStr = theAddr.Convert(true);
	GClientList::iterator it = m_clients.find(IPStr);
	if (it != m_clients.end())
	{
		GameClient *Client = it->second;
		if (Client->IsValid() == false)
		{
			DEBUG_LOG( format("Removing dead client [%1%]") % IPStr );
			m_clients.erase(it);
			delete Client;
		}
		else
		{
			Client->HandlePacket(pData, len);
		}
	}
	else
	{
		m_clients[IPStr] = new GameClient(inc_addr, this);
		DEBUG_LOG(format ("Client connected [%1%], now have [%2%] clients")
			% IPStr % Clients_Connected());

		m_clients[IPStr]->HandlePacket(pData, len);
		m_clients[IPStr]->InitializeWorld () ;
	}
}
Пример #5
0
void CleanupBot(BotUpdate* update) {
    GameClient* client = update->GetClient();

    client->RemoveComponent(Component::GetIdFromName(EffectComponent::name));
    client->RemoveComponent(Component::GetIdFromName(JumpComponent::name));
    client->RemoveComponent(Component::GetIdFromName(TargetingComponent::name));
}
Пример #6
0
int main(int argc, char** argv)
{
	//MemoryDebug::isEnabled = true;

	try
	{
		GameClient gc;
		GASimulation gas;
		Mode mode = Mode_GA_Simulation;

		for(int i=0; i<argc; i++)
		{
			printf("arg\t%i:\t%s\n", i, argv[i]);
		}

		for(int i=0; i<argc; i++)
		{
			if( strcmp(argv[i], "/network") == 0 )
			{
				mode = Mode_Network;
			}
			else if( strcmp(argv[i], "/targetIP") == 0 )
			{
				i++;
				gc.targetIP = argv[i];
			}
			else if( strcmp(argv[i], "/targetPort") == 0 )
			{
				i++;
				gc.targetPort = argv[i];
			}
		}

		switch( mode)
		{
		case Mode_Default:
			gc.run();
			break;

		case Mode_Network:
			gc.run2();
			break;

		case Mode_GA_Simulation:
			gas.run();
			break;
		}
	}
	catch( char* ex )
	{
		printf( "%s\n", ex );
		getchar();
	}

	//memoryDebug.debugPrint();
	//MemoryDebug::isEnabled = false;
	return 1337;
}
Пример #7
0
void GameHandler::handleTradeRequest(GameClient &client, MessageIn &message)
{
    const int id = message.readInt16();

    auto *characterComponent =
            client.character->getComponent<CharacterComponent>();

    if (Trade *t = characterComponent->getTrading())
        if (t->request(client.character, id))
            return;

    Entity *q = findCharacterNear(client.character, id);
    if (!q || characterComponent->isBusy())
    {
        client.send(MessageOut(GPMSG_TRADE_CANCEL));
        return;
    }

    new Trade(client.character, q);

    // log transaction
    std::string str;
    str = "User requested trade with " + q->getComponent<BeingComponent>()
            ->getName();
    accountHandler->sendTransaction(characterComponent->getDatabaseID(),
                                    TRANS_TRADE_REQUEST, str);
}
Пример #8
0
void GameHandler::handleRaiseAttribute(GameClient &client, MessageIn &message)
{
    auto *characterComponent =
            client.character->getComponent<CharacterComponent>();

    const int attribute = message.readInt16();
    AttribmodResponseCode retCode;
    retCode = characterComponent->useCharacterPoint(*client.character,
                                                    attribute);

    MessageOut result(GPMSG_RAISE_ATTRIBUTE_RESPONSE);
    result.writeInt8(retCode);
    result.writeInt16(attribute);
    client.send(result);

    if (retCode == ATTRIBMOD_OK)
    {
        accountHandler->updateCharacterPoints(
                characterComponent->getDatabaseID(),
                characterComponent->getCharacterPoints(),
                characterComponent->getCorrectionPoints());

        // log transaction
        std::stringstream str;
        str << "User increased attribute " << attribute;
        accountHandler->sendTransaction(characterComponent->getDatabaseID(),
                                        TRANS_ATTR_INCREASE, str.str());
    }
}
Пример #9
0
    bool HasTarget() {
        mc::core::PlayerPtr targetPlayer = m_Client->GetPlayerManager()->GetPlayerByName(TargetPlayer);
        if (!targetPlayer) return false;

        mc::entity::EntityPtr entity = targetPlayer->GetEntity();
        return entity != nullptr;
    }
Пример #10
0
void GameHandler::handleDisconnect(GameClient &client, MessageIn &message)
{
    const bool reconnectAccount = (bool) message.readInt8();

    MessageOut result(GPMSG_DISCONNECT_RESPONSE);
    result.writeInt8(ERRMSG_OK); // It is, when control reaches here

    if (reconnectAccount)
    {
        std::string magic_token(utils::getMagicToken());
        result.writeString(magic_token, MAGIC_TOKEN_LENGTH);
        // No accountserver data, the client should remember that
        accountHandler->playerReconnectAccount(
                    client.character->getDatabaseID(),
                    magic_token);
    }
    accountHandler->sendCharacterData(client.character);

    // Done with the character, also handle possible respawn case
    client.character->disconnected();
    delete client.character;
    client.character = 0;
    client.status = CLIENT_LOGIN;

    client.send(result);
}
Пример #11
0
void GameHandler::handleLowerAttribute(GameClient &client, MessageIn &message)
{
    const int attribute = message.readInt32();
    AttribmodResponseCode retCode;
    retCode = client.character->useCorrectionPoint(attribute);

    MessageOut result(GPMSG_LOWER_ATTRIBUTE_RESPONSE);
    result.writeInt8(retCode);
    result.writeInt16(attribute);
    client.send(result);

    if (retCode == ATTRIBMOD_OK)
    {
        accountHandler->updateCharacterPoints(
            client.character->getDatabaseID(),
            client.character->getCharacterPoints(),
            client.character->getCorrectionPoints());

        // log transaction
        std::stringstream str;
        str << "User decreased attribute " << attribute;
        accountHandler->sendTransaction(client.character->getDatabaseID(),
                                        TRANS_ATTR_DECREASE, str.str());
    }
}
Пример #12
0
void GameHandler::sendNpcError(GameClient &client, int id,
                               const std::string &errorMsg)
{
    MessageOut msg(GPMSG_NPC_ERROR);
    msg.writeInt16(id);
    msg.writeString(errorMsg, errorMsg.size());
    client.send(msg);
}
Пример #13
0
/// GameClient main function
int WINAPI _tWinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
   CrashReporter::Init(_T("gameclient"), Filesystem().UserFolder() + c_pszCrashdumpFoldername);

   try
   {
      GameClient gc;
      gc.Start();
   }
   catch (Exception& ex)
   {
      CString cszText;
      cszText.Format(_T("Arena ended with exception: %s"), ex.Message().GetString());
      MessageBox(GetActiveWindow(), cszText, _T("Arena"), MB_OK);
   }

   return 0;
}
Пример #14
0
    void Act() override {
        mc::core::PlayerPtr targetPlayer = m_Client->GetPlayerManager()->GetPlayerByName(TargetPlayer);
        auto entity = targetPlayer->GetEntity();

        auto targeting = GetActorComponent(m_Client, TargetingComponent);
        if (!targeting) return;

        targeting->SetTargetEntity(entity->GetEntityId());
        targeting->SetTarget(mc::ToVector3i(entity->GetPosition()));
    }
Пример #15
0
void GameHandler::handleUnequip(GameClient &client, MessageIn &message)
{
    const int itemInstance = message.readInt16();
    if (!Inventory(client.character).unequip(itemInstance))
    {
        MessageOut msg(GPMSG_SAY);
        msg.writeInt16(0); // From the server
        msg.writeString("Unable to unequip.");
        client.send(msg);
    }
}
Пример #16
0
void GameCore::initializePlayers()
{
	teamDM=(gmc->getCurrentRoom()->getGameType()==0?false:true);
	unsigned char clientTeam=(teamDM?gmc->getLocalClient()->getTeam():(gmc->getLocalClient()->getColor()==0?0:1));

    std::map<unsigned int,GameClient*> clientMap=gmc->getCurrentRoom()->getClientMap();
    std::map<unsigned int,GameClient*>::iterator iter=clientMap.begin();
    GameClient* client;
    while(iter!=clientMap.end())
    {
        client=iter->second;
        if(client!=gmc->getLocalClient())
            createPlayer(client);
        iter++;
    }
    client=gmc->getLocalClient();
	localPlayer=new Player(client->getID(),client->getName(),true,true,clientTeam,sceneManager);
    localPlayer->createVisual("SpaceMarine.mesh", Quaternion::IDENTITY, Ogre::Vector3(2, 2, 2), Ogre::Vector3(-100, -100, -500));
    localPlayer->enablePhysics(dynamics);
	localPlayer->changePlayerColor(clientTeam);
    localPlayer->getAnimationController()->enableAnimation("Idle");
    localPlayer->getAnimationController()->addIdleAnimation("Run","Idle");
    localPlayer->getAnimationController()->enableAnimation("Run");

    cameraController->setTarget(localPlayer->getSceneNode());
    float cameraShift =-reader->getFieldValueAsDouble("CameraSettings", "camera-shift");
	cameraController->moveCamera(cameraShift,0);

    cameraController->rotateCamera(90, 0);
    cameraController->rotateCamera(0, 15);
    gmc->requestNextSpawnPoint();
    soundController->setListener(localPlayer->getSceneNode());

	//ingameGUI->setGameType(InGameGUIHandler::TEAM_MATCH);
	this->ingameGUI->showItem(ItemType::IMMORTALITY);
	this->ingameGUI->showItem(ItemType::EAGLE_EYE);
	this->ingameGUI->showItem(ItemType::ONE_SHOT);
}
Пример #17
0
bool GameWorld::canMoveTo( int x, int y, const GameClient& client, bool doMove )
{
	int x_map = x / MAP_OBJECT_WIDTH;
	int y_map = y / MAP_OBJECT_HEIGHT;
	std::cout <<abs( client.getCurrentCharacter()->position().x - x )<< "-"
		<<abs( client.getCurrentCharacter()->position().y - y )<< "-"
		<<_mapData( x_map, y_map ) << "\n";

	bool canMove =  
		( 
			abs( client.getCurrentCharacter()->position().x - x ) <= MAP_OBJECT_WIDTH &&
			abs( client.getCurrentCharacter()->position().y - y ) <= MAP_OBJECT_HEIGHT &&
			_mapData( x_map, y_map ) == WALKABLE
		);

	// save new position
	if ( canMove == true && doMove == true ) {
		_mapData( client.getCurrentCharacter()->position().x / MAP_OBJECT_WIDTH , 
			client.getCurrentCharacter()->position().y / MAP_OBJECT_HEIGHT ) = WALKABLE;
		_mapData( x_map , y_map ) = CHARACTER;
	}

	return canMove;
}
Пример #18
0
void GameHandler::handlePartyInvite(GameClient &client, MessageIn &message)
{
    MapComposite *map = client.character->getMap();
    const int visualRange = Configuration::getValue("game_visualRange", 448);
    std::string invitee = message.readString();

    if (invitee == client.character->getComponent<BeingComponent>()->getName())
        return;

    for (CharacterIterator it(map->getWholeMapIterator()); it; ++it)
    {
        if ((*it)->getComponent<BeingComponent>()->getName() == invitee)
        {
            // calculate if the invitee is within the visual range
            auto *inviterComponent =
                    client.character->getComponent<ActorComponent>();
            auto *inviteeComponent = (*it)->getComponent<ActorComponent>();
            const Point &inviterPosition = inviterComponent->getPosition();
            const Point &inviteePosition = inviteeComponent->getPosition();
            const int dx = std::abs(inviterPosition.x - inviteePosition.x);
            const int dy = std::abs(inviterPosition.y - inviteePosition.y);
            if (visualRange > std::max(dx, dy))
            {
                MessageOut out(GCMSG_PARTY_INVITE);
                out.writeString(client.character
                                ->getComponent<BeingComponent>()->getName());
                out.writeString(invitee);
                accountHandler->send(out);
                return;
            }
            break;
        }
    }

    // Invitee was not found or is too far away
    MessageOut out(GPMSG_PARTY_INVITE_ERROR);
    out.writeString(invitee);
    client.send(out);
}
Пример #19
0
    void Act() override {
        mc::core::PlayerPtr targetPlayer = m_Client->GetPlayerManager()->GetPlayerByName(TargetPlayer);
        auto entity = targetPlayer->GetEntity();
        auto physics = GetActorComponent(m_Client, PhysicsComponent);
        auto targeting = GetActorComponent(m_Client, TargetingComponent);

        ai::FaceSteering align(m_Client, entity->GetPosition(), 0.1, 1, 1);

        physics->ApplyRotation(align.GetSteering().rotation);
        //physics->ClearHorizontalVelocity();
        Vector3d entityHeading = util::OrientationToVector(entity->GetYaw());

        Vector3d target = entity->GetPosition() - entityHeading * 2;
        targeting->SetTarget(ToVector3i(target));

        s64 time = util::GetTime();

        if (time >= m_LastAttack + m_AttackCooldown) {
            Attack(entity);

            m_LastAttack = time;
        }
    }
Пример #20
0
void GameSocket::PruneDeadClients()
{
	m_currTime = getTime();

	// Do client cleanup
	for (GClientList::iterator it=m_clients.begin();it!=m_clients.end();)
	{
		GameClient *Client = it->second;
		if (!Client->IsValid() || (m_currTime - Client->LastActive()) >= 20)
		{
			if (!Client->IsValid())
				DEBUG_LOG( format("Removing invalidated client [%1%]") % Client->Address() );
			else
				DEBUG_LOG( format("Removing client due to time-out [%1%]") % Client->Address() );

			m_clients.erase(it++);
			delete Client;
		}
		else
		{
			++it;
		}
	}

	if ((m_currTime - m_lastCleanupTime) >= 5)
	{
		// Update player count
		if (m_lastPlayerCount != this->Clients_Connected())
		{
			sDatabase.Execute(format("UPDATE `worlds` SET `numPlayers`='%1%' WHERE `name`='%2%' LIMIT 1")
				% this->Clients_Connected()
				% sGame.GetName() );

			m_lastPlayerCount = this->Clients_Connected();
		}

		m_lastCleanupTime = m_currTime;
	}
}
Пример #21
0
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    QString serverAddr = "";
    int serverPort = 0;
    ServerThread *server;

    StartupPage page;
    page.show();
    page.exec();

    if (page.exit) return 0;

    var isServer = page.isServer;
    qDebug() << (isServer ? "server" : "client");

    if (isServer) {
        int timeLimit = defaultTimeLimit;
        QString initStatus = defaultInitStatus;
        bool whiteFirst = false;

        CustomBoard board;
        board.show();
        board.exec();
        initStatus = board.res;
        timeLimit = board.tl;
        whiteFirst = board.whiteFirst;

        ServerSettings settings;
        settings.show();
        settings.exec();

        serverPort = settings.portSelected;
        if (!~serverPort) return 0;

        server = new ServerThread(serverPort, timeLimit, initStatus, whiteFirst);
        server->start();
        server->moveToThread(server);

        client.connectToServer(getCurrentInterfaceAddress().ip(), serverPort);

        Waiting waitingPage;
        QObject::connect(server, SIGNAL(onClientsConnected()), &waitingPage, SLOT(close()));
        waitingPage.show();
        waitingPage.exec();

        serverAddr = getCurrentInterfaceAddress().ip().toString();
    } else {
        ConnectToServer conn;
        conn.show();
        conn.exec();

        serverAddr = conn.serverIp;
        serverPort = conn.serverPort;

        if (!~serverPort) return 0;

        client.connectToServer(QHostAddress(serverAddr), serverPort);

        Waiting waitingPage;
        QObject::connect(&client, SIGNAL(onConnected()), &waitingPage, SLOT(close()));
        waitingPage.show();
        waitingPage.exec();
    }

    MainWindow mw(&client);
    mw.show();
    int rv = app.exec();

    client.sock->disconnectFromHost();
    return rv;
}
//============================================================================
int main( int argc, char *argv[] )
{	

	// I can't live without my precious printf's
#ifdef WIN32
#  ifndef NDEBUG
	AllocConsole();
	SetConsoleTitle( L"ld15_cavern CONSOLE" );
	freopen("CONOUT$", "w", stdout );
#  endif
#endif
	
	
	// make sure no vesion mismatch for protobuf
	GOOGLE_PROTOBUF_VERIFY_VERSION;

	// Initialize SDL
	if (SDL_Init( SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO ) < 0 ) 
	{
		errorMessage( string("Unable to init SDL:") + SDL_GetError() );
		exit(1);
	}

	// cheezy check for fullscreen
	Uint32 mode_flags = SDL_OPENGL;
	for (int i=1; i < argc; i++)
	{
		if (!stricmp( argv[i], "-fullscreen"))
		{
			mode_flags |= SDL_FULLSCREEN;
		}
	}

	if (SDL_SetVideoMode( 800, 600, 32, mode_flags ) == 0 ) 
	{
		errorMessage( string("Unable to set video mode: ") +  SDL_GetError() ) ;
		exit(1);
	}
		

	SDL_WM_SetCaption( "Spaceships in a Cave", NULL );

	// seed rand
	srand( time(0) );

	// initialize DevIL
	ilInit();
	ilutRenderer( ILUT_OPENGL );

	// Initialize enet
	if (enet_initialize() != 0)
	{
		errorMessage( "Unable to initialize networking." );
		exit(1);
	}
	
	// clean up net stuff at exit
	atexit( enet_deinitialize );

	// init game object
	GameClient *game = new GameClient();

	//=====[ Main loop ]======
	Uint32 ticks = SDL_GetTicks(), ticks_elapsed, sim_ticks = 0;	
	while(!game->done())
	{
		SDL_Event event;

		while (SDL_PollEvent( &event ) ) 
		{
			switch (event.type )
			{
				case SDL_KEYDOWN:
					switch( event.key.keysym.sym ) 
					{						
						case SDLK_ESCAPE:
							game->done( true );
							break;
					}

					// let the game handle it
					game->keypress( event.key );
					break;

				case SDL_MOUSEMOTION:					
					break;

				case SDL_MOUSEBUTTONDOWN:					
					game->mouse( event.button );
					break;

				case SDL_MOUSEBUTTONUP:					
					game->mouse( event.button );
					break;				

				case SDL_QUIT:
					game->done( true );
					break;
			}
		}
		
		
		// Timing
		ticks_elapsed = SDL_GetTicks() - ticks;
		ticks += ticks_elapsed;

		// fixed sim update
		sim_ticks += ticks_elapsed;
		while (sim_ticks > STEPTIME) 
		{
			sim_ticks -= STEPTIME;						

			//printf("update sim_ticks %d ticks_elapsed %d\n", sim_ticks, ticks_elapsed );						
			game->updateSim( (float)STEPTIME / 1000.0f );			
		}	

		// redraw as fast as possible		
		float dtRaw = (float)(ticks_elapsed) / 1000.0f;
				
		game->update( dtRaw ); 
		game->redraw();
		

		SDL_GL_SwapBuffers();

        ReloadChangedTweakableValues();        
	}

	delete game;

	return 1;
}
Пример #23
0
void ButtonContact::setButton( Noun * pNoun )
{
	ASSERT( pNoun != NULL );

	m_Flags |= NOCLIP;
	m_Style = HAS_BACK | EFFECT_HIGHLIGHT | SMOOTH_LL;
	//m_Alpha = 0.75f;

	// set the window name to the same as our contact
	setName( pNoun->name() );

	// set the noun
	m_Noun = pNoun;
	if ( WidgetCast<NounShip>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( NounShip::typeText( ((NounShip *)pNoun)->type() ) ) ) );
	else if ( WidgetCast<NounPlanet>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "PLANET" ) ) );
	else if ( WidgetCast<NounStar>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "STAR" ) ) );
	else if ( WidgetCast<NounNebula>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "NEBULA" ) ) );
	else if ( WidgetCast<NounAsteroid>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "ASTEROID" ) ) );
	else if ( WidgetCast<NounTarget>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "TARGET" ) ) );
	else if ( WidgetCast<NounJumpGate>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "JUMPGATE" ) ) );
	else if ( WidgetCast<NounProjectile>( pNoun ) )
		setIcon( WidgetCast<Material>( resource( "PROJECTILE" ) ) );
	else
		setIcon( WidgetCast<Material>( resource( "UNKNOWN" ) ) );

	// determine if this contact is an objective!
	GameDocument * pDoc = (GameDocument *)document();
	ASSERT( pDoc );
	GameContext * pContext = pDoc->context();
	ASSERT( pContext );
	GameClient * pClient = pDoc->client();
	ASSERT( pClient );

	int myFaction = pDoc->factionId();

	m_IsObjective = false;
	for(int i=0;i<pContext->conditionCount();i++)
	{
		const GameContext::Condition & condition = pContext->conditionN( i );
		for(int j=0;j<condition.objectives.size();j++)
			if ( condition.objectives[j].noun == m_Noun->key() && condition.objectives[j].factionId == myFaction )
			{
				m_IsObjective = true;
				m_Objective = (ObjectiveType)condition.objectives[j].type;
				break;
			}

		if ( m_IsObjective )
			break;
	}

	if ( pNoun->userId() != 0 )
	{
		Group * pGroup = pClient->group();
		if ( pGroup != NULL )
		{
			m_bGroupLeader = pGroup->isLeader( pNoun->userId() );
			m_bGroupPending = pGroup->isPending( pNoun->userId() );
		}
	}

	// set the tool tip
	CharString tip( pNoun->name() );
	if ( m_IsObjective )
		tip += CharString().format(" / Objective: %s", GameContext::objectiveText( m_Objective ) );

	setTip( tip );
}
Пример #24
0
void GameHandler::sendTo(Character *beingPtr, MessageOut &msg)
{
    GameClient *client = beingPtr->getClient();
    assert(client && client->status == CLIENT_CONNECTED);
    client->send(msg);
}