← Back to branch summary

~swag/armagetronad/0.2.9-sty+ct+ap-fork

« back to all changes in this revision

Viewing changes to src/engine/ePlayer.cpp

  • Committer: SwagTron
  • Date: 2019-03-03 20:57:16 UTC
  • Revision ID: swagtron-20190303205716-nk32wtrusb3tum54
As far as I am aware, compiling 2.9 sty+ct+ap was incredibly difficult and impossible without using older versions merged with the latest revision (thanks to Nelg's help). Created a proper win32 folder, a readme file, and made it simple to compile for windows.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/engine/ePlayer.cpp
1331
1331
    StoreConfitem(tNEW(tConfItem<int>) (confname,
1332
1332
                                        "$color_r_help",
1333
1333
                                        rgb[0]));
1334
 
 
1335
 
    confname.Clear();
1336
 
    confname << "PLAYER_RANDOM_COLOR_"<< id+1;
1337
 
    colorRandomization=0;
1338
 
    StoreConfitem(tNEW(tConfItem<int>) (confname,
1339
 
                                         "$player_random_color_help",
1340
 
                                         colorRandomization));
1341
1334
    confname.Clear();
1342
1335
#endif
1343
1336
 
3044
3037
}
3045
3038
#endif // DEDICATED
3046
3039
 
3047
 
//static bool se_silenceDead = false;
3048
 
//static tSettingItem<bool> se_silenceDeadConf("SILENCE_DEAD", se_silenceDead);
 
3040
static bool se_silenceDead = false;
 
3041
static tSettingItem<bool> se_silenceDeadConf("SILENCE_DEAD", se_silenceDead);
3049
3042
 
3050
3043
// help message printed out to whoever asks for it
3051
3044
static tString se_helpMessage("");
4630
4623
// a name is only legal if it contains at least one non-witespace character.
4631
4624
static bool IsLegalPlayerName( tString const & name )
4632
4625
{
4633
 
    tString userName = se_UnauthenticatedUserName( name );
4634
 
    if ( userName.Len() <= 1 )
4635
 
        return false;
4636
 
 
4637
4626
    // strip colors
4638
4627
    tString stripped( tColoredString::RemoveColors( name ) );
4639
4628
 
4647
4636
    return false;
4648
4637
}
4649
4638
 
4650
 
#ifndef DEDICATED
4651
 
static bool se_enableChatCommands = true;
4652
 
static tSettingItem<bool> se_enableChatCommandsConf( "CHAT_LOCAL_COMMANDS", se_enableChatCommands );
4653
 
 
4654
 
//our local commands (should always be lowercase)
4655
 
static char const * const se_localChatCommands[] = {
4656
 
    "/console",
4657
 
    "/listcolors",
4658
 
    "/colors",
4659
 
    "/info",
4660
 
    "/rgb"
4661
 
};
4662
 
#endif //if not dedicated
4663
 
 
4664
4639
void ePlayerNetID::Chat(const tString &s_orig)
4665
4640
{
4666
4641
    tColoredString s( s_orig );
4667
4642
    s.NetFilter();
4668
4643
 
4669
4644
#ifndef DEDICATED
4670
 
 
4671
 
    std::string chatString(s_orig);
4672
 
    std::istringstream passedString(chatString);
4673
 
 
4674
 
    tString command;
4675
 
 
4676
 
    passedString >> command;
4677
 
    tToLower( command );
4678
 
    tConfItemBase::EatWhitespace(passedString);
4679
 
 
4680
 
    bool isLocalCommand  = false;
4681
 
 
4682
 
    for (int i = sizeof(se_localChatCommands)/sizeof(se_localChatCommands[0]) - 1; i >= 0; --i)
4683
 
    {
4684
 
        if (command.StartsWith(se_localChatCommands[i]))
4685
 
        {
4686
 
            isLocalCommand = true;
4687
 
        }
4688
 
    }
4689
 
 
4690
 
    if (isLocalCommand && se_enableChatCommands && (s_orig.StartsWith("/")))
4691
 
    {
4692
 
        // check for direct console commands
4693
 
        if (command == "/console")
4694
 
        {
4695
 
            // direct commands are executed at owner level
4696
 
            tCurrentAccessLevel level( tAccessLevel_Owner, true );
4697
 
 
4698
 
            tString params("");
4699
 
            if (s_orig.StrPos(" ") == -1)
4700
 
                return;
4701
 
            else
4702
 
                params = s_orig.SubStr(s_orig.StrPos(" ") + 1);
4703
 
 
4704
 
            if ( tRecorder::IsPlayingBack() )
4705
 
            {
4706
 
                tConfItemBase::LoadPlayback();
4707
 
            }
4708
 
            else
4709
 
            {
4710
 
                std::stringstream s(static_cast< char const * >( params ) );
4711
 
                tConfItemBase::LoadAll(s);
4712
 
            }
4713
 
        }
4714
 
        //Short handle for grabbing player colors.
4715
 
        else if ((command == "/listcolors") || (command == "/colors"))
4716
 
        {
4717
 
            listPlayerColors(tString(s_orig));
4718
 
        }
4719
 
        //Short handle for grabbing player information.
4720
 
        else if (command == "/info")
4721
 
        {
4722
 
            listPlayerInfo(tString(s_orig));
4723
 
        }
4724
 
        //Short handle for changing our RGB values.
4725
 
        else if (command == "/rgb")
4726
 
        {
4727
 
            currentPlayerRGB(tString(s_orig));
 
4645
    // check for direct console commands
 
4646
    if( s_orig.StartsWith("/console") )
 
4647
    {
 
4648
        // direct commands are executed at owner level
 
4649
        tCurrentAccessLevel level( tAccessLevel_Owner, true );
 
4650
 
 
4651
        tString params("");
 
4652
        if (s_orig.StrPos(" ") == -1)
 
4653
            return;
 
4654
        else
 
4655
            params = s_orig.SubStr(s_orig.StrPos(" ") + 1);
 
4656
 
 
4657
        if ( tRecorder::IsPlayingBack() )
 
4658
        {
 
4659
            tConfItemBase::LoadPlayback();
 
4660
        }
 
4661
        else
 
4662
        {
 
4663
            std::stringstream s(static_cast< char const * >( params ) );
 
4664
            tConfItemBase::LoadAll(s);
4728
4665
        }
4729
4666
    }
4730
4667
    else
4731
 
#endif //if not dedicated
 
4668
#endif
4732
4669
    {
4733
4670
        tString retStr(s);
4734
4671
        if (eBannedWords::BadWordTrigger(this, retStr))
4737
4674
 
4738
4675
        switch (sn_GetNetState())
4739
4676
        {
4740
 
        case nCLIENT:
4741
 
        {
4742
 
            se_NewChatMessage( this, s )->BroadCast();
4743
 
            break;
4744
 
        }
4745
 
        case nSERVER:
4746
 
        {
4747
 
            se_BroadcastChat( this, s );
 
4677
            case nCLIENT:
 
4678
            {
 
4679
                se_NewChatMessage( this, s )->BroadCast();
 
4680
                break;
 
4681
            }
 
4682
            case nSERVER:
 
4683
            {
 
4684
                se_BroadcastChat( this, s );
4748
4685
 
4749
 
            // falling through on purpose
4750
 
            // break;
4751
 
        }
4752
 
        default:
4753
 
        {
4754
 
            se_DisplayChatLocally( this, s );
4755
 
            break;
4756
 
        }
 
4686
                // falling through on purpose
 
4687
                // break;
 
4688
            }
 
4689
            default:
 
4690
            {
 
4691
                se_DisplayChatLocally( this, s );
 
4692
                break;
 
4693
            }
4757
4694
        }
4758
4695
    }
4759
4696
}
4773
4710
}
4774
4711
*/
4775
4712
 
4776
 
// identify a local human player
 
4713
// identify a local player
4777
4714
ePlayerNetID *se_GetLocalPlayer()
4778
4715
{
4779
4716
    for(int i=0; i<se_PlayerNetIDs.Len(); i++)
4780
4717
    {
4781
4718
        ePlayerNetID *p = se_PlayerNetIDs[i];
4782
4719
 
4783
 
        if( p->Owner() == sn_myNetID && p->IsHuman())
 
4720
        if( p->Owner() == sn_myNetID )
4784
4721
            return p;
4785
4722
    }
4786
4723
    return NULL;
7365
7302
tSettingItem< bool > se_stripMiddleConf( "FILTER_NAME_MIDDLE", se_stripMiddle );
7366
7303
 
7367
7304
// do the optional filtering steps
7368
 
static void se_OptionalNameFilters( tString & remoteName, int owner )
 
7305
static void se_OptionalNameFilters( tString & remoteName )
7369
7306
{
7370
7307
    // filter colors
7371
7308
    if ( se_filterColorNames )
7432
7369
        else
7433
7370
        {
7434
7371
            // or replace it by a default value
7435
 
            remoteName = "Player ";
7436
 
            remoteName << owner;
 
7372
            remoteName = "Player 1";
7437
7373
        }
7438
7374
    }
7439
7375
}
7469
7405
        m >> remoteName;
7470
7406
 
7471
7407
        // filter
7472
 
        se_OptionalNameFilters( remoteName, Owner() );
 
7408
        se_OptionalNameFilters( remoteName );
7473
7409
 
7474
7410
        //  remove all colors from name
7475
7411
        tString colorlessName = tColoredString::RemoveColors(remoteName, false);
8119
8055
#endif
8120
8056
}
8121
8057
 
8122
 
// Should we hide the chat flag in tab when the user is silenced?
8123
 
static bool se_HideSilencedPlayersTabChatFlag    = true;
8124
 
static tSettingItem<bool> se_HideSilencedPlayersTabChatFlagConf("HIDE_SILENCED_SCOREBOARD_CHATFLAG", se_HideSilencedPlayersTabChatFlag  );
8125
8058
 
8126
8059
tString ePlayerNetID::Ranking( int MAX, bool cut )
8127
8060
{
8169
8102
            // line << tColoredString::ColorString( p->r/15.0, p->g/15.0, p->b/15.0 ) << name << tColoredString::ColorString(1,1,1);
8170
8103
 
8171
8104
            // however, using the streaming operator is a lot cleaner. The example is left, as it really can be usefull in some situations.
8172
 
            
8173
8105
            if (p->IsChatting())
8174
 
            {
8175
 
                // If the HIDE_SILENCED_SCOREBOARD_CHATFLAG command is set to false and the player is not silenced, show the tab chatflag.
8176
 
                if (!(se_HideSilencedPlayersTabChatFlag && p->AccessSilenced()))
8177
 
                {
8178
 
                    line << tColoredString::ColorString(-1, -1, -1) << "*";
8179
 
                }
8180
 
            }
 
8106
                line << tColoredString::ColorString(-1,-1,-1) << "*";
8181
8107
            line.SetPos(2, cut);
8182
8108
            line << *p;
8183
8109
            line.SetPos(19, false );
8202
8128
                {
8203
8129
                    //tString teamtemp = p->currentTeam->Name();
8204
8130
                    //teamtemp.RemoveHex();
8205
 
                    //Not sure why we need to filter the color here. 
8206
 
                       // line << tColoredString::RemoveColors(p->currentTeam->Name());
8207
 
                    line << p->currentTeam->GetColoredName();
 
8131
                    line << tColoredString::RemoveColors(p->currentTeam->Name());
8208
8132
                    line.SetPos(56, cut );
8209
8133
                }
8210
8134
            }
8458
8382
    return distance;
8459
8383
}
8460
8384
 
8461
 
 
8462
 
static int se_RandomizeColorRange = 32;
8463
 
static tSettingItem<int> se_RandomizeColorRangeConf("PLAYER_RANDOM_COLOR_RANGE", se_RandomizeColorRange);
8464
 
 
8465
 
//This seems more random. Stolen from the old randomize color, but no comparing. 
8466
 
static void se_RandomizeColor(ePlayer * l)
8467
 
{
8468
 
    int currentRGB[3];
8469
 
    int newRGB[3];
8470
 
  
8471
 
    static tReproducibleRandomizer randomizer;
8472
 
 
8473
 
    for( int i = 2; i >= 0; --i )
8474
 
    {
8475
 
        currentRGB[i] = l->rgb[i];
8476
 
        newRGB[i] = randomizer.Get(se_RandomizeColorRange+1);
8477
 
    }
8478
 
 
8479
 
    for( int i = 2; i >= 0; --i )
8480
 
    {
8481
 
        l->rgb[i] = newRGB[i];
8482
 
    }
8483
 
}
8484
 
 
8485
 
 
8486
 
//This didnt seem to be too random, more like picking a unique color no one else currently has.
8487
 
static void se_UniqueColor( ePlayer * l, ePlayerNetID * p )
 
8385
bool se_randomizeColor = false;
 
8386
static tSettingItem< bool > se_randomizeColorConf( "PLAYER_RANDOM_COLOR", se_randomizeColor );
 
8387
 
 
8388
static void se_RandomizeColor( ePlayer * l, ePlayerNetID * p )
8488
8389
{
8489
8390
    int currentRGB[3];
8490
8391
    int newRGB[3];
8531
8432
    }
8532
8433
}
8533
8434
 
8534
 
//Gather all the rgb colors and put them in a nice list.
8535
 
//Usage /colors with no parameters returns all players and their colors.
8536
 
//      /colors playername returns that specific players color or more depending if the search term is found in other player names
8537
 
void ePlayerNetID::listPlayerColors(tString s_orig)
8538
 
{
8539
 
 
8540
 
    if (se_PlayerNetIDs.Len()>0)
8541
 
    {
8542
 
        if (s_orig.StrPos(" ") == -1)
8543
 
        {
8544
 
            con << tOutput("$player_colors_text");
8545
 
 
8546
 
            for ( int i = 0; i <= se_PlayerNetIDs.Len()-1; i++ )
8547
 
            {
8548
 
                ePlayerNetID *p=se_PlayerNetIDs(i);
8549
 
                con << (i+1) << ": " << gatherPlayerColor(p);
8550
 
 
8551
 
            }
8552
 
        }
8553
 
        else
8554
 
        {
8555
 
            tArray<tString> msgsExt = s_orig.Split(" ");
8556
 
            bool playerFound = false;
8557
 
 
8558
 
            con << tOutput("$player_colors_text");
8559
 
 
8560
 
            for(int i = 0; i < msgsExt.Len(); i++)
8561
 
            {
8562
 
                tString word = msgsExt[i];
8563
 
                int j = 0;
8564
 
                for ( int i = 0; i <= se_PlayerNetIDs.Len()-1; i++ )
8565
 
                {
8566
 
                    ePlayerNetID *p=se_PlayerNetIDs(i);
8567
 
 
8568
 
                    if (p->GetName().Filter().Contains(word.Filter()))
8569
 
                    {
8570
 
                        playerFound = true;
8571
 
 
8572
 
                        con << (j+1) << ": " << gatherPlayerColor(p);
8573
 
                        j++;
8574
 
 
8575
 
                    }
8576
 
                }
8577
 
            }
8578
 
            //No one found.
8579
 
            if (!playerFound)
8580
 
            {
8581
 
                con << tOutput("$player_not_found_text", msgsExt[1]);
8582
 
            }
8583
 
 
8584
 
        }
8585
 
 
8586
 
    }
8587
 
}
8588
 
 
8589
 
//Not sure if this is better / faster but better looking I guess?
8590
 
tColoredString ePlayerNetID::gatherPlayerColor(ePlayerNetID * p)
8591
 
{
8592
 
tColoredString listColors;
8593
 
return listColors << p->GetColoredName() << "0xRESETT (" << p->r << ", " << p->g << ", " << p->b << ")\n";
8594
 
}
8595
 
 
8596
 
 
8597
 
 
8598
 
/*
8599
 
List player information.
8600
 
Displays:
8601
 
Colored Name
8602
 
Position
8603
 
Direction
8604
 
Used Rubber out of max
8605
 
Speed
8606
 
Spectating / Playing
8607
 
Chatting
8608
 
Sometimes Alive / Dead
8609
 
Usage: /info - Returns own information
8610
 
       /info playername - Returns that players name. (or more depending if the search word is found in more than one player)
8611
 
*/
8612
 
 
8613
 
void ePlayerNetID::listPlayerInfo(tString s_orig)
8614
 
{
8615
 
 
8616
 
    if (se_PlayerNetIDs.Len()>0)
8617
 
    {
8618
 
        if (s_orig.StrPos(" ") == -1)
8619
 
        {
8620
 
            con << tOutput("$player_info_text");
8621
 
            ePlayerNetID *p = se_GetLocalPlayer();
8622
 
            con << gatherPlayerInfo(p);
8623
 
        }
8624
 
        else
8625
 
        {
8626
 
            tArray<tString> msgsExt = s_orig.Split(" ");
8627
 
            tArray<ePlayerNetID *> foundPlayers;
8628
 
            bool playerFound = false;
8629
 
            con << tOutput("$player_info_text");
8630
 
            for(int i = 0; i < msgsExt.Len(); i++)
8631
 
            {
8632
 
                tString word = msgsExt[i];
8633
 
 
8634
 
                for(int i=0; i < se_PlayerNetIDs.Len(); i++)
8635
 
                {
8636
 
                    ePlayerNetID *p=se_PlayerNetIDs(i);
8637
 
 
8638
 
                    if (p->GetName().Filter().Contains(word.Filter()))
8639
 
                    {
8640
 
                        playerFound = true;
8641
 
 
8642
 
                        con << gatherPlayerInfo(p);
8643
 
 
8644
 
                    }
8645
 
                }
8646
 
            }
8647
 
 
8648
 
            if (!playerFound)
8649
 
            {
8650
 
                con << tOutput("$player_not_found_text", msgsExt[1]);
8651
 
            }
8652
 
 
8653
 
        }
8654
 
 
8655
 
    }
8656
 
}
8657
 
 
8658
 
 
8659
 
 
8660
 
tColoredString ePlayerNetID::gatherPlayerInfo(ePlayerNetID * p)
8661
 
{
8662
 
    tColoredString listinfo;
8663
 
    listinfo << "Results for " << p->GetColoredName() << "0xRESETT: \n";
8664
 
 
8665
 
    ///Status. Includes player type, spectating or playing, and if the player is chatting.
8666
 
    listinfo << "Status: ";
8667
 
    (p->IsHuman()) ? listinfo << "Human" : listinfo << "Bot";
8668
 
 
8669
 
    //Oddly IsSpectating returned some confusing results.
8670
 
    (!p->CurrentTeam()) ? listinfo << ", Spectating" : listinfo << ", Playing";
8671
 
 
8672
 
    //Are we chatting / out of focus? Calculating the time worked for our local player but didnt work too well for players who joined before us.
8673
 
    (p->IsChatting()) ? listinfo << ", Chatting" : listinfo << ""; // ("<< fabs(p->TimeChatting()) << ") seconds\n" : listinfo << "\n";
8674
 
 
8675
 
 
8676
 
    //Only grab this information if the player is an active object.
8677
 
    if (p->Object() && p->currentTeam)
8678
 
    {
8679
 
        //If the player is an active object, are they alive? Pretty sure we know this already but no harm in including it.
8680
 
        (p->Object()->Alive()) ? listinfo << ", Alive\n" : listinfo << ", Dead\n";
8681
 
 
8682
 
        //Only grab this information if the player is an alive object.
8683
 
        if (p->Object()->Alive())
8684
 
        {
8685
 
            gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
8686
 
 
8687
 
            listinfo <<  "Position: x: " << pCycle->MapPosition().x << ", y: " << pCycle->MapPosition().y  << "\n";
8688
 
 
8689
 
            //Had trouble converting the direction to an angle, will have to visit this later
8690
 
            listinfo << "Map Direction: " << "x: " << pCycle->MapDirection().x << ", y: " << pCycle->MapDirection().y << "\n";
8691
 
            listinfo << "Speed: " << pCycle->verletSpeed_  << "\n";
8692
 
            listinfo << "Rubber: " << pCycle->GetRubber() << "/" << sg_rubberCycle << "\n";
8693
 
        }
8694
 
    }
8695
 
 
8696
 
    return listinfo << "\n";
8697
 
}
8698
 
 
8699
 
// Allow us to change our current RGB easily.
8700
 
// Usage: /rgb with no parameters displays current rgb.
8701
 
//        /rgb 15 3 3 Would set player 1's RGB to R15 G3 B3. 
8702
 
//        /rgb unique gives all players unique colors.
8703
 
//        /rgb random gives all players random colors.
8704
 
//        /rgb 2 15 3 3 Will change player 2's colors to 15 3 3. 
8705
 
void ePlayerNetID::currentPlayerRGB(tString s_orig)
8706
 
{
8707
 
    if (s_orig.StrPos(" ") == -1)
8708
 
    {
8709
 
        con << tOutput("$player_colors_current_text");
8710
 
        for(int i=0; i<MAX_PLAYERS; ++i )
8711
 
        {
8712
 
            bool in_game=ePlayer::PlayerIsInGame(i);
8713
 
            ePlayer *me=ePlayer::PlayerConfig(i);
8714
 
            tASSERT(me);
8715
 
            tCONTROLLED_PTR(ePlayerNetID) &p=me->netPlayer;
8716
 
            if (bool(p) && in_game)
8717
 
            {
8718
 
                tColoredString listColors;
8719
 
                listColors << p->GetColoredName() << "0xRESETT (" << ePlayer::PlayerConfig(i)->rgb[0] << ", " << ePlayer::PlayerConfig(i)->rgb[1] << ", " << ePlayer::PlayerConfig(i)->rgb[2] << ")\n";
8720
 
                con << listColors;
8721
 
            }
8722
 
        }
8723
 
    }
8724
 
    else
8725
 
    {
8726
 
        tArray<tString> passedString = s_orig.Split(" ");
8727
 
        bool correctParameters = false;
8728
 
        bool random = false;
8729
 
        bool unique = false;
8730
 
        int ourID = 0;
8731
 
 
8732
 
        if (passedString[1] == "random")
8733
 
        {
8734
 
            correctParameters = true;
8735
 
            random = true;
8736
 
 
8737
 
            //For now everyone gets random colors.
8738
 
            for(int i=0; i<MAX_PLAYERS; ++i )
8739
 
            {
8740
 
                bool in_game = ePlayer::PlayerIsInGame(i);
8741
 
                ePlayer *me = ePlayer::PlayerConfig(i);
8742
 
                tASSERT(me);
8743
 
                tCONTROLLED_PTR(ePlayerNetID) &p=me->netPlayer;
8744
 
 
8745
 
                if (bool(p) && in_game)
8746
 
                {
8747
 
                    se_RandomizeColor(me);
8748
 
                }
8749
 
            }
8750
 
 
8751
 
        }
8752
 
        else if(passedString[1] == "unique")
8753
 
        {
8754
 
            correctParameters = true;
8755
 
            unique = true;
8756
 
            //Also everyone gets unique colors if sent.
8757
 
            for(int i=0; i<MAX_PLAYERS; ++i )
8758
 
            {
8759
 
                bool in_game=ePlayer::PlayerIsInGame(i);
8760
 
                ePlayer *me=ePlayer::PlayerConfig(i);
8761
 
                tASSERT(me);
8762
 
                tCONTROLLED_PTR(ePlayerNetID) &p=me->netPlayer;
8763
 
 
8764
 
                if (bool(p) && in_game)
8765
 
                {
8766
 
                    se_UniqueColor(me,p);
8767
 
                }
8768
 
            }
8769
 
        }
8770
 
 
8771
 
        //Not really checking if the strings passed parameters are numbers, but if someone did /rgb asd asd asd it would just make it 0 0 0.
8772
 
        else if (passedString.Len() >= 4 && !(random || unique ))
8773
 
        {
8774
 
            //Guess we must be ID 0?
8775
 
            if (passedString.Len() == 4)
8776
 
            {
8777
 
                correctParameters = true;
8778
 
 
8779
 
                unsigned short r = (unsigned short) strtoul(passedString[1], NULL, 0);
8780
 
                unsigned short g = (unsigned short) strtoul(passedString[2], NULL, 0);
8781
 
                unsigned short b = (unsigned short) strtoul(passedString[3], NULL, 0);
8782
 
                
8783
 
                ePlayer::PlayerConfig(0)->rgb[0] = r;
8784
 
                ePlayer::PlayerConfig(0)->rgb[1] = g;
8785
 
                ePlayer::PlayerConfig(0)->rgb[2] = b;
8786
 
 
8787
 
            }
8788
 
            else if (passedString.Len() == 5)
8789
 
            {
8790
 
                ourID = (unsigned short) strtoul(passedString[1], NULL, 0);
8791
 
                if ((ourID <= MAX_PLAYERS) && (ourID > 0))
8792
 
                {
8793
 
                    correctParameters = true;
8794
 
 
8795
 
                    bool in_game=ePlayer::PlayerIsInGame(ourID-1);
8796
 
                    ePlayer *me=ePlayer::PlayerConfig(ourID-1);
8797
 
 
8798
 
                    unsigned short r = (unsigned short) strtoul(passedString[2], NULL, 0);
8799
 
                    unsigned short g = (unsigned short) strtoul(passedString[3], NULL, 0);
8800
 
                    unsigned short b = (unsigned short) strtoul(passedString[4], NULL, 0);
8801
 
 
8802
 
                    ePlayer::PlayerConfig(ourID-1)->rgb[0] = r;
8803
 
                    ePlayer::PlayerConfig(ourID-1)->rgb[1] = g;
8804
 
                    ePlayer::PlayerConfig(ourID-1)->rgb[2] = b;
8805
 
                }
8806
 
            }
8807
 
        }
8808
 
 
8809
 
        // If the correct parameters are passed, display the changes.
8810
 
        if (correctParameters)
8811
 
        {
8812
 
            con << tOutput("$player_colors_current_text");
8813
 
 
8814
 
            for(int i=0; i<MAX_PLAYERS; ++i )
8815
 
            {
8816
 
                bool in_game=ePlayer::PlayerIsInGame(i);
8817
 
                ePlayer *me=ePlayer::PlayerConfig(i);
8818
 
                tASSERT(me);
8819
 
                tCONTROLLED_PTR(ePlayerNetID) &p=me->netPlayer;
8820
 
                if (bool(p) && in_game)
8821
 
                {   tColoredString listColors;
8822
 
                    listColors << i+1 << ": " << p->GetColoredName() << "0xRESETT (" << ePlayer::PlayerConfig(i)->rgb[0] << ", " << ePlayer::PlayerConfig(i)->rgb[1] << ", " << ePlayer::PlayerConfig(i)->rgb[2] << ")\n";
8823
 
                    con << listColors;
8824
 
                }
8825
 
                if(!(bool(p) && in_game) && ourID-1 == i)
8826
 
                {
8827
 
                    con << tOutput("$player_colors_changed_text", ourID, ePlayer::PlayerConfig(i)->rgb[0], ePlayer::PlayerConfig(i)->rgb[1], ePlayer::PlayerConfig(i)->rgb[2]);
8828
 
                }
8829
 
            }
8830
 
        }
8831
 
        else
8832
 
        {
8833
 
            con << tOutput("$player_colors_changed_usage_error");
8834
 
        }
8835
 
    }
8836
 
}
8837
 
 
8838
 
 
8839
 
 
8840
 
 
8841
8435
static nSettingItem<int> se_pingCharityServerConf("PING_CHARITY_SERVER",sn_pingCharityServer );
8842
8436
static nVersionFeature   se_pingCharityServerControlled( 14 );
8843
8437
 
8946
8540
                p->favoriteNumberOfPlayersPerTeam=ePlayer::PlayerConfig(i)->favoriteNumberOfPlayersPerTeam;
8947
8541
                p->nameTeamAfterMe=ePlayer::PlayerConfig(i)->nameTeamAfterMe;
8948
8542
 
8949
 
                //Does the player want color randomization?
8950
 
                switch(ePlayer::PlayerConfig(i)->colorRandomization)
8951
 
                    {
8952
 
                        case COLORRANDOMIZATIONOFF:
8953
 
                            break;
8954
 
                        case COLORRANDOMIZATIONRANDOM:
8955
 
                        se_RandomizeColor(local_p);
8956
 
                            break;
8957
 
                        case COLORRANDOMIZATIONUNIQUE:
8958
 
                        se_UniqueColor(local_p,p);
8959
 
                            break;
8960
 
                        default:
8961
 
                        //Number not in the range of 0-2? Oh well, no color randomization for you.
8962
 
                            break;
8963
 
                    }
8964
 
 
 
8543
                if ( se_randomizeColor )
 
8544
                {
 
8545
                    se_RandomizeColor(local_p,p);
 
8546
                }
8965
8547
 
8966
8548
                p->r=ePlayer::PlayerConfig(i)->rgb[0];
8967
8549
                p->g=ePlayer::PlayerConfig(i)->rgb[1];
10651
10233
 
10652
10234
static void Silence_conf(std::istream &s)
10653
10235
{
 
10236
    if ( se_NeedsServer( "SILENCE", s ) )
 
10237
    {
 
10238
        return;
 
10239
    }
 
10240
 
10654
10241
    ePlayerNetID * p = ReadPlayer( s );
10655
10242
    if ( p && !p->IsSilenced() )
10656
10243
    {
10657
 
#ifndef DEDICATED
10658
 
        if ( sn_GetNetState() == nCLIENT )
10659
 
            sn_ConsoleOut( tOutput( "$player_silenced_local", p->GetColoredName() ) );
10660
 
        else
10661
 
#endif
10662
 
            sn_ConsoleOut( tOutput( "$player_silenced", p->GetColoredName() ) );
 
10244
        sn_ConsoleOut( tOutput( "$player_silenced", p->GetColoredName() ) );
10663
10245
        p->SetSilenced( true );
10664
10246
    }
10665
10247
}
10669
10251
 
10670
10252
static void SilenceAll_conf(std::istream &s)
10671
10253
{
10672
 
    if (se_PlayerNetIDs.Len() > 0)
 
10254
    if ( se_NeedsServer( "SILENCE_ALL", s ) )
 
10255
    {
 
10256
        return;
 
10257
    }
 
10258
 
 
10259
    if (se_PlayerNetIDs.Len()>0)
10673
10260
    {
10674
10261
        int max = se_PlayerNetIDs.Len();
10675
 
        for (int i = 0; i < max; i++)
10676
 
        {
10677
 
            ePlayerNetID *p = se_PlayerNetIDs(i);
10678
 
 
10679
 
            #ifndef DEDICATED
10680
 
            if ((sn_GetNetState() == nCLIENT) && (p && !p->IsSilenced()) && ((p->Owner() != ::sn_myNetID)))
10681
 
            {
10682
 
                p->SetSilenced(true);
10683
 
            }
10684
 
            else
10685
 
            #endif
10686
 
            {
10687
 
                if ((sn_GetNetState() == nSERVER) && (p && !p->IsSilenced()))
10688
 
                {
10689
 
                    p->SetSilenced(true);
10690
 
                }
10691
 
            }
10692
 
        }
10693
 
        #ifndef DEDICATED
10694
 
        if (sn_GetNetState() == nCLIENT)
10695
 
        {
10696
 
            sn_ConsoleOut(tOutput("$player_silenced_all_local"));
10697
 
        }
10698
 
        #endif
10699
 
        if (sn_GetNetState() == nSERVER)
10700
 
        {
10701
 
            sn_ConsoleOut(tOutput("$player_silenced_all"));
10702
 
        }
 
10262
        for(int i=0; i<max; i++)
 
10263
        {
 
10264
            ePlayerNetID *p=se_PlayerNetIDs(i);
 
10265
            if ( p && !p->IsSilenced() )
 
10266
            {
 
10267
                p->SetSilenced( true );
 
10268
            }
 
10269
        }
 
10270
        sn_ConsoleOut( tOutput( "$player_silenced_all") );
10703
10271
    }
10704
10272
}
10705
10273
 
10706
 
 
10707
10274
static tConfItemFunc silenceall_conf("SILENCE_ALL",&SilenceAll_conf);
10708
10275
static tAccessLevelSetter se_silenceallConfLevel( silenceall_conf, tAccessLevel_Moderator );
10709
10276
 
10710
10277
static void Voice_conf(std::istream &s)
10711
10278
{
 
10279
    if ( se_NeedsServer( "VOICE", s ) || se_NeedsServer( "UNSILENCE", s ))
 
10280
    {
 
10281
        return;
 
10282
    }
 
10283
 
10712
10284
    ePlayerNetID * p = ReadPlayer( s );
10713
10285
    if ( p && p->IsSilenced() )
10714
10286
    {
10715
 
#ifndef DEDICATED
10716
 
        if ( sn_GetNetState() == nCLIENT )
10717
 
            sn_ConsoleOut( tOutput( "$player_voiced_local", p->GetColoredName() ) );
10718
 
        else
10719
 
#endif
10720
 
            sn_ConsoleOut( tOutput( "$player_voiced", p->GetColoredName() ) );
 
10287
        sn_ConsoleOut( tOutput( "$player_voiced", p->GetColoredName() ) );
10721
10288
        p->SetSilenced( false );
10722
10289
    }
10723
10290
}
10729
10296
 
10730
10297
static void VoiceAll(std::istream &s)
10731
10298
{
 
10299
    if ( se_NeedsServer( "VOICE_ALL", s ) || se_NeedsServer( "UNSILENCE_ALL", s ))
 
10300
    {
 
10301
        return;
 
10302
    }
10732
10303
    if (se_PlayerNetIDs.Len()>0)
10733
10304
    {
10734
10305
        int max = se_PlayerNetIDs.Len();
10740
10311
                p->SetSilenced( false );
10741
10312
            }
10742
10313
        }
10743
 
 
10744
 
        #ifndef DEDICATED
10745
 
        if ( sn_GetNetState() == nCLIENT )
10746
 
            sn_ConsoleOut( tOutput( "$player_voiced_all_local") );
10747
 
        else
10748
 
#endif
10749
10314
        sn_ConsoleOut( tOutput( "$player_voiced_all") );
10750
10315
    }
10751
10316
}
10985
10550
    {
10986
10551
        // apply name filters only on remote players
10987
10552
        if ( Owner() != 0 )
10988
 
            se_OptionalNameFilters( nameFromClient_, Owner() );
 
10553
            se_OptionalNameFilters( nameFromClient_ );
10989
10554
 
10990
10555
        // nothing wrong ? proceed to renaming
10991
10556
        nameFromAdmin_ = nameFromServer_ = nameFromClient_;
11379
10944
 
11380
10945
    // replace empty name
11381
10946
    if ( !IsLegalPlayerName( nameFromClient_ ) )
11382
 
    {
11383
 
        nameFromClient_ = "Player ";
11384
 
        nameFromClient_ << Owner();
11385
 
    }
 
10947
        nameFromClient_ = "Player 1";
11386
10948
 
11387
10949
    if ( sn_GetNetState() != nCLIENT )
11388
10950
        nameFromServer_ = nameFromClient_;