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

« back to all changes in this revision

Viewing changes to src/tron/gZone.cpp

  • Committer: SwagTron
  • Date: 2019-03-05 07:13:03 UTC
  • Revision ID: swagtron-20190305071303-5m4cn9hs6h8ydsgf
- Ported toggle from 0.4. Seems kind of hacky. Had to add another FindConfigItem of type tConfItemBase due to tab completion using the previous tString function. Plan to change this later, but I really needed the toggle function. Tried to cast the two, but that did not work out. Seemed like the bug-less option for the time being. Those unfamiliar with this function, you can now toggle boolean commands (Ex. toggle text_out)

Show diffs side-by-side

added added

removed removed

Lines of Context:
53
53
#include "nConfig.h"
54
54
#include "gSpawn.h"
55
55
#include "gArena.h"
56
 
#include "tRandom.h"
57
 
 
58
 
//HACK RACE
59
 
#include "gRace.h"
60
 
 
 
56
#include "tRandom.h"
 
57
 
 
58
//HACK RACE
 
59
#include "gRace.h"
 
60
 
61
61
#include "gParser.h"
62
62
 
63
63
#include <time.h>
64
 
#include <algorithm>
65
 
 
66
 
static bool sg_SwapWinDeath = false;
 
64
#include <algorithm>
 
65
 
 
66
static bool sg_SwapWinDeath = false;
67
67
static tSettingItem<bool> sg_SwitchWinDeathColorCONF("SWAP_WINZONE_DEATHZONE_COLORS", sg_SwapWinDeath);
68
68
 
69
69
static int sg_zoneAlphaToggle = 0;
70
 
static tConfItem<int> sg_zoneAlphaToggleConf( "ZONE_ALPHA_TOGGLE", sg_zoneAlphaToggle );
 
70
static tSettingItem<int> sg_zoneAlphaToggleConf( "ZONE_ALPHA_TOGGLE", sg_zoneAlphaToggle );
71
71
 
72
72
static int sg_zoneDeath = 1;
73
73
static tSettingItem<int> sg_zoneDeathConf( "WIN_ZONE_DEATHS", sg_zoneDeath );
100
100
static tSettingItem<bool> sg_ballAutoRespawnConf( "BALL_AUTORESPAWN", sg_ballAutoRespawn );
101
101
 
102
102
static int sg_zoneSegments = 11;
103
 
static tConfItem<int> sg_zoneSegmentsConf( "ZONE_SEGMENTS", sg_zoneSegments );
 
103
static tSettingItem<int> sg_zoneSegmentsConf( "ZONE_SEGMENTS", sg_zoneSegments );
104
104
 
105
105
static REAL sg_zoneSegLength = .5;
106
 
static tConfItem<REAL> sg_zoneSegLengthConf( "ZONE_SEG_LENGTH", sg_zoneSegLength );
 
106
static tSettingItem<REAL> sg_zoneSegLengthConf( "ZONE_SEG_LENGTH", sg_zoneSegLength );
107
107
 
108
108
static REAL sg_zoneBottom = 0.0f;
109
 
static tConfItem<REAL> sg_zoneBottomConf( "ZONE_BOTTOM", sg_zoneBottom );
 
109
static tSettingItem<REAL> sg_zoneBottomConf( "ZONE_BOTTOM", sg_zoneBottom );
110
110
 
111
111
static REAL sg_zoneHeight = 5.0f;
112
 
static tConfItem<REAL> sg_zoneHeightConf( "ZONE_HEIGHT", sg_zoneHeight );
 
112
static tSettingItem<REAL> sg_zoneHeightConf( "ZONE_HEIGHT", sg_zoneHeight );
113
113
 
114
114
static eLadderLogWriter sg_flagConquestRoundWinWriter("FLAG_CONQUEST_ROUND_WIN", true);
115
115
static eLadderLogWriter sg_flagTimeoutWriter("FLAG_TIMEOUT", true);
119
119
static eLadderLogWriter sg_flagScoreWriter("FLAG_SCORE", true);
120
120
static eLadderLogWriter sg_flagHeldWriter("FLAG_HELD", true);
121
121
static eLadderLogWriter sg_baseRespawnWriter("BASE_RESPAWN", true);
122
 
static eLadderLogWriter sg_baseEnemyRespawnWriter("BASE_ENEMY_RESPAWN", true);
123
 
 
 
122
static eLadderLogWriter sg_baseEnemyRespawnWriter("BASE_ENEMY_RESPAWN", true);
 
123
 
124
124
static eLadderLogWriter sg_deathZoneActivated("DEATHZONE_ACTIVATED", true);
125
 
static eLadderLogWriter sg_winZoneActivated("WINZONE_ACTIVATED", true);
126
 
 
127
 
bool gWinZoneHack::winnerPlayer_ = false;
 
125
static eLadderLogWriter sg_winZoneActivated("WINZONE_ACTIVATED", true);
 
126
 
 
127
bool gWinZoneHack::winnerPlayer_ = false;
128
128
 
129
129
//! creates a win or death zone (according to configuration) at the specified position
130
130
gZone * sg_CreateWinDeathZone( eGrid * grid, const eCoord & pos )
133
133
    if ( sg_zoneDeath )
134
134
    {
135
135
        ret = tNEW( gDeathZoneHack( grid, pos ) );
136
 
        sn_ConsoleOut( "$instant_death_activated" );
137
 
 
138
 
        sg_deathZoneActivated << ret->GOID() << ret->GetName() << ret->MapPosition().x << ret->MapPosition().y;
 
136
        sn_ConsoleOut( "$instant_death_activated" );
 
137
 
 
138
        sg_deathZoneActivated << ret->GOID() << ret->GetName() << ret->MapPosition().x << ret->MapPosition().y;
139
139
        sg_deathZoneActivated.write();
140
140
    }
141
141
    else
148
148
        else
149
149
        {
150
150
            sn_ConsoleOut( "$instant_round_end_activated" );
151
 
        }
152
 
 
153
 
        sg_winZoneActivated << ret->GOID() << ret->GetName() << ret->MapPosition().x << ret->MapPosition().y;
 
151
        }
 
152
 
 
153
        sg_winZoneActivated << ret->GOID() << ret->GetName() << ret->MapPosition().x << ret->MapPosition().y;
154
154
        sg_winZoneActivated.write();
155
155
    }
156
156
 
215
215
 
216
216
int gZone::FindFirst(tString name)
217
217
{
218
 
    eGrid *grid = eGrid::CurrentGrid();
219
 
    if (!grid) return -1;
 
218
    eGrid *grid = eGrid::CurrentGrid();
 
219
    if (!grid) return -1;
220
220
 
221
221
    const tList<eGameObject>& gameObjects = grid->GameObjects();
222
222
    for (int j=gameObjects.Len()-1;j>=0;j--)
238
238
 
239
239
int gZone::FindNext(tString name, int prev_pos)
240
240
{
241
 
    eGrid *grid = eGrid::CurrentGrid();
242
 
    if (!grid) return -1;
 
241
    eGrid *grid = eGrid::CurrentGrid();
 
242
    if (!grid) return -1;
243
243
 
244
244
    const tList<eGameObject>& gameObjects = grid->GameObjects();
245
245
    for (int j=prev_pos-1;j>=0;j--)
276
276
    // store creation time
277
277
    referenceTime_ = createTime_ = lastTime = 0;
278
278
 
279
 
    destroyed_ = false;
 
279
    destroyed_ = false;
280
280
    zoneInit_ = false;
281
 
    dynamicCreation_ = dynamicCreation;
 
281
    dynamicCreation_ = dynamicCreation;
282
282
    delayCreation_ = delayCreation;
283
283
    wallInteract_ = false;
284
 
    wallBouncesLeft_ = 0;
 
284
    wallBouncesLeft_ = 0;
285
285
    wallPenetrate_ = false;
286
286
    targetRadius_ = 0;
287
287
    lastImpactTime_ = 0;
291
291
    pOwner_ = NULL;
292
292
    pSeekingCycle_ = NULL;
293
293
    seeking_ = false;            //??? change this to a game object, allow seeking any
294
 
    name_ = tString("");
 
294
    name_ = tString("");
295
295
    effect_ = tString("");
296
296
 
297
 
    color_.r = color_.g = color_.b = 1.0f;
298
 
 
 
297
    color_.r = color_.g = color_.b = 1.0f;
 
298
 
299
299
    // set fixed values
300
300
    SetRotationSpeed( .3f );
301
301
    SetRotationAcceleration( 0.0f );
311
311
        createTime_ -= 3.5;
312
312
    }
313
313
 
314
 
    // add to game grid
 
314
    // add to game grid
315
315
    if (!delayCreation)
316
316
        this->AddToList();
317
317
 
336
336
gZone::gZone( nMessage & m )
337
337
:eNetGameObject( m ), rotation_(1,0)
338
338
{
339
 
    destroyed_ = false;
 
339
    destroyed_ = false;
340
340
    zoneInit_ = false;
341
 
    dynamicCreation_ = false;
 
341
    dynamicCreation_ = false;
342
342
    delayCreation_ = false;
343
343
    wallInteract_ = false;
344
 
    wallBouncesLeft_ = 0;
 
344
    wallBouncesLeft_ = 0;
345
345
    wallPenetrate_ = false;
346
346
    lastImpactTime_ = 0;
347
347
    targetRadius_ = 0;
351
351
    pOwner_ = NULL;
352
352
    pSeekingCycle_ = NULL;
353
353
    seeking_ = false;
354
 
    name_ = tString("");
 
354
    name_ = tString("");
355
355
    effect_ = tString("");
356
356
 
357
357
    // read creation time
359
359
    referenceTime_ = lastTime = createTime_;
360
360
 
361
361
    // initialize color to white, ReadSync will fill in the true value if available
362
 
    color_.r = color_.g = color_.b = 1.0f;
363
 
 
 
362
    color_.r = color_.g = color_.b = 1.0f;
 
363
 
364
364
    // set fixed values
365
365
    SetRotationSpeed( .3f );
366
366
    SetRotationAcceleration( 0.0f );
367
367
 
368
 
    // add to game grid
 
368
    // add to game grid
369
369
    if(!delayCreation_)
370
370
        this->AddToList();
371
371
 
520
520
    {
521
521
        Zone->SetWallInteract(true);
522
522
        Zone->SetWallBouncesLeft(-1);
523
 
    }
524
 
    if (zonePenetrate)
525
 
    {
526
 
        Zone->SetWallPenetrate(true);
 
523
    }
 
524
    if (zonePenetrate)
 
525
    {
 
526
        Zone->SetWallPenetrate(true);
527
527
    }
528
528
    if(targetRadius != 0)
529
529
    {
541
541
    gSumoZoneHack *thisSumoZone = dynamic_cast<gSumoZoneHack *>(Zone);
542
542
    if(thisSumoZone){
543
543
        thisSumoZone->SetUnspawnedState();
544
 
    }
545
 
 
546
 
    Zone->SetEffect(zoneEffect);
 
544
    }
 
545
 
 
546
    Zone->SetEffect(zoneEffect);
547
547
 
548
548
    Zone->RequestSync();
549
549
 
718
718
    SetVelocity(V);
719
719
    SetPosition(P);
720
720
    RequestSync();
721
 
}
722
 
 
 
721
}
 
722
 
723
723
// *******************************************************************************
724
724
// *
725
725
// *    Collapse
726
726
// *
727
 
// *******************************************************************************
728
 
 
729
 
void gZone::Collapse()
730
 
{
731
 
    Vanish(-1);
732
 
    destroyed_ = true;
733
 
    SetReferenceTime();
734
 
    SetExpansionSpeed(-GetRadius());
 
727
// *******************************************************************************
 
728
 
 
729
void gZone::Collapse()
 
730
{
 
731
    Vanish(-1);
 
732
    destroyed_ = true;
 
733
    SetReferenceTime();
 
734
    SetExpansionSpeed(-GetRadius());
735
735
    SetRadius(0);
736
 
    RequestSync();
 
736
    RequestSync();
737
737
}
738
738
 
739
739
 
745
745
//!
746
746
//!     @param  time    the current time
747
747
//!
748
 
// *******************************************************************************
749
 
 
750
 
static bool sg_zoneWallDeath = false;
751
 
static tSettingItem<bool> sg_zoneWallDeathConf("ZONE_WALL_DEATH", sg_zoneWallDeath);
752
 
 
753
 
static REAL sg_zoneWallBoundary = -20.0;
754
 
bool restrictZoneBoundry(const REAL &newValue)
755
 
{
756
 
    //  we cannot have the boundry limit be greater than -1
757
 
    if (newValue > 0) return false;
758
 
    return true;
759
 
}
760
 
static tSettingItem<REAL> sg_zoneWallBoundaryConf("ZONE_WALL_BOUNDARY", sg_zoneWallBoundary, &restrictZoneBoundry);
761
 
 
 
748
// *******************************************************************************
 
749
 
 
750
static bool sg_zoneWallDeath = false;
 
751
static tSettingItem<bool> sg_zoneWallDeathConf("ZONE_WALL_DEATH", sg_zoneWallDeath);
 
752
 
 
753
static REAL sg_zoneWallBoundary = -20.0;
 
754
bool restrictZoneBoundry(const REAL &newValue)
 
755
{
 
756
    //  we cannot have the boundry limit be greater than -1
 
757
    if (newValue > 0) return false;
 
758
    return true;
 
759
}
 
760
static tSettingItem<REAL> sg_zoneWallBoundaryConf("ZONE_WALL_BOUNDARY", sg_zoneWallBoundary, &restrictZoneBoundry);
 
761
 
762
762
static eLadderLogWriter sg_OnlineZoneWriter("ONLINE_ZONE", false);
763
763
 
764
764
bool gZone::Timestep( REAL time )
772
772
        //??? game AND sync the last update on time.  Removing from game gets to
773
773
        //??? the client much later than the sync does if not killed and looks bad.
774
774
        return false;
775
 
    }
776
 
 
777
 
    if (!zoneInit_)
778
 
    {
779
 
        sg_OnlineZoneWriter << GOID() << name_ << effect_ << MapPosition().x << MapPosition().y << GetVelocity().x << GetVelocity().y
780
 
                            << GetRadius() << GetExpansionSpeed();
781
 
 
782
 
        zoneInit_ = true;
 
775
    }
 
776
 
 
777
    if (!zoneInit_)
 
778
    {
 
779
        sg_OnlineZoneWriter << GOID() << name_ << effect_ << MapPosition().x << MapPosition().y << GetVelocity().x << GetVelocity().y
 
780
                            << GetRadius() << GetExpansionSpeed();
 
781
 
 
782
        zoneInit_ = true;
783
783
    }
784
784
 
785
785
    bool doRequestSync = false;
868
868
            if (s_zoneWallInteractionFound)
869
869
            {
870
870
                if (wallBouncesLeft_ == 0)
871
 
                {
872
 
                    if ((wallPenetrate_ && !eWallRim::IsBound(GetPosition(), 0)) || (!wallPenetrate_))
 
871
                {
 
872
                    if ((wallPenetrate_ && !eWallRim::IsBound(GetPosition(), 0)) || (!wallPenetrate_))
873
873
                    {
874
874
                        // kill the zone as we hit a wall
875
875
                        //??? make kill code a common function
876
876
                        Collapse();
877
 
                        return false;
 
877
                        return false;
878
878
                    }
879
879
                }
880
880
                else
881
 
                {
882
 
                    if (wallPenetrate_ && !eWallRim::IsBound(GetPosition(), 0))
883
 
                    {
884
 
                        // bounce off wall
885
 
                        BounceOffPoint(GetPosition(), s_zoneWallInteractionImpactCoord);
886
 
                        lastImpactTime_ = time + s_zoneWallInteractionImpactTime;
887
 
 
888
 
                        if (wallBouncesLeft_ > 0)
889
 
                        {
890
 
                            wallBouncesLeft_--;
891
 
                        }
892
 
                    }
893
 
                    else
894
 
                    {
895
 
                        // bounce off wall
896
 
                        BounceOffPoint(GetPosition(), s_zoneWallInteractionImpactCoord);
897
 
                        lastImpactTime_ = time + s_zoneWallInteractionImpactTime;
898
 
 
899
 
                        if (wallBouncesLeft_ > 0)
900
 
                        {
901
 
                            wallBouncesLeft_--;
902
 
                        }
 
881
                {
 
882
                    if (wallPenetrate_ && !eWallRim::IsBound(GetPosition(), 0))
 
883
                    {
 
884
                        // bounce off wall
 
885
                        BounceOffPoint(GetPosition(), s_zoneWallInteractionImpactCoord);
 
886
                        lastImpactTime_ = time + s_zoneWallInteractionImpactTime;
 
887
 
 
888
                        if (wallBouncesLeft_ > 0)
 
889
                        {
 
890
                            wallBouncesLeft_--;
 
891
                        }
 
892
                    }
 
893
                    else
 
894
                    {
 
895
                        // bounce off wall
 
896
                        BounceOffPoint(GetPosition(), s_zoneWallInteractionImpactCoord);
 
897
                        lastImpactTime_ = time + s_zoneWallInteractionImpactTime;
 
898
 
 
899
                        if (wallBouncesLeft_ > 0)
 
900
                        {
 
901
                            wallBouncesLeft_--;
 
902
                        }
903
903
                    }
904
904
 
905
905
                    return false;
906
 
                }
 
906
                }
907
907
            }
908
908
 
909
909
            // only clip if zone is moving
927
927
                        //Don't allow going outside, kill it
928
928
                        Collapse();
929
929
                        return false;
930
 
                    }
931
 
 
932
 
                    gSoccerZoneHack *thisSockerBall = dynamic_cast<gSoccerZoneHack *>(this);
933
 
                    if (thisSockerBall && (thisSockerBall->GetType() == gSoccerZoneHack::gSoccer_BALL))
934
 
                    {
935
 
                        thisSockerBall->GoHome();
936
 
                    }
937
 
                    else
938
 
                    {
939
 
                        Collapse();
940
 
                        return false;
 
930
                    }
 
931
 
 
932
                    gSoccerZoneHack *thisSockerBall = dynamic_cast<gSoccerZoneHack *>(this);
 
933
                    if (thisSockerBall && (thisSockerBall->GetType() == gSoccerZoneHack::gSoccer_BALL))
 
934
                    {
 
935
                        thisSockerBall->GoHome();
 
936
                    }
 
937
                    else
 
938
                    {
 
939
                        Collapse();
 
940
                        return false;
941
941
                    }
942
942
                }
943
943
            }
944
 
        }
945
 
        else
946
 
        {
947
 
            if (sg_zoneWallDeath && !eWallRim::IsBound(GetPosition(), sg_zoneWallBoundary))
948
 
            {
949
 
                Collapse();
950
 
                return false;
951
 
            }
 
944
        }
 
945
        else
 
946
        {
 
947
            if (sg_zoneWallDeath && !eWallRim::IsBound(GetPosition(), sg_zoneWallBoundary))
 
948
            {
 
949
                Collapse();
 
950
                return false;
 
951
            }
952
952
        }
953
953
 
954
954
        if(!route_.empty() && time >= nextUpdate_)
991
991
            SetExpansionSpeed( -fallSpeed_ );
992
992
            targetRadius_ = 0;
993
993
            doRequestSync = true;
994
 
        }
995
 
 
996
 
        if (seeking_)
997
 
        {
 
994
        }
 
995
 
 
996
        if (seeking_)
 
997
        {
998
998
            if ((!pSeekingCycle_) || (!pSeekingCycle_->Player()) || (!pSeekingCycle_->Alive()))
999
999
            {
1000
1000
                //Seeking cycle is gone, shrink
1002
1002
                SetReferenceTime();
1003
1003
                SetExpansionSpeed( -GetRadius()*1 );
1004
1004
                targetRadius_ = 0;
1005
 
                seeking_ = false;
1006
 
 
 
1005
                seeking_ = false;
 
1006
 
1007
1007
                doRequestSync = true;
1008
 
            }
 
1008
            }
1009
1009
        }
1010
1010
 
1011
1011
        if (doRequestSync)
1029
1029
 
1030
1030
void gZone::OnVanish( void )
1031
1031
{
1032
 
}
1033
 
 
 
1032
}
 
1033
 
1034
1034
// *******************************************************************************
1035
1035
// *
1036
1036
// *    TriggerAvoidZone
1041
1041
//!     @param  zone          the zone player is getting near
1042
1042
//!     @param  time          the current time
1043
1043
//!
1044
 
// *******************************************************************************
1045
 
 
1046
 
bool sg_cyclesZonesAvoid = false;
1047
 
static tSettingItem<bool> sg_cyclesZonesAvoidConf("CYCLE_ZONES_AVOID", sg_cyclesZonesAvoid);
1048
 
 
1049
 
REAL sg_cycleZonesApproch = 100.0;
1050
 
static tSettingItem<REAL>sg_cycleZoneApprochConf("CYCLE_ZONES_APPROCH", sg_cycleZonesApproch);
1051
 
 
1052
 
static void TriggerAvoidZone(gCycle *target, gZone *Zone, REAL currentTime)
1053
 
{
1054
 
    //  don't execute if players won't want to avoid zones
1055
 
    if (!sg_cyclesZonesAvoid)
1056
 
        return;
1057
 
 
1058
 
    eGrid *grid = eGrid::CurrentGrid();
1059
 
    if (!grid) return;
1060
 
 
1061
 
    ePlayerNetID *player = target->Player();
1062
 
    if ((player->IsChatting()) && (player->IsActive()) || (!player->IsHuman()))
1063
 
    {
1064
 
        REAL tarX = target->Position().x;
1065
 
        REAL tarY = target->Position().y;
1066
 
        REAL zonX = Zone->Position().x;
1067
 
        REAL zonY = Zone->Position().y;
1068
 
 
1069
 
        REAL tarDirX = target->Direction().x;
1070
 
        REAL tarDirY = target->Direction().y;
1071
 
 
1072
 
        if ((tarX == zonX) || (tarY == zonY))
1073
 
        {
1074
 
            target->Act(&gCycle::se_turnRight, 1);
1075
 
        }
1076
 
 
1077
 
        if (tarDirX >= 0)
1078
 
        {
1079
 
            if (tarX < zonX)
1080
 
            {
1081
 
                if (tarY < zonY)
1082
 
                    target->Act(&gCycle::se_turnRight, 1);
1083
 
                else
1084
 
                    target->Act(&gCycle::se_turnLeft, 1);
1085
 
            }
1086
 
        }
1087
 
        else if (tarDirX <= -0.01)
1088
 
        {
1089
 
            if (tarX > zonX)
1090
 
            {
1091
 
                if (tarY < zonY)
1092
 
                    target->Act(&gCycle::se_turnLeft, 1);
1093
 
                else
1094
 
                    target->Act(&gCycle::se_turnRight, 1);
1095
 
            }
1096
 
        }
1097
 
        if (tarDirY >= 0)
1098
 
        {
1099
 
            if (tarY < zonY)
1100
 
            {
1101
 
                if (tarX < zonX)
1102
 
                    target->Act(&gCycle::se_turnLeft, 1);
1103
 
                else
1104
 
                    target->Act(&gCycle::se_turnRight, 1);
1105
 
            }
1106
 
        }
1107
 
        else if (tarDirY <= -0.01)
1108
 
        {
1109
 
            if (tarY > zonY)
1110
 
            {
1111
 
                if (tarX < zonX)
1112
 
                    target->Act(&gCycle::se_turnRight, 1);
1113
 
                else
1114
 
                    target->Act(&gCycle::se_turnLeft, 1);
1115
 
            }
1116
 
        }
1117
 
    }
1118
 
 
1119
 
    //  if all fails, cycle will enter the zone
 
1044
// *******************************************************************************
 
1045
 
 
1046
bool sg_cyclesZonesAvoid = false;
 
1047
static tSettingItem<bool> sg_cyclesZonesAvoidConf("CYCLE_ZONES_AVOID", sg_cyclesZonesAvoid);
 
1048
 
 
1049
REAL sg_cycleZonesApproch = 100.0;
 
1050
static tSettingItem<REAL>sg_cycleZoneApprochConf("CYCLE_ZONES_APPROCH", sg_cycleZonesApproch);
 
1051
 
 
1052
static void TriggerAvoidZone(gCycle *target, gZone *Zone, REAL currentTime)
 
1053
{
 
1054
    //  don't execute if players won't want to avoid zones
 
1055
    if (!sg_cyclesZonesAvoid)
 
1056
        return;
 
1057
 
 
1058
    eGrid *grid = eGrid::CurrentGrid();
 
1059
    if (!grid) return;
 
1060
 
 
1061
    ePlayerNetID *player = target->Player();
 
1062
    if ((player->IsChatting()) && (player->IsActive()) || (!player->IsHuman()))
 
1063
    {
 
1064
        REAL tarX = target->Position().x;
 
1065
        REAL tarY = target->Position().y;
 
1066
        REAL zonX = Zone->Position().x;
 
1067
        REAL zonY = Zone->Position().y;
 
1068
 
 
1069
        REAL tarDirX = target->Direction().x;
 
1070
        REAL tarDirY = target->Direction().y;
 
1071
 
 
1072
        if ((tarX == zonX) || (tarY == zonY))
 
1073
        {
 
1074
            target->Act(&gCycle::se_turnRight, 1);
 
1075
        }
 
1076
 
 
1077
        if (tarDirX >= 0)
 
1078
        {
 
1079
            if (tarX < zonX)
 
1080
            {
 
1081
                if (tarY < zonY)
 
1082
                    target->Act(&gCycle::se_turnRight, 1);
 
1083
                else
 
1084
                    target->Act(&gCycle::se_turnLeft, 1);
 
1085
            }
 
1086
        }
 
1087
        else if (tarDirX <= -0.01)
 
1088
        {
 
1089
            if (tarX > zonX)
 
1090
            {
 
1091
                if (tarY < zonY)
 
1092
                    target->Act(&gCycle::se_turnLeft, 1);
 
1093
                else
 
1094
                    target->Act(&gCycle::se_turnRight, 1);
 
1095
            }
 
1096
        }
 
1097
        if (tarDirY >= 0)
 
1098
        {
 
1099
            if (tarY < zonY)
 
1100
            {
 
1101
                if (tarX < zonX)
 
1102
                    target->Act(&gCycle::se_turnLeft, 1);
 
1103
                else
 
1104
                    target->Act(&gCycle::se_turnRight, 1);
 
1105
            }
 
1106
        }
 
1107
        else if (tarDirY <= -0.01)
 
1108
        {
 
1109
            if (tarY > zonY)
 
1110
            {
 
1111
                if (tarX < zonX)
 
1112
                    target->Act(&gCycle::se_turnRight, 1);
 
1113
                else
 
1114
                    target->Act(&gCycle::se_turnLeft, 1);
 
1115
            }
 
1116
        }
 
1117
    }
 
1118
 
 
1119
    //  if all fails, cycle will enter the zone
1120
1120
}
1121
1121
 
1122
1122
 
1137
1137
    gCycle* prey = dynamic_cast< gCycle* >( target );
1138
1138
    if ( prey )
1139
1139
    {
1140
 
        REAL r = this->Radius();
1141
 
        if (((prey->Position() - this->Position()).NormSquared() > r*r) && ((prey->Position() - this->Position()).NormSquared() < ((r*r) + (sg_cycleZonesApproch * 2))))
1142
 
        {
1143
 
            TriggerAvoidZone(prey, this, time);
1144
 
            OnNear(prey, time);
 
1140
        REAL r = this->Radius();
 
1141
        if (((prey->Position() - this->Position()).NormSquared() > r*r) && ((prey->Position() - this->Position()).NormSquared() < ((r*r) + (sg_cycleZonesApproch * 2))))
 
1142
        {
 
1143
            TriggerAvoidZone(prey, this, time);
 
1144
            OnNear(prey, time);
1145
1145
        }
1146
1146
        else if ( ( prey->Position() - this->Position() ).NormSquared() < r*r )
1147
1147
        {
1148
1148
            if ( prey->Player() && prey->Alive() )
1149
1149
            {
1150
 
                OnEnter( prey, time );
1151
 
                if (!isInside(prey)) // make sure this cycle isn't in zone already
1152
 
                {
1153
 
                    //  if not, then add them to the list
1154
 
                    AddPlayerInteraction(prey);
 
1150
                OnEnter( prey, time );
 
1151
                if (!isInside(prey)) // make sure this cycle isn't in zone already
 
1152
                {
 
1153
                    //  if not, then add them to the list
 
1154
                    AddPlayerInteraction(prey);
1155
1155
                }
1156
1156
            }
1157
 
        }
1158
 
        else
1159
 
        {
1160
 
            if (isInside(prey)) // make sure this cycle already is within the zone
1161
 
            {
1162
 
                OnExit(prey, time); // call the OnExit event
1163
 
                RemovePlayerInteraction(prey);  // remove them from the list
1164
 
            }
 
1157
        }
 
1158
        else
 
1159
        {
 
1160
            if (isInside(prey)) // make sure this cycle already is within the zone
 
1161
            {
 
1162
                OnExit(prey, time); // call the OnExit event
 
1163
                RemovePlayerInteraction(prey);  // remove them from the list
 
1164
            }
1165
1165
        }
1166
1166
    }
1167
1167
    else
1298
1298
                    }
1299
1299
                }
1300
1300
            }
1301
 
        }
1302
 
 
 
1301
        }
 
1302
 
1303
1303
        gSoccerZoneHack *gSoccerZone = dynamic_cast<gSoccerZoneHack *>(this);
1304
1304
        if (gSoccerZone)
1305
1305
        {
1308
1308
            {
1309
1309
                REAL dis = this->Radius() + gNormalZone->Radius();
1310
1310
                if ( ( gNormalZone->Position() - this->Position() ).NormSquared() < (dis * dis) )
1311
 
                {
1312
 
                    gSoccerZone->OnEnter(gNormalZone, time);
1313
 
                }
1314
 
            }
1315
 
        }
1316
 
 
 
1311
                {
 
1312
                    gSoccerZone->OnEnter(gNormalZone, time);
 
1313
                }
 
1314
            }
 
1315
        }
 
1316
 
1317
1317
        gObjectZoneHack *gObjectZone = dynamic_cast<gObjectZoneHack *>(this);
1318
1318
        if (gObjectZone)
1319
1319
        {
1322
1322
            {
1323
1323
                REAL dis = this->Radius() + gNormalZone->Radius();
1324
1324
                if ( ( gNormalZone->Position() - this->Position() ).NormSquared() < (dis * dis) )
1325
 
                {
1326
 
                    gObjectZone->OnEnter(gNormalZone, time);
1327
 
                }
1328
 
            }
 
1325
                {
 
1326
                    gObjectZone->OnEnter(gNormalZone, time);
 
1327
                }
 
1328
            }
1329
1329
        }
1330
1330
    }
1331
1331
}
1360
1360
 
1361
1361
void gZone::OnEnter( gZone * target, REAL time )
1362
1362
{
1363
 
}
1364
 
 
 
1363
}
 
1364
 
1365
1365
// *******************************************************************************
1366
1366
// *
1367
1367
// *    OnExit
1375
1375
 
1376
1376
void gZone::OnExit( gCycle *target, REAL time )
1377
1377
{
1378
 
}
1379
 
 
 
1378
}
 
1379
 
1380
1380
// *******************************************************************************
1381
1381
// *
1382
1382
// *    OnExit
1391
1391
void gZone::OnExit( gZone *target, REAL time )
1392
1392
{
1393
1393
}
1394
 
 
 
1394
 
1395
1395
// *******************************************************************************
1396
1396
// *
1397
1397
// *    OnNear
1405
1405
 
1406
1406
void gZone::OnNear( gCycle *target, REAL time )
1407
1407
{
1408
 
}
1409
 
 
 
1408
}
 
1409
 
1410
1410
// *******************************************************************************
1411
1411
// *
1412
1412
// *    OnNear
1476
1476
 
1477
1477
// extra alpha blending factors
1478
1478
static REAL sg_zoneAlpha = 1.0, sg_zoneAlphaServer = 1.0;
1479
 
static tConfItem< REAL > sg_zoneAlphaConf( "ZONE_ALPHA", sg_zoneAlpha );
 
1479
static tSettingItem< REAL > sg_zoneAlphaConf( "ZONE_ALPHA", sg_zoneAlpha );
1480
1480
static nSettingItem< REAL > sg_zoneAlphaConfServer( "ZONE_ALPHA_SERVER", sg_zoneAlphaServer );
1481
1481
 
1482
1482
// *******************************************************************************
1489
1489
//!
1490
1490
// *******************************************************************************
1491
1491
 
1492
 
 
1493
 
//Do we want zones to fade in when the game starts?
1494
 
static bool sg_zoneFadeIn = true;
1495
 
static tConfItem<bool> sg_zoneFadeInConf( "ZONE_FADE_IN", sg_zoneFadeIn);
1496
 
 
1497
 
REAL alpha;
1498
1492
void gZone::Render( const eCamera * cam )
1499
1493
{
1500
1494
    #ifndef DEDICATED
1503
1497
    if ( sg_zoneSegments < 1 )
1504
1498
        sg_zoneSegments = 11;
1505
1499
 
1506
 
    if (sg_zoneFadeIn)
1507
 
    {
1508
 
        alpha = (lastTime - createTime_) * .2f;
1509
 
        if (alpha > .7f)
1510
 
            alpha = .7f;
1511
 
        if (alpha <= 0)
1512
 
            return;
1513
 
        alpha *= sg_zoneAlpha * sg_zoneAlphaServer;
1514
 
    }
1515
 
    else
1516
 
    {
1517
 
        alpha = sg_zoneAlpha * sg_zoneAlphaServer;
1518
 
    }
 
1500
    REAL alpha = ( lastTime - createTime_ ) * .2f;
 
1501
    if ( alpha > .7f )
 
1502
    alpha = .7f;
 
1503
    if ( alpha <= 0 )
 
1504
        return;
 
1505
    alpha *= sg_zoneAlpha * sg_zoneAlphaServer;
1519
1506
 
1520
1507
        ModelMatrix();
1521
1508
    glPushMatrix();
1644
1631
bool gZone::RendersAlpha() const
1645
1632
{
1646
1633
    return sr_alphaBlend ? !sg_zoneAlphaToggle : sg_zoneAlphaToggle;
1647
 
}
1648
 
 
1649
 
// *******************************************************************************
1650
 
// *
1651
 
// *    Vanish
1652
 
// *
1653
 
// *******************************************************************************
1654
 
//!
1655
 
//!             @param  factor vanishing speed factor
1656
 
//!
1657
 
// *******************************************************************************
1658
 
 
1659
 
void gZone::Vanish( REAL factor )
1660
 
{
1661
 
    if ( GetExpansionSpeed() >= 0 )
1662
 
    {
1663
 
        SetReferenceTime();
1664
 
        SetExpansionSpeed( -GetRadius() * factor );
1665
 
        SetTargetRadius(0);
1666
 
        RequestSync();
1667
 
    }
1668
 
}
1669
 
 
1670
 
// *******************************************************************************
1671
 
// *
1672
 
// *    Win Zone Color Commands
 
1634
}
 
1635
 
 
1636
// *******************************************************************************
 
1637
// *
 
1638
// *    Vanish
 
1639
// *
 
1640
// *******************************************************************************
 
1641
//!
 
1642
//!             @param  factor vanishing speed factor
 
1643
//!
 
1644
// *******************************************************************************
 
1645
 
 
1646
void gZone::Vanish( REAL factor )
 
1647
{
 
1648
    if ( GetExpansionSpeed() >= 0 )
 
1649
    {
 
1650
        SetReferenceTime();
 
1651
        SetExpansionSpeed( -GetRadius() * factor );
 
1652
        SetTargetRadius(0);
 
1653
        RequestSync();
 
1654
    }
 
1655
}
 
1656
 
 
1657
// *******************************************************************************
 
1658
// *
 
1659
// *    Win Zone Color Commands
1673
1660
// *    Death Zone Color Commands
1674
1661
// *
1675
1662
// *******************************************************************************
1676
1663
//!
1677
1664
//!     @return True if alpha blending is used
1678
1665
//!
1679
 
// *******************************************************************************
1680
 
static int sg_ColorWinZoneRed = 0;
1681
 
static tSettingItem<int> sg_ColorWinZoneRedCONF("COLOR_WINZONE_RED", sg_ColorWinZoneRed);
1682
 
 
1683
 
static int sg_ColorWinZoneBlue = 0;
1684
 
static tSettingItem<int> sg_ColorWinZoneBlueCONF("COLOR_WINZONE_BLUE", sg_ColorWinZoneBlue);
1685
 
 
1686
 
static int sg_ColorWinZoneGreen = 15;
1687
 
static tSettingItem<int> sg_ColorWinZoneGreenCONF("COLOR_WINZONE_GREEN", sg_ColorWinZoneGreen);
1688
 
 
1689
 
static int sg_ColorDeathZoneRed = 15;
1690
 
static tSettingItem<int> sg_ColorDeathZoneRedCONF("COLOR_DEATHZONE_RED", sg_ColorDeathZoneRed);
1691
 
 
1692
 
static int sg_ColorDeathZoneBlue = 0;
1693
 
static tSettingItem<int> sg_ColorDeathZoneBlueCONF("COLOR_DEATHZONE_BLUE", sg_ColorDeathZoneBlue);
1694
 
 
1695
 
static int sg_ColorDeathZoneGreen = 0;
 
1666
// *******************************************************************************
 
1667
static int sg_ColorWinZoneRed = 0;
 
1668
static tSettingItem<int> sg_ColorWinZoneRedCONF("COLOR_WINZONE_RED", sg_ColorWinZoneRed);
 
1669
 
 
1670
static int sg_ColorWinZoneBlue = 0;
 
1671
static tSettingItem<int> sg_ColorWinZoneBlueCONF("COLOR_WINZONE_BLUE", sg_ColorWinZoneBlue);
 
1672
 
 
1673
static int sg_ColorWinZoneGreen = 15;
 
1674
static tSettingItem<int> sg_ColorWinZoneGreenCONF("COLOR_WINZONE_GREEN", sg_ColorWinZoneGreen);
 
1675
 
 
1676
static int sg_ColorDeathZoneRed = 15;
 
1677
static tSettingItem<int> sg_ColorDeathZoneRedCONF("COLOR_DEATHZONE_RED", sg_ColorDeathZoneRed);
 
1678
 
 
1679
static int sg_ColorDeathZoneBlue = 0;
 
1680
static tSettingItem<int> sg_ColorDeathZoneBlueCONF("COLOR_DEATHZONE_BLUE", sg_ColorDeathZoneBlue);
 
1681
 
 
1682
static int sg_ColorDeathZoneGreen = 0;
1696
1683
static tSettingItem<int> sg_ColorDeathZoneGreenCONF("COLOR_DEATHZONE_GREEN", sg_ColorDeathZoneGreen);
1697
1684
 
1698
1685
// *******************************************************************************
1705
1692
//!     @param  pos  Position to spawn the zone at
1706
1693
//!
1707
1694
// *******************************************************************************
1708
 
 
1709
 
 
 
1695
 
 
1696
 
1710
1697
gWinZoneHack::gWinZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, bool delayCreation)
1711
1698
:gZone( grid, pos, dynamicCreation, delayCreation)
1712
 
{
1713
 
    if (sg_SwapWinDeath == false)
 
1699
{
 
1700
    if (sg_SwapWinDeath == false)
1714
1701
    {
1715
1702
        color_.r = sg_ColorWinZoneRed / 15.0f;//0.0f;
1716
1703
        color_.b = sg_ColorWinZoneBlue / 15.0f;//1.0f;
1717
 
        color_.g = sg_ColorWinZoneGreen / 15.0f;//0.0f;
1718
 
    }
1719
 
    else
1720
 
    {
 
1704
        color_.g = sg_ColorWinZoneGreen / 15.0f;//0.0f;
 
1705
    }
 
1706
    else
 
1707
    {
1721
1708
        color_.r = sg_ColorDeathZoneRed / 15.0f;//1.0f;
1722
1709
        color_.b = sg_ColorDeathZoneBlue / 15.0f;//0.0f;
1723
 
        color_.g = sg_ColorDeathZoneGreen / 15.0f;//0.0f;
 
1710
        color_.g = sg_ColorDeathZoneGreen / 15.0f;//0.0f;
1724
1711
    }
1725
1712
}
1726
1713
 
1767
1754
//!
1768
1755
// *******************************************************************************
1769
1756
 
1770
 
static eLadderLogWriter sg_winzonePlayerEnterWriter("WINZONE_PLAYER_ENTER", true);
1771
 
 
1772
 
bool sg_winZonePlayerEnteredWin = true;
 
1757
static eLadderLogWriter sg_winzonePlayerEnterWriter("WINZONE_PLAYER_ENTER", true);
 
1758
 
 
1759
bool sg_winZonePlayerEnteredWin = true;
1773
1760
static tSettingItem<bool> sg_winZonePlayerEnteredWinConf("WINZONE_PLAYER_ENTER_WIN", sg_winZonePlayerEnteredWin);
1774
1761
 
1775
1762
void gWinZoneHack::OnEnter( gCycle * target, REAL time )
1776
 
{
 
1763
{
1777
1764
    sg_winzonePlayerEnterWriter << this->GOID() << name_ << MapPosition().x << MapPosition().y << target->Player()->GetUserName() << target->MapPosition().x << target->MapPosition().y << target->MapDirection().x << target->MapDirection().y << time;
1778
 
    sg_winzonePlayerEnterWriter.write();
1779
 
 
1780
 
    //HACK RACE begin
1781
 
    if ( sg_RaceTimerEnabled )
1782
 
    {
1783
 
        gRace::ZoneHit( target->Player(), time );
1784
 
    }
1785
 
    else
1786
 
    {
1787
 
        if (sg_winZonePlayerEnteredWin)
1788
 
        {
1789
 
            if (!winnerPlayer_)
1790
 
            {
1791
 
                LogWinnerCycleTurns(target);
1792
 
                winnerPlayer_ = true;
1793
 
            }
1794
 
 
1795
 
            static const char* message="$player_win_instant";
1796
 
            sg_DeclareWinner( target->Player()->CurrentTeam(), message );
1797
 
            destroyed_ = true;
1798
 
            Vanish( 0.5 );
1799
 
        }
1800
 
    }
 
1765
    sg_winzonePlayerEnterWriter.write();
 
1766
 
 
1767
    //HACK RACE begin
 
1768
    if ( sg_RaceTimerEnabled )
 
1769
    {
 
1770
        gRace::ZoneHit( target->Player(), time );
 
1771
    }
 
1772
    else
 
1773
    {
 
1774
        if (sg_winZonePlayerEnteredWin)
 
1775
        {
 
1776
            if (!winnerPlayer_)
 
1777
            {
 
1778
                LogWinnerCycleTurns(target);
 
1779
                winnerPlayer_ = true;
 
1780
            }
 
1781
 
 
1782
            static const char* message="$player_win_instant";
 
1783
            sg_DeclareWinner( target->Player()->CurrentTeam(), message );
 
1784
            destroyed_ = true;
 
1785
            Vanish( 0.5 );
 
1786
        }
 
1787
    }
1801
1788
    //HACK RACE end
1802
1789
}
1803
 
 
1804
 
void gWinZoneHack::OnExit( gCycle *target, REAL time )
1805
 
{
1806
 
    if (sg_RaceTimerEnabled)
1807
 
    {
1808
 
        gRace::ZoneOut( target->Player(), time );
1809
 
    }
1810
 
}
 
1790
 
 
1791
void gWinZoneHack::OnExit( gCycle *target, REAL time )
 
1792
{
 
1793
    if (sg_RaceTimerEnabled)
 
1794
    {
 
1795
        gRace::ZoneOut( target->Player(), time );
 
1796
    }
 
1797
}
1811
1798
 
1812
1799
 
1813
1800
// *******************************************************************************
1819
1806
//!     @param  grid Grid to put the zone into
1820
1807
//!     @param  pos  Position to spawn the zone at
1821
1808
//!
1822
 
// *******************************************************************************
1823
 
 
1824
 
bool sg_deathZoneRandomColors = false;
1825
 
static tSettingItem<bool> sg_deathZoneRandomColorsConf("DEATHZONE_RANDOM_COLORS", sg_deathZoneRandomColors);
1826
 
 
1827
 
bool sg_deathZoneRotation = false;
1828
 
static tSettingItem<bool> sg_deathZoneRotationConf("DEATHZONE_ROTATION", sg_deathZoneRotation);
1829
 
 
1830
 
REAL sg_deathZoneRotationSpeed = 0.3f;
1831
 
static tSettingItem<REAL> sg_deathZoneRotationSpeedConf("DEATHZONE_ROTATION_SPEED", sg_deathZoneRotationSpeed);
 
1809
// *******************************************************************************
 
1810
 
 
1811
bool sg_deathZoneRandomColors = false;
 
1812
static tSettingItem<bool> sg_deathZoneRandomColorsConf("DEATHZONE_RANDOM_COLORS", sg_deathZoneRandomColors);
 
1813
 
 
1814
bool sg_deathZoneRotation = false;
 
1815
static tSettingItem<bool> sg_deathZoneRotationConf("DEATHZONE_ROTATION", sg_deathZoneRotation);
 
1816
 
 
1817
REAL sg_deathZoneRotationSpeed = 0.3f;
 
1818
static tSettingItem<REAL> sg_deathZoneRotationSpeedConf("DEATHZONE_ROTATION_SPEED", sg_deathZoneRotationSpeed);
1832
1819
 
1833
1820
gDeathZoneHack::gDeathZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, eTeam * teamowner, bool delayCreation )
1834
1821
:gZone( grid, pos, dynamicCreation, delayCreation )
1835
1822
{
1836
1823
    pLastShotCollision = NULL;
1837
 
 
1838
 
    if (!sg_deathZoneRandomColors)
1839
 
    {
1840
 
        if (sg_SwapWinDeath == false)
 
1824
 
 
1825
    if (!sg_deathZoneRandomColors)
 
1826
    {
 
1827
        if (sg_SwapWinDeath == false)
1841
1828
        {
1842
1829
            color_.r = sg_ColorDeathZoneRed / 15.0f;//1.0f;
1843
1830
            color_.b = sg_ColorDeathZoneBlue / 15.0f;//0.0f;
1844
 
            color_.g = sg_ColorDeathZoneGreen / 15.0f;//0.0f;
1845
 
        }
1846
 
        else
1847
 
        {
 
1831
            color_.g = sg_ColorDeathZoneGreen / 15.0f;//0.0f;
 
1832
        }
 
1833
        else
 
1834
        {
1848
1835
            color_.r = sg_ColorWinZoneRed / 15.0f;//0.0f;
1849
1836
            color_.b = sg_ColorWinZoneBlue / 15.0f;//1.0f;
1850
 
            color_.g = sg_ColorWinZoneGreen / 15.0f;//0.0f;
1851
 
        }
1852
 
    }
1853
 
    else
1854
 
    {
1855
 
        tRandomizer &randomizer = tRandomizer::GetInstance();
1856
 
        REAL colorR = randomizer.Get(16) / 15.0f;
1857
 
        REAL colorG = randomizer.Get(16) / 15.0f;
1858
 
        REAL colorB = randomizer.Get(16) / 15.0f;
1859
 
 
1860
 
        color_.r = colorR;
1861
 
        color_.b = colorG;
1862
 
        color_.g = colorB;
1863
 
    }
1864
 
 
1865
 
    if (sg_deathZoneRotation)
 
1837
            color_.g = sg_ColorWinZoneGreen / 15.0f;//0.0f;
 
1838
        }
 
1839
    }
 
1840
    else
 
1841
    {
 
1842
        tRandomizer &randomizer = tRandomizer::GetInstance();
 
1843
        REAL colorR = randomizer.Get(16) / 15.0f;
 
1844
        REAL colorG = randomizer.Get(16) / 15.0f;
 
1845
        REAL colorB = randomizer.Get(16) / 15.0f;
 
1846
 
 
1847
        color_.r = colorR;
 
1848
        color_.b = colorG;
 
1849
        color_.g = colorB;
 
1850
    }
 
1851
 
 
1852
    if (sg_deathZoneRotation)
1866
1853
        SetRotationSpeed(sg_deathZoneRotationSpeed);
1867
1854
 
1868
 
    if (teamowner!=NULL)
1869
 
    {
1870
 
        team = teamowner;
1871
 
        deathZoneType = TYPE_TEAM;
1872
 
    }
1873
 
    else
1874
 
    {
1875
 
        deathZoneType = TYPE_NORMAL;
1876
 
    }
1877
 
 
 
1855
    if (teamowner!=NULL)
 
1856
    {
 
1857
        team = teamowner;
 
1858
        deathZoneType = TYPE_TEAM;
 
1859
    }
 
1860
    else
 
1861
    {
 
1862
        deathZoneType = TYPE_NORMAL;
 
1863
    }
 
1864
 
1878
1865
    if (!delayCreation)
1879
1866
        grid->AddGameObjectInteresting(this);
1880
1867
}
1889
1876
//!     @param  m Message to read creation data from
1890
1877
//!     @param  null
1891
1878
//!
1892
 
// *******************************************************************************
1893
 
 
 
1879
// *******************************************************************************
 
1880
 
1894
1881
 
1895
1882
 
1896
1883
gDeathZoneHack::gDeathZoneHack( nMessage & m )
1897
1884
: gZone( m )
1898
1885
{
1899
1886
    deathZoneType = TYPE_NORMAL;
1900
 
    pLastShotCollision = NULL;
1901
 
 
1902
 
    if (sg_deathZoneRotation)
 
1887
    pLastShotCollision = NULL;
 
1888
 
 
1889
    if (sg_deathZoneRotation)
1903
1890
        SetRotationSpeed(sg_deathZoneRotationSpeed);
1904
1891
}
1905
1892
 
1920
1907
        pLastShotCollision->pLastShotCollision = NULL;
1921
1908
        pLastShotCollision = NULL;
1922
1909
    }
1923
 
}
1924
 
 
1925
 
bool gDeathZoneHack::Timestep(REAL time)
1926
 
{
 
1910
}
 
1911
 
 
1912
bool gDeathZoneHack::Timestep(REAL time)
 
1913
{
1927
1914
    // delegate
1928
 
    bool returnStatus = gZone::Timestep( time );
1929
 
 
 
1915
    bool returnStatus = gZone::Timestep( time );
 
1916
 
1930
1917
    if (seeking_)
1931
1918
    {
1932
1919
        //Only run this every poll time to save on network traffic
1944
1931
 
1945
1932
            RequestSync();
1946
1933
        }
1947
 
    }
1948
 
 
1949
 
    return returnStatus;
 
1934
    }
 
1935
 
 
1936
    return returnStatus;
1950
1937
}
1951
1938
 
1952
1939
 
1953
1940
static int score_deathzone=-1;
1954
 
static tSettingItem<int> s_dz("SCORE_DEATHZONE",score_deathzone);
1955
 
static int score_deathzone_team=-1;
 
1941
static tSettingItem<int> s_dz("SCORE_DEATHZONE",score_deathzone);
 
1942
static int score_deathzone_team=-1;
1956
1943
static tSettingItem<int> s_dz_team("SCORE_DEATHZONE_TEAM",score_deathzone_team);
1957
1944
 
1958
1945
void gDeathZoneHack::OnVanish( void )
1984
1971
static tSettingItem<int> s_score_zombie_zone("SCORE_ZOMBIE_ZONE",score_zombie_zone);
1985
1972
 
1986
1973
static bool sg_shotKillSelf = false;
1987
 
static tSettingItem<bool> conf_shotKillSelf ("SHOT_KILL_SELF", sg_shotKillSelf);
1988
 
 
 
1974
static tSettingItem<bool> conf_shotKillSelf ("SHOT_KILL_SELF", sg_shotKillSelf);
 
1975
 
1989
1976
static bool sg_shotKillEnemies = true;
1990
1977
static tSettingItem<bool> conf_shotKillEnemies ("SHOT_KILL_ENEMIES", sg_shotKillEnemies);
1991
1978
 
2106
2093
static eLadderLogWriter sg_deathShotFragWriter("DEATH_SHOT_FRAG", true);
2107
2094
static eLadderLogWriter sg_deathShotSuicideWriter("DEATH_SHOT_SUICIDE", true);
2108
2095
static eLadderLogWriter sg_deathShotTeamkillWriter("DEATH_SHOT_TEAMKILL", true);
2109
 
static eLadderLogWriter sg_deathDeathZoneWriter("DEATH_DEATHZONE", true);
2110
 
static eLadderLogWriter sg_deathDeathZoneTeamWriter("DEATH_DEATHZONE_TEAM", false);
 
2096
static eLadderLogWriter sg_deathDeathZoneWriter("DEATH_DEATHZONE", true);
 
2097
static eLadderLogWriter sg_deathDeathZoneTeamWriter("DEATH_DEATHZONE_TEAM", false);
2111
2098
static eLadderLogWriter sg_deathZombieZoneWriter("DEATH_ZOMBIEZONE", true);
2112
2099
static eLadderLogWriter sg_deathDeathShotWriter("DEATH_DEATHSHOT", true);
2113
2100
static eLadderLogWriter sg_deathDeathSelfDestructWriter("DEATH_SELF_DESTRUCT", true);
2120
2107
        target->Kill();
2121
2108
        sg_deathDeathZoneWriter << target->Player()->GetUserName();
2122
2109
        sg_deathDeathZoneWriter.write();
2123
 
    }
 
2110
    }
2124
2111
    // check normal death zone linked to a team ...
2125
2112
    else if (team && deathZoneType == TYPE_TEAM)
2126
2113
    {
2128
2115
        {
2129
2116
            return;
2130
2117
        }
2131
 
        if (target->Player()->CurrentTeam() == team)
2132
 
        {
2133
 
            return;
2134
 
        }
2135
 
        else
2136
 
        {
 
2118
        if (target->Player()->CurrentTeam() == team)
 
2119
        {
 
2120
            return;
 
2121
        }
 
2122
        else
 
2123
        {
2137
2124
            target->Player()->AddScore(score_deathzone_team, "", "player_lose_deathzone_team");
2138
2125
            target->Kill();
2139
2126
            sg_deathDeathZoneTeamWriter << ePlayerNetID::FilterName( team->Name() ) << target->Player()->GetUserName();
2140
 
            sg_deathDeathZoneTeamWriter.write();
 
2127
            sg_deathDeathZoneTeamWriter.write();
2141
2128
        }
2142
2129
    }
2143
2130
    else
2184
2171
                }
2185
2172
            }
2186
2173
            else
2187
 
            {
2188
 
                if (!sg_shotKillEnemies)
2189
 
                    return;
 
2174
            {
 
2175
                if (!sg_shotKillEnemies)
 
2176
                    return;
2190
2177
 
2191
2178
                //The cycle may have been deleted since...  I think this is OK because Player() returns a checked pointer
2192
2179
 
2299
2286
 
2300
2287
        if (((deathZoneType == TYPE_ZOMBIE_ZONE) && ((!pSeekingCycle_) || (sg_zombieZoneVanish))) ||
2301
2288
            ((deathZoneType == TYPE_SELF_DESTRUCT) && (sg_selfDestructVanish)) ||
2302
 
            ((deathZoneType < TYPE_SELF_DESTRUCT) && (sg_shotKillVanish)) ||
 
2289
            ((deathZoneType < TYPE_SELF_DESTRUCT) && (sg_shotKillVanish)) ||
2303
2290
            ((deathZoneType == TYPE_SHOT && sg_shotKillEnemies)))
2304
2291
        {
2305
2292
#if 0
2484
2471
//!     @param  pos  Position to spawn the zone at
2485
2472
//!
2486
2473
// *******************************************************************************
2487
 
 
2488
 
static REAL sg_colorRubberZoneR = 15;
2489
 
static REAL sg_colorRubberZoneG = 10.5;
2490
 
static REAL sg_colorRubberZoneB = 3;
2491
 
static tSettingItem<REAL> sg_colorRubberZoneRConf("COLOR_RUBBERZONE_RED", sg_colorRubberZoneR);
2492
 
static tSettingItem<REAL> sg_colorRubberZoneGConf("COLOR_RUBBERZONE_GREEN", sg_colorRubberZoneG);
2493
 
static tSettingItem<REAL> sg_colorRubberZoneBConf("COLOR_RUBBERZONE_BLUE", sg_colorRubberZoneB);
 
2474
 
 
2475
static REAL sg_colorRubberZoneR = 15;
 
2476
static REAL sg_colorRubberZoneG = 10.5;
 
2477
static REAL sg_colorRubberZoneB = 3;
 
2478
static tSettingItem<REAL> sg_colorRubberZoneRConf("COLOR_RUBBERZONE_RED", sg_colorRubberZoneR);
 
2479
static tSettingItem<REAL> sg_colorRubberZoneGConf("COLOR_RUBBERZONE_GREEN", sg_colorRubberZoneG);
 
2480
static tSettingItem<REAL> sg_colorRubberZoneBConf("COLOR_RUBBERZONE_BLUE", sg_colorRubberZoneB);
2494
2481
 
2495
2482
gRubberZoneHack::gRubberZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, bool delayCreation)
2496
2483
:gZone( grid, pos, dynamicCreation, delayCreation)
2498
2485
    color_.r = sg_colorRubberZoneR / 15.0;
2499
2486
    color_.g = sg_colorRubberZoneG / 15.0;
2500
2487
    color_.b = sg_colorRubberZoneB / 15.0;
2501
 
 
 
2488
 
2502
2489
    if (!delayCreation)
2503
 
        grid->AddGameObjectInteresting(this);
2504
 
 
 
2490
        grid->AddGameObjectInteresting(this);
 
2491
 
2505
2492
    rmRubber = 1.0;
2506
2493
}
2507
2494
 
2529
2516
}
2530
2517
 
2531
2518
gZone & gRubberZoneHack::SetRubber(REAL rubber)
2532
 
{
2533
 
    rmRubber = rubber;
2534
 
 
2535
 
    if (rubberType_ == TYPE_RUBBER)
 
2519
{
 
2520
    rmRubber = rubber;
 
2521
 
 
2522
    if (rubberType_ == TYPE_RUBBER)
2536
2523
    {
2537
2524
        color_.r = 1.0f;
2538
2525
        REAL p_rubber = (1-(rmRubber/sg_rubberCycle));
2539
2526
        if (p_rubber <0)
2540
2527
            p_rubber=0;
2541
2528
        color_.g = (p_rubber);
2542
 
        color_.b = (p_rubber/3);
 
2529
        color_.b = (p_rubber/3);
2543
2530
    }
2544
2531
 
2545
2532
    return (*this);
2579
2566
//!     @brief    when DZ_RUBBER is not 0: change target's rubber instead of just killing
2580
2567
//!
2581
2568
// *******************************************************************************
2582
 
static eLadderLogWriter sg_deathRubberZoneWriter("DEATH_RUBBERZONE", true);
 
2569
static eLadderLogWriter sg_deathRubberZoneWriter("DEATH_RUBBERZONE", true);
2583
2570
 
2584
2571
void sg_RubberZoneHurt( gCycle * target, gRubberZoneHack *rubberZone)
2585
 
{
2586
 
    REAL rubber = target->GetRubber();
2587
 
    if (rubberZone->GetRubberType() == gRubberZoneHack::TYPE_RUBBER)
 
2572
{
 
2573
    REAL rubber = target->GetRubber();
 
2574
    if (rubberZone->GetRubberType() == gRubberZoneHack::TYPE_RUBBER)
2588
2575
    {
2589
2576
        if ( rubber + rubberZone->GetRubber() >= sg_rubberCycle )       // max rubber amount reached, kill the cycle
2590
2577
        {
2599
2586
            target->SetRubber( rubber + rubberZone->GetRubber() );
2600
2587
        }
2601
2588
        else                                                        // too low value, just set to zero
2602
 
            target->SetRubber( 0 );
2603
 
    }
2604
 
    else if (rubberZone->GetRubberType() == gRubberZoneHack::TYPE_ADJUST)
2605
 
    {
2606
 
        if (rubberZone->GetRubber() >= sg_rubberCycle)
2607
 
            rubberZone->SetRubber(sg_rubberCycle);
2608
 
 
2609
 
        target->SetRubber(rubberZone->GetRubber());
 
2589
            target->SetRubber( 0 );
 
2590
    }
 
2591
    else if (rubberZone->GetRubberType() == gRubberZoneHack::TYPE_ADJUST)
 
2592
    {
 
2593
        if (rubberZone->GetRubber() >= sg_rubberCycle)
 
2594
            rubberZone->SetRubber(sg_rubberCycle);
 
2595
 
 
2596
        target->SetRubber(rubberZone->GetRubber());
2610
2597
    }
2611
2598
}
2612
2599
 
2796
2783
 
2797
2784
 
2798
2785
static int sg_onSurviveScore = 0;
2799
 
static tSettingItem< int > sg_onSurviveConquestScoreConfig( "FORTRESS_HELD_SCORE", sg_onSurviveScore );
 
2786
static tSettingItem< int > sg_onSurviveConquestScoreConfig( "FORTRESS_HELD_SCORE", sg_onSurviveScore );
2800
2787
 
2801
2788
static REAL sg_collapseSpeed = .5;
2802
2789
static tSettingItem< REAL > sg_collapseSpeedConfig( "FORTRESS_COLLAPSE_SPEED", sg_collapseSpeed );
3444
3431
            int count = 0;
3445
3432
            CountZonesOfTeam( Grid(), team, count, farthest );
3446
3433
 
3447
 
            // discard team of farthest zone
 
3434
            // discard team of farthest zone
3448
3435
            // No NULL check is required here for farthest, since count is greater than 0 which implies farthest was set.
3449
3436
            if ( count > sg_baseZonesPerTeam )
3450
3437
            {
3700
3687
            }
3701
3688
        }
3702
3689
    }
3703
 
}
3704
 
 
 
3690
}
 
3691
 
3705
3692
// flag indicating whether base will respawn team if a team player's shot enters it
3706
3693
static bool sg_shotbaseRespawn = false;
3707
3694
static tSettingItem<bool> sg_shotBaseRespawnConfig ("SHOT_BASE_RESPAWN", sg_shotbaseRespawn);
3708
3695
 
3709
3696
// flag indicating whether base will respawn team if an enemy player's shot enters it
3710
3697
static bool sg_shotbaseEnemyRespawn = false;
3711
 
static tSettingItem<bool> sg_shotBaseEnemyRespawnConfig ("SHOT_BASE_ENEMY_RESPAWN", sg_shotbaseEnemyRespawn);
3712
 
 
3713
 
static int sg_scoreShotBase = 0;
 
3698
static tSettingItem<bool> sg_shotBaseEnemyRespawnConfig ("SHOT_BASE_ENEMY_RESPAWN", sg_shotbaseEnemyRespawn);
 
3699
 
 
3700
static int sg_scoreShotBase = 0;
3714
3701
static tSettingItem<int> sg_scoreShotBaseConf("SCORE_SHOT_BASE", sg_scoreShotBase);
3715
3702
 
3716
3703
 
3729
3716
{
3730
3717
                                 //it already hit the zone.
3731
3718
    if(currentState_ == State_Conquering || currentState_ == State_Conquered) return;
3732
 
    gBallZoneHack *ball = dynamic_cast<gBallZoneHack *>(target);
 
3719
    gBallZoneHack *ball = dynamic_cast<gBallZoneHack *>(target);
3733
3720
 
3734
3721
    // check ball team mode
3735
3722
    bool toScore;
3852
3839
                ball->GoHome();
3853
3840
            }
3854
3841
        }
3855
 
    }
3856
 
 
3857
 
    gDeathZoneHack *deathZone = dynamic_cast<gDeathZoneHack *>(target);
3858
 
    if (deathZone)
3859
 
    {
3860
 
        if (deathZone->GetType() == gDeathZoneHack::TYPE_SHOT)
3861
 
        {
3862
 
            ePlayerNetID *shotOwner = deathZone->GetOwner();
3863
 
            if (shotOwner && (((shotOwner->CurrentTeam() == team) && sg_shotbaseRespawn) || ((shotOwner->CurrentTeam() != team) && sg_shotbaseEnemyRespawn)))
3864
 
            {
 
3842
    }
 
3843
 
 
3844
    gDeathZoneHack *deathZone = dynamic_cast<gDeathZoneHack *>(target);
 
3845
    if (deathZone)
 
3846
    {
 
3847
        if (deathZone->GetType() == gDeathZoneHack::TYPE_SHOT)
 
3848
        {
 
3849
            ePlayerNetID *shotOwner = deathZone->GetOwner();
 
3850
            if (shotOwner && (((shotOwner->CurrentTeam() == team) && sg_shotbaseRespawn) || ((shotOwner->CurrentTeam() != team) && sg_shotbaseEnemyRespawn)))
 
3851
            {
3865
3852
                gSpawnPoint *pSpawn = Arena.ClosestSpawnPoint(GetPosition());
3866
3853
 
3867
3854
                if (pSpawn)
3883
3870
                            pSpawn->Spawn(pos, dir);
3884
3871
 
3885
3872
                            gCycle *pCycle = new gCycle(grid, pos, dir, pPlayer);
3886
 
                            pPlayer->ControlObject(pCycle);
3887
 
 
 
3873
                            pPlayer->ControlObject(pCycle);
 
3874
 
3888
3875
                            tColoredString playerName;
3889
3876
                            playerName << *pPlayer << tColoredString::ColorString(1,1,1);
3890
 
 
3891
 
                            if (shotOwner->CurrentTeam() == team)
 
3877
 
 
3878
                            if (shotOwner->CurrentTeam() == team)
3892
3879
                            {
3893
3880
                                tColoredString spawnerName;
3894
3881
                                spawnerName << shotOwner->GetColoredName() << tColoredString::ColorString(1,1,1);
3895
 
                                sn_ConsoleOut( tOutput( "$player_base_respawn", playerName, spawnerName ) );
3896
 
                            }
3897
 
                            else
 
3882
                                sn_ConsoleOut( tOutput( "$player_base_respawn", playerName, spawnerName ) );
 
3883
                            }
 
3884
                            else
3898
3885
                            {
3899
3886
                                tColoredString spawnerName;
3900
3887
                                spawnerName << shotOwner->GetColoredName() << tColoredString::ColorString(1,1,1);
3901
3888
                                sn_ConsoleOut( tOutput( "$player_base_enemy_respawn", playerName, spawnerName ) );
3902
 
                            }
3903
 
                        }
3904
 
                    }
3905
 
                }
3906
 
            }
3907
 
            tOutput win;
3908
 
            win.SetTemplateParameter(1, shotOwner->GetName());
3909
 
            win.SetTemplateParameter(3, team->Name());
3910
 
            win << "$player_shot_base";
3911
 
            shotOwner->AddScore(sg_scoreShotBase, win, "");
3912
 
        }
 
3889
                            }
 
3890
                        }
 
3891
                    }
 
3892
                }
 
3893
            }
 
3894
            tOutput win;
 
3895
            win.SetTemplateParameter(1, shotOwner->GetName());
 
3896
            win.SetTemplateParameter(3, team->Name());
 
3897
            win << "$player_shot_base";
 
3898
            shotOwner->AddScore(sg_scoreShotBase, win, "");
 
3899
        }
3913
3900
    }
3914
3901
}
3915
3902
 
3950
3937
}
3951
3938
 
3952
3939
void gSumoZoneHack::OnVanish( void )
3953
 
{
 
3940
{
3954
3941
    grid->RemoveGameObjectInteresting(this);
3955
3942
}
3956
3943
// *******************************************************************************
4530
4517
    lastImpactTime_ = 0;
4531
4518
 
4532
4519
    if (teamowner!=NULL) team = teamowner;
4533
 
 
 
4520
 
4534
4521
    if (!delayCreation)
4535
4522
        grid->AddGameObjectInteresting(this);
4536
4523
}
4831
4818
    ownerDropped_ = NULL;
4832
4819
    ownerDroppedTime_ = 0;
4833
4820
    lastHoldScoreTime_ = -1;
4834
 
    positionUpdatePending_ = false;
4835
 
 
4836
 
    passingTheFlag_ = false;
4837
 
    passingOwner_ = NULL;
 
4821
    positionUpdatePending_ = false;
 
4822
 
 
4823
    passingTheFlag_ = false;
 
4824
    passingOwner_ = NULL;
4838
4825
    passerOwnerFree_ = false;
4839
4826
 
4840
4827
    SetExpansionSpeed(0);
4869
4856
    ownerDropped_ = NULL;
4870
4857
    ownerDroppedTime_ = 0;
4871
4858
    lastHoldScoreTime_ = -1;
4872
 
    positionUpdatePending_ = false;
4873
 
 
4874
 
    passingTheFlag_ = false;
4875
 
    passingOwner_ = NULL;
 
4859
    positionUpdatePending_ = false;
 
4860
 
 
4861
    passingTheFlag_ = false;
 
4862
    passingOwner_ = NULL;
4876
4863
    passerOwnerFree_ = false;
4877
4864
}
4878
4865
 
4943
4930
static tSettingItem<float> sg_flagColorGConfig( "FLAG_COLOR_G", sg_flagColorG );
4944
4931
 
4945
4932
static float sg_flagColorB = -1;
4946
 
static tSettingItem<float> sg_flagColorBConfig( "FLAG_COLOR_B", sg_flagColorB );
4947
 
 
4948
 
REAL sg_flagPassSpeed = 30;
 
4933
static tSettingItem<float> sg_flagColorBConfig( "FLAG_COLOR_B", sg_flagColorB );
 
4934
 
 
4935
REAL sg_flagPassSpeed = 30;
4949
4936
static tSettingItem<REAL> sg_flagPassSpeedConf("FLAG_PASS_SPEED", sg_flagPassSpeed);
4950
4937
 
4951
4938
// *******************************************************************************
5192
5179
                }
5193
5180
            }
5194
5181
        }
5195
 
    }
5196
 
 
5197
 
    if (passingTheFlag_)
5198
 
    {
5199
 
        if (passingOwner_ && !owner_)
5200
 
        {
5201
 
            if (passingOwner_->Alive())
5202
 
            {
 
5182
    }
 
5183
 
 
5184
    if (passingTheFlag_)
 
5185
    {
 
5186
        if (passingOwner_ && !owner_)
 
5187
        {
 
5188
            if (passingOwner_->Alive())
 
5189
            {
5203
5190
                //Calculate new direction
5204
5191
                eCoord newDir = passingOwner_->Position() - GetPosition();
5205
5192
                newDir.Normalize();
5206
5193
 
5207
 
                SetReferenceTime();
5208
 
 
5209
 
                //  take in the speed of the flag speed command + the person who is going to receive the flag
 
5194
                SetReferenceTime();
 
5195
 
 
5196
                //  take in the speed of the flag speed command + the person who is going to receive the flag
5210
5197
                int newSpeed = sg_flagPassSpeed + (passingOwner_->verletSpeed_);
5211
 
                SetVelocity(newDir * newSpeed);
5212
 
 
5213
 
                RequestSync();
5214
 
            }
5215
 
            else
5216
 
            {
 
5198
                SetVelocity(newDir * newSpeed);
 
5199
 
 
5200
                RequestSync();
 
5201
            }
 
5202
            else
 
5203
            {
5217
5204
                SetReferenceTime();
5218
5205
                SetVelocity(se_zeroCoord);
5219
5206
                SetRadius(originalRadius_);
5220
5207
                SetExpansionSpeed(0);
5221
5208
                RequestSync();
5222
 
                positionUpdatePending_ = true;
5223
 
 
5224
 
                SetPassing(false);
5225
 
            }
5226
 
        }
5227
 
        else if(!passingOwner_)
5228
 
        {
 
5209
                positionUpdatePending_ = true;
 
5210
 
 
5211
                SetPassing(false);
 
5212
            }
 
5213
        }
 
5214
        else if(!passingOwner_)
 
5215
        {
5229
5216
            SetReferenceTime();
5230
5217
            SetVelocity(se_zeroCoord);
5231
5218
            SetRadius(originalRadius_);
5232
5219
            SetExpansionSpeed(0);
5233
5220
            RequestSync();
5234
 
            positionUpdatePending_ = true;
5235
 
 
5236
 
            SetPassing(false);
5237
 
        }
 
5221
            positionUpdatePending_ = true;
 
5222
 
 
5223
            SetPassing(false);
 
5224
        }
5238
5225
    }
5239
5226
 
5240
5227
    // delegate
5244
5231
    positionUpdatePending_ = false;
5245
5232
 
5246
5233
    return (returnStatus);
5247
 
}
5248
 
 
 
5234
}
 
5235
 
5249
5236
// *******************************************************************************
5250
5237
// *
5251
5238
// *    PassTheFlag
5252
5239
// *
5253
 
// *******************************************************************************
5254
 
 
5255
 
void gFlagZoneHack::PassComplete(gCycle *target)
5256
 
{
5257
 
    //  finish passing the flag
5258
 
    if (passingTheFlag_ && passingOwner_ && passerOwner_)
5259
 
    {
5260
 
        tOutput message;
5261
 
 
5262
 
        tColoredString playerName, passingName;
5263
 
        passingName << passerOwner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5264
 
        playerName << target->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5265
 
 
5266
 
        if (target == passingOwner_)
5267
 
        {
5268
 
            message.SetTemplateParameter(1, playerName);
5269
 
            message.SetTemplateParameter(2, passingName);
5270
 
            message << "$flag_pass_complete_same";
5271
 
        }
5272
 
        else
5273
 
        {
5274
 
            message.SetTemplateParameter(1, passingName);
5275
 
            message.SetTemplateParameter(2, playerName);
5276
 
            message << "$flag_pass_complete_diff";
5277
 
        }
5278
 
        sn_ConsoleOut(message);
5279
 
    }
5280
 
 
5281
 
    SetPassing(false);
5282
 
}
5283
 
 
5284
 
void gFlagZoneHack::PassFailed(gCycle *target)
5285
 
{
5286
 
    //  finish passing the flag
5287
 
    if (passingTheFlag_ && passingOwner_ && passerOwner_)
5288
 
    {
5289
 
        tOutput message;
5290
 
 
5291
 
        tColoredString playerName, passingName;
5292
 
        passingName << passerOwner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5293
 
        playerName << target->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5294
 
 
5295
 
        message.SetTemplateParameter(1, passingName);
5296
 
        message.SetTemplateParameter(2, playerName);
5297
 
        message << "$flag_pass_failed";
5298
 
        sn_ConsoleOut(message);
5299
 
    }
5300
 
 
5301
 
    SetPassing(false);
5302
 
}
5303
 
 
5304
 
void gFlagZoneHack::SetPassing(bool passed, gCycle *passOwner)
5305
 
{
5306
 
    if (passed)
5307
 
    {
5308
 
        passingTheFlag_ = true;
5309
 
        passingOwner_ = passOwner;
5310
 
        passerOwner_ = owner_;
5311
 
        passerOwnerFree_ = false;
5312
 
    }
5313
 
    else
5314
 
    {
5315
 
        passingTheFlag_ = false;
5316
 
        passingOwner_ = NULL;
5317
 
        passerOwner_ = NULL;
5318
 
        passerOwnerFree_ = false;
5319
 
    }
5320
 
}
5321
 
 
5322
 
enum gFlagPassMode
5323
 
{
5324
 
    gFLAGPASS_DISABLE = 0,  //! Disable passing the flag to team members
5325
 
    gFLAGPASS_CLOSEST = 1,  //! Picks a team member close to the passing player
5326
 
    gFLAGPASS_FURTHEST = 2, //! Picks a team member furthur to the passing player
5327
 
    gFLAGPASS_DISTANCE = 3, //! Picks a team member within the distance specified
5328
 
    gFLAGPASS_PERSON = 4    //! Picks a team member by the given name
5329
 
};
5330
 
tCONFIG_ENUM( gFlagPassMode );
5331
 
 
5332
 
gFlagPassMode sg_flagPassMode = gFLAGPASS_DISABLE;
5333
 
bool restrictFlagPassMode(const gFlagPassMode &newValue)
5334
 
{
5335
 
    if ((newValue < gFLAGPASS_DISABLE) || (newValue > gFLAGPASS_PERSON)) return false;
5336
 
    return true;
5337
 
}
5338
 
static tSettingItem<gFlagPassMode> sg_flagPassModeConf("FLAG_PASS_MODE", sg_flagPassMode, &restrictFlagPassMode);
5339
 
 
5340
 
REAL sg_flagPassDistance = 5.0;
5341
 
bool restrictFlagPassDistance(const REAL &newValue)
5342
 
{
5343
 
    if (newValue < 0) return false;
5344
 
    return true;
5345
 
}
5346
 
static tSettingItem<REAL> sg_flagPassDistanceConf("FLAG_PASS_DISTANCE", sg_flagPassDistance, &restrictFlagPassDistance);
5347
 
 
5348
 
void gFlagZoneHack::PassTheFlag(tString name)
5349
 
{
5350
 
    if (owner_)
5351
 
    {
5352
 
        if (sg_flagPassMode == gFLAGPASS_DISABLE) return;
5353
 
 
5354
 
        int alive = 0;
5355
 
        for (int i = 0; i < owner_->Team()->players.Len(); i++)
5356
 
        {
5357
 
            ePlayerNetID *p = owner_->Team()->players[i];
5358
 
            if (p && (p != owner_->Player()))
5359
 
            {
5360
 
                gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
5361
 
 
5362
 
                if (pCycle && pCycle->Alive())
5363
 
                {
5364
 
                    alive++;
5365
 
                }
5366
 
            }
5367
 
        }
5368
 
 
5369
 
        //  if no member is alive other than yourself, don't pass the flag
5370
 
        if (alive == 0) return;
5371
 
 
5372
 
        //  check the modes of each
5373
 
        gCycle *passOwner = NULL;
5374
 
        if (sg_flagPassMode == gFLAGPASS_CLOSEST)
5375
 
        {
5376
 
            REAL closestDistance = 0;
5377
 
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
5378
 
            {
5379
 
                ePlayerNetID *p = owner_->Team()->players[i];
5380
 
                if (p && (p != owner_->Player()))
5381
 
                {
5382
 
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
5383
 
 
5384
 
                    if (pCycle && pCycle->Alive())
5385
 
                    {
5386
 
                        eCoord otherpos = pCycle->Position() - owner_->Position();
5387
 
                        REAL distance = otherpos.NormSquared();
5388
 
                        if (!passOwner || (distance < closestDistance))
5389
 
                        {
5390
 
                            passOwner = pCycle;
5391
 
                            closestDistance = distance;
5392
 
                        }
5393
 
                    }
5394
 
                }
5395
 
            }
5396
 
 
5397
 
            if (passOwner)
5398
 
            {
5399
 
                // put the flag to move towards new owner
5400
 
                SetReferenceTime();
5401
 
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
5402
 
                SetPosition(owner_->Position());
5403
 
                SetRadius(originalRadius_);
5404
 
                SetExpansionSpeed(0);
5405
 
                RequestSync();
5406
 
                positionUpdatePending_ = true;
5407
 
 
5408
 
                //  announce the passing activation
5409
 
                tOutput message;
5410
 
 
5411
 
                tColoredString playerName, passingName;
5412
 
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5413
 
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5414
 
 
5415
 
                message.SetTemplateParameter(1, passingName);
5416
 
                message.SetTemplateParameter(2, playerName);
5417
 
                message << "$flag_pass_active";
5418
 
                sn_ConsoleOut(message);
5419
 
 
5420
 
                //  set the passing owner (one to receive the flag)
5421
 
                SetPassing(true, passOwner);
5422
 
 
5423
 
                // remove the current owner
5424
 
                RemoveOwner();
5425
 
            }
5426
 
        }
5427
 
        else if (sg_flagPassMode == gFLAGPASS_FURTHEST)
5428
 
        {
5429
 
            REAL furthestDistance = 0;
5430
 
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
5431
 
            {
5432
 
                ePlayerNetID *p = owner_->Team()->players[i];
5433
 
                if (p && (p != owner_->Player()))
5434
 
                {
5435
 
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
5436
 
 
5437
 
                    if (pCycle && pCycle->Alive())
5438
 
                    {
5439
 
                        eCoord otherpos = pCycle->Position() - owner_->Position();
5440
 
                        REAL distance = otherpos.NormSquared();
5441
 
                        if (!passOwner || (distance > furthestDistance))
5442
 
                        {
5443
 
                            passOwner = pCycle;
5444
 
                            furthestDistance = distance;
5445
 
                        }
5446
 
                    }
5447
 
                }
5448
 
            }
5449
 
 
5450
 
            if (passOwner)
5451
 
            {
5452
 
                // put the flag to move towards new owner
5453
 
                SetReferenceTime();
5454
 
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
5455
 
                SetPosition(owner_->Position());
5456
 
                SetRadius(originalRadius_);
5457
 
                SetExpansionSpeed(0);
5458
 
                RequestSync();
5459
 
                positionUpdatePending_ = true;
5460
 
 
5461
 
                //  announce the passing activation
5462
 
                tOutput message;
5463
 
 
5464
 
                tColoredString playerName, passingName;
5465
 
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5466
 
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5467
 
 
5468
 
                message.SetTemplateParameter(1, passingName);
5469
 
                message.SetTemplateParameter(2, playerName);
5470
 
                message << "$flag_pass_active";
5471
 
                sn_ConsoleOut(message);
5472
 
 
5473
 
                //  set the passing owner
5474
 
                SetPassing(true, passOwner);
5475
 
 
5476
 
                // remove the current owner
5477
 
                RemoveOwner();
5478
 
            }
5479
 
        }
5480
 
        else if (sg_flagPassMode == gFLAGPASS_DISTANCE)
5481
 
        {
5482
 
            REAL furthestDistance = 0;
5483
 
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
5484
 
            {
5485
 
                ePlayerNetID *p = owner_->Team()->players[i];
5486
 
                if (p && (p != owner_->Player()))
5487
 
                {
5488
 
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
5489
 
 
5490
 
                    if (pCycle && pCycle->Alive())
5491
 
                    {
5492
 
                        eCoord otherpos = pCycle->Position() - owner_->Position();
5493
 
                        REAL distance = otherpos.NormSquared();
5494
 
                        if (!passOwner || (distance > furthestDistance))
5495
 
                        {
5496
 
                            passOwner = pCycle;
5497
 
                            furthestDistance = distance;
5498
 
                        }
5499
 
 
5500
 
                        //  if distance is over the specified flag distance, break out of the function
5501
 
                        if (furthestDistance >= sg_flagPassDistance) break;
5502
 
                    }
5503
 
                }
5504
 
            }
5505
 
 
5506
 
            if (passOwner)
5507
 
            {
5508
 
                // put the flag to move towards new owner
5509
 
                SetReferenceTime();
5510
 
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
5511
 
                SetPosition(owner_->Position());
5512
 
                SetRadius(originalRadius_);
5513
 
                SetExpansionSpeed(0);
5514
 
                RequestSync();
5515
 
                positionUpdatePending_ = true;
5516
 
 
5517
 
                //  announce the passing activation
5518
 
                tOutput message;
5519
 
 
5520
 
                tColoredString playerName, passingName;
5521
 
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5522
 
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5523
 
 
5524
 
                message.SetTemplateParameter(1, passingName);
5525
 
                message.SetTemplateParameter(2, playerName);
5526
 
                message << "$flag_pass_active";
5527
 
                sn_ConsoleOut(message);
5528
 
 
5529
 
                //  set the passing owner
5530
 
                SetPassing(true, passOwner);
5531
 
 
5532
 
                // remove the current owner
5533
 
                RemoveOwner();
5534
 
            }
5535
 
        }
5536
 
        else if (sg_flagPassMode == gFLAGPASS_PERSON)
5537
 
        {
5538
 
            if (name.Filter() == "") return;
5539
 
 
5540
 
            ePlayerNetID *p = ePlayerNetID::FindPlayerByName(name);
5541
 
            if (!p) return;
5542
 
 
5543
 
            //  make sure that only the same team member will be allowed to get the pass of the flag
5544
 
            if (p->CurrentTeam() != owner_->Team()) return;
5545
 
 
5546
 
            passOwner = dynamic_cast<gCycle *>(p->Object());
5547
 
            if (passOwner)
5548
 
            {
5549
 
                // put the flag to move towards new owner
5550
 
                SetReferenceTime();
5551
 
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
5552
 
                SetPosition(owner_->Position());
5553
 
                SetRadius(originalRadius_);
5554
 
                SetExpansionSpeed(0);
5555
 
                RequestSync();
5556
 
                positionUpdatePending_ = true;
5557
 
 
5558
 
                //  announce the passing activation
5559
 
                tOutput message;
5560
 
 
5561
 
                tColoredString playerName, passingName;
5562
 
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5563
 
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
5564
 
 
5565
 
                message.SetTemplateParameter(1, passingName);
5566
 
                message.SetTemplateParameter(2, playerName);
5567
 
                message << "$flag_pass_active";
5568
 
                sn_ConsoleOut(message);
5569
 
 
5570
 
                //  set the passing owner
5571
 
                SetPassing(true, passOwner);
5572
 
 
5573
 
                // remove the current owner
5574
 
                RemoveOwner();
5575
 
            }
5576
 
        }
5577
 
    }
 
5240
// *******************************************************************************
 
5241
 
 
5242
void gFlagZoneHack::PassComplete(gCycle *target)
 
5243
{
 
5244
    //  finish passing the flag
 
5245
    if (passingTheFlag_ && passingOwner_ && passerOwner_)
 
5246
    {
 
5247
        tOutput message;
 
5248
 
 
5249
        tColoredString playerName, passingName;
 
5250
        passingName << passerOwner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5251
        playerName << target->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5252
 
 
5253
        if (target == passingOwner_)
 
5254
        {
 
5255
            message.SetTemplateParameter(1, playerName);
 
5256
            message.SetTemplateParameter(2, passingName);
 
5257
            message << "$flag_pass_complete_same";
 
5258
        }
 
5259
        else
 
5260
        {
 
5261
            message.SetTemplateParameter(1, passingName);
 
5262
            message.SetTemplateParameter(2, playerName);
 
5263
            message << "$flag_pass_complete_diff";
 
5264
        }
 
5265
        sn_ConsoleOut(message);
 
5266
    }
 
5267
 
 
5268
    SetPassing(false);
 
5269
}
 
5270
 
 
5271
void gFlagZoneHack::PassFailed(gCycle *target)
 
5272
{
 
5273
    //  finish passing the flag
 
5274
    if (passingTheFlag_ && passingOwner_ && passerOwner_)
 
5275
    {
 
5276
        tOutput message;
 
5277
 
 
5278
        tColoredString playerName, passingName;
 
5279
        passingName << passerOwner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5280
        playerName << target->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5281
 
 
5282
        message.SetTemplateParameter(1, passingName);
 
5283
        message.SetTemplateParameter(2, playerName);
 
5284
        message << "$flag_pass_failed";
 
5285
        sn_ConsoleOut(message);
 
5286
    }
 
5287
 
 
5288
    SetPassing(false);
 
5289
}
 
5290
 
 
5291
void gFlagZoneHack::SetPassing(bool passed, gCycle *passOwner)
 
5292
{
 
5293
    if (passed)
 
5294
    {
 
5295
        passingTheFlag_ = true;
 
5296
        passingOwner_ = passOwner;
 
5297
        passerOwner_ = owner_;
 
5298
        passerOwnerFree_ = false;
 
5299
    }
 
5300
    else
 
5301
    {
 
5302
        passingTheFlag_ = false;
 
5303
        passingOwner_ = NULL;
 
5304
        passerOwner_ = NULL;
 
5305
        passerOwnerFree_ = false;
 
5306
    }
 
5307
}
 
5308
 
 
5309
enum gFlagPassMode
 
5310
{
 
5311
    gFLAGPASS_DISABLE = 0,  //! Disable passing the flag to team members
 
5312
    gFLAGPASS_CLOSEST = 1,  //! Picks a team member close to the passing player
 
5313
    gFLAGPASS_FURTHEST = 2, //! Picks a team member furthur to the passing player
 
5314
    gFLAGPASS_DISTANCE = 3, //! Picks a team member within the distance specified
 
5315
    gFLAGPASS_PERSON = 4    //! Picks a team member by the given name
 
5316
};
 
5317
tCONFIG_ENUM( gFlagPassMode );
 
5318
 
 
5319
gFlagPassMode sg_flagPassMode = gFLAGPASS_DISABLE;
 
5320
bool restrictFlagPassMode(const gFlagPassMode &newValue)
 
5321
{
 
5322
    if ((newValue < gFLAGPASS_DISABLE) || (newValue > gFLAGPASS_PERSON)) return false;
 
5323
    return true;
 
5324
}
 
5325
static tSettingItem<gFlagPassMode> sg_flagPassModeConf("FLAG_PASS_MODE", sg_flagPassMode, &restrictFlagPassMode);
 
5326
 
 
5327
REAL sg_flagPassDistance = 5.0;
 
5328
bool restrictFlagPassDistance(const REAL &newValue)
 
5329
{
 
5330
    if (newValue < 0) return false;
 
5331
    return true;
 
5332
}
 
5333
static tSettingItem<REAL> sg_flagPassDistanceConf("FLAG_PASS_DISTANCE", sg_flagPassDistance, &restrictFlagPassDistance);
 
5334
 
 
5335
void gFlagZoneHack::PassTheFlag(tString name)
 
5336
{
 
5337
    if (owner_)
 
5338
    {
 
5339
        if (sg_flagPassMode == gFLAGPASS_DISABLE) return;
 
5340
 
 
5341
        int alive = 0;
 
5342
        for (int i = 0; i < owner_->Team()->players.Len(); i++)
 
5343
        {
 
5344
            ePlayerNetID *p = owner_->Team()->players[i];
 
5345
            if (p && (p != owner_->Player()))
 
5346
            {
 
5347
                gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
 
5348
 
 
5349
                if (pCycle && pCycle->Alive())
 
5350
                {
 
5351
                    alive++;
 
5352
                }
 
5353
            }
 
5354
        }
 
5355
 
 
5356
        //  if no member is alive other than yourself, don't pass the flag
 
5357
        if (alive == 0) return;
 
5358
 
 
5359
        //  check the modes of each
 
5360
        gCycle *passOwner = NULL;
 
5361
        if (sg_flagPassMode == gFLAGPASS_CLOSEST)
 
5362
        {
 
5363
            REAL closestDistance = 0;
 
5364
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
 
5365
            {
 
5366
                ePlayerNetID *p = owner_->Team()->players[i];
 
5367
                if (p && (p != owner_->Player()))
 
5368
                {
 
5369
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
 
5370
 
 
5371
                    if (pCycle && pCycle->Alive())
 
5372
                    {
 
5373
                        eCoord otherpos = pCycle->Position() - owner_->Position();
 
5374
                        REAL distance = otherpos.NormSquared();
 
5375
                        if (!passOwner || (distance < closestDistance))
 
5376
                        {
 
5377
                            passOwner = pCycle;
 
5378
                            closestDistance = distance;
 
5379
                        }
 
5380
                    }
 
5381
                }
 
5382
            }
 
5383
 
 
5384
            if (passOwner)
 
5385
            {
 
5386
                // put the flag to move towards new owner
 
5387
                SetReferenceTime();
 
5388
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
 
5389
                SetPosition(owner_->Position());
 
5390
                SetRadius(originalRadius_);
 
5391
                SetExpansionSpeed(0);
 
5392
                RequestSync();
 
5393
                positionUpdatePending_ = true;
 
5394
 
 
5395
                //  announce the passing activation
 
5396
                tOutput message;
 
5397
 
 
5398
                tColoredString playerName, passingName;
 
5399
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5400
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5401
 
 
5402
                message.SetTemplateParameter(1, passingName);
 
5403
                message.SetTemplateParameter(2, playerName);
 
5404
                message << "$flag_pass_active";
 
5405
                sn_ConsoleOut(message);
 
5406
 
 
5407
                //  set the passing owner (one to receive the flag)
 
5408
                SetPassing(true, passOwner);
 
5409
 
 
5410
                // remove the current owner
 
5411
                RemoveOwner();
 
5412
            }
 
5413
        }
 
5414
        else if (sg_flagPassMode == gFLAGPASS_FURTHEST)
 
5415
        {
 
5416
            REAL furthestDistance = 0;
 
5417
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
 
5418
            {
 
5419
                ePlayerNetID *p = owner_->Team()->players[i];
 
5420
                if (p && (p != owner_->Player()))
 
5421
                {
 
5422
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
 
5423
 
 
5424
                    if (pCycle && pCycle->Alive())
 
5425
                    {
 
5426
                        eCoord otherpos = pCycle->Position() - owner_->Position();
 
5427
                        REAL distance = otherpos.NormSquared();
 
5428
                        if (!passOwner || (distance > furthestDistance))
 
5429
                        {
 
5430
                            passOwner = pCycle;
 
5431
                            furthestDistance = distance;
 
5432
                        }
 
5433
                    }
 
5434
                }
 
5435
            }
 
5436
 
 
5437
            if (passOwner)
 
5438
            {
 
5439
                // put the flag to move towards new owner
 
5440
                SetReferenceTime();
 
5441
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
 
5442
                SetPosition(owner_->Position());
 
5443
                SetRadius(originalRadius_);
 
5444
                SetExpansionSpeed(0);
 
5445
                RequestSync();
 
5446
                positionUpdatePending_ = true;
 
5447
 
 
5448
                //  announce the passing activation
 
5449
                tOutput message;
 
5450
 
 
5451
                tColoredString playerName, passingName;
 
5452
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5453
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5454
 
 
5455
                message.SetTemplateParameter(1, passingName);
 
5456
                message.SetTemplateParameter(2, playerName);
 
5457
                message << "$flag_pass_active";
 
5458
                sn_ConsoleOut(message);
 
5459
 
 
5460
                //  set the passing owner
 
5461
                SetPassing(true, passOwner);
 
5462
 
 
5463
                // remove the current owner
 
5464
                RemoveOwner();
 
5465
            }
 
5466
        }
 
5467
        else if (sg_flagPassMode == gFLAGPASS_DISTANCE)
 
5468
        {
 
5469
            REAL furthestDistance = 0;
 
5470
            for (int i = 0; i < owner_->Team()->players.Len(); i++)
 
5471
            {
 
5472
                ePlayerNetID *p = owner_->Team()->players[i];
 
5473
                if (p && (p != owner_->Player()))
 
5474
                {
 
5475
                    gCycle *pCycle = dynamic_cast<gCycle *>(p->Object());
 
5476
 
 
5477
                    if (pCycle && pCycle->Alive())
 
5478
                    {
 
5479
                        eCoord otherpos = pCycle->Position() - owner_->Position();
 
5480
                        REAL distance = otherpos.NormSquared();
 
5481
                        if (!passOwner || (distance > furthestDistance))
 
5482
                        {
 
5483
                            passOwner = pCycle;
 
5484
                            furthestDistance = distance;
 
5485
                        }
 
5486
 
 
5487
                        //  if distance is over the specified flag distance, break out of the function
 
5488
                        if (furthestDistance >= sg_flagPassDistance) break;
 
5489
                    }
 
5490
                }
 
5491
            }
 
5492
 
 
5493
            if (passOwner)
 
5494
            {
 
5495
                // put the flag to move towards new owner
 
5496
                SetReferenceTime();
 
5497
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
 
5498
                SetPosition(owner_->Position());
 
5499
                SetRadius(originalRadius_);
 
5500
                SetExpansionSpeed(0);
 
5501
                RequestSync();
 
5502
                positionUpdatePending_ = true;
 
5503
 
 
5504
                //  announce the passing activation
 
5505
                tOutput message;
 
5506
 
 
5507
                tColoredString playerName, passingName;
 
5508
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5509
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5510
 
 
5511
                message.SetTemplateParameter(1, passingName);
 
5512
                message.SetTemplateParameter(2, playerName);
 
5513
                message << "$flag_pass_active";
 
5514
                sn_ConsoleOut(message);
 
5515
 
 
5516
                //  set the passing owner
 
5517
                SetPassing(true, passOwner);
 
5518
 
 
5519
                // remove the current owner
 
5520
                RemoveOwner();
 
5521
            }
 
5522
        }
 
5523
        else if (sg_flagPassMode == gFLAGPASS_PERSON)
 
5524
        {
 
5525
            if (name.Filter() == "") return;
 
5526
 
 
5527
            ePlayerNetID *p = ePlayerNetID::FindPlayerByName(name);
 
5528
            if (!p) return;
 
5529
 
 
5530
            //  make sure that only the same team member will be allowed to get the pass of the flag
 
5531
            if (p->CurrentTeam() != owner_->Team()) return;
 
5532
 
 
5533
            passOwner = dynamic_cast<gCycle *>(p->Object());
 
5534
            if (passOwner)
 
5535
            {
 
5536
                // put the flag to move towards new owner
 
5537
                SetReferenceTime();
 
5538
                SetVelocity(passOwner->Direction() * owner_->verletSpeed_);
 
5539
                SetPosition(owner_->Position());
 
5540
                SetRadius(originalRadius_);
 
5541
                SetExpansionSpeed(0);
 
5542
                RequestSync();
 
5543
                positionUpdatePending_ = true;
 
5544
 
 
5545
                //  announce the passing activation
 
5546
                tOutput message;
 
5547
 
 
5548
                tColoredString playerName, passingName;
 
5549
                passingName << owner_->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5550
                playerName << passOwner->Player()->GetColoredName() << tColoredString::ColorString(1,1,1);
 
5551
 
 
5552
                message.SetTemplateParameter(1, passingName);
 
5553
                message.SetTemplateParameter(2, playerName);
 
5554
                message << "$flag_pass_active";
 
5555
                sn_ConsoleOut(message);
 
5556
 
 
5557
                //  set the passing owner
 
5558
                SetPassing(true, passOwner);
 
5559
 
 
5560
                // remove the current owner
 
5561
                RemoveOwner();
 
5562
            }
 
5563
        }
 
5564
    }
5578
5565
}
5579
5566
 
5580
5567
 
5632
5619
 
5633
5620
    // check if the player is on our team or not (check will fail if team not enabled)
5634
5621
    if (target->Player()->CurrentTeam() == team)
5635
 
    {
5636
 
        PassFailed(target);
 
5622
    {
 
5623
        PassFailed(target);
5637
5624
 
5638
5625
        // player is on our team, if we're not at home, go back
5639
5626
        if (!IsHome())
5651
5638
    }
5652
5639
    // check if this player dropped the flag previously and ensure that player does not have another flag
5653
5640
    else if (((target != ownerDropped_) || (time > (ownerDroppedTime_ + sg_flagDropTime))) && (!playerHasFlag))
5654
 
    {
5655
 
        bool process = true;
5656
 
        if ((sg_flagPassMode > gFLAGPASS_DISABLE) && passingTheFlag_ && !passerOwnerFree_)
5657
 
            process = false;
5658
 
 
5659
 
        if (process)
 
5641
    {
 
5642
        bool process = true;
 
5643
        if ((sg_flagPassMode > gFLAGPASS_DISABLE) && passingTheFlag_ && !passerOwnerFree_)
 
5644
            process = false;
 
5645
 
 
5646
        if (process)
5660
5647
        {
5661
5648
            // take the flag
5662
5649
            owner_ = target;
5666
5653
            owner_->flag_ = this;
5667
5654
 
5668
5655
            blinkUpdateTime_ = -1000;
5669
 
            blinkTrackUpdateTime_ = -1000;
5670
 
 
 
5656
            blinkTrackUpdateTime_ = -1000;
 
5657
 
5671
5658
            PassComplete(target);
5672
5659
 
5673
5660
            // diminish the flag and put it at the original location
5687
5674
 
5688
5675
            tColoredString playerName;
5689
5676
            playerName << *target->Player() << tColoredString::ColorString(1,1,1);
5690
 
            sn_ConsoleOut( tOutput( "$player_flag_take", playerName ) );
 
5677
            sn_ConsoleOut( tOutput( "$player_flag_take", playerName ) );
5691
5678
        }
5692
5679
    }
5693
 
}
5694
 
 
 
5680
}
 
5681
 
5695
5682
// *******************************************************************************
5696
5683
// *
5697
5684
// *    OnExit
5703
5690
//!
5704
5691
// *******************************************************************************
5705
5692
 
5706
 
void gFlagZoneHack::OnExit( gCycle * target, REAL time )
5707
 
{
5708
 
    if ((sg_flagPassMode > gFLAGPASS_DISABLE) && passingTheFlag_ && !passerOwnerFree_)
5709
 
    {
5710
 
        if (passerOwner_ == target)
5711
 
            passerOwnerFree_ = true;
5712
 
    }
 
5693
void gFlagZoneHack::OnExit( gCycle * target, REAL time )
 
5694
{
 
5695
    if ((sg_flagPassMode > gFLAGPASS_DISABLE) && passingTheFlag_ && !passerOwnerFree_)
 
5696
    {
 
5697
        if (passerOwner_ == target)
 
5698
            passerOwnerFree_ = true;
 
5699
    }
5713
5700
}
5714
5701
 
5715
5702
 
5942
5929
ePlayerNetID *gTargetZoneHack::winner_ = 0;
5943
5930
 
5944
5931
static void sg_SetTargetCmd(std::istream &s)
5945
 
{
5946
 
    eGrid *grid = eGrid::CurrentGrid();
5947
 
    if ( !grid )
5948
 
    {
5949
 
        con << "Must be called while a grid exists!\n";
5950
 
        return;
5951
 
    }
 
5932
{
 
5933
    eGrid *grid = eGrid::CurrentGrid();
 
5934
    if ( !grid )
 
5935
    {
 
5936
        con << "Must be called while a grid exists!\n";
 
5937
        return;
 
5938
    }
5952
5939
 
5953
5940
    tString params;
5954
5941
    params.ReadLine( s, true );
5979
5966
        gTargetZoneHack *zone=dynamic_cast<gTargetZoneHack *>(gameObjects(zone_id));
5980
5967
        if (zone)
5981
5968
        {
5982
 
            if (event_str == "onenter")
 
5969
            if (event_str == "onenter")
5983
5970
            {
5984
5971
                zone->SetOnEnterCmd(cmd_str, mode_str);
5985
5972
                con << "Zone " << zone->GOID() << " command onenter '" << cmd_str << "'\n";
5986
 
            }
5987
 
            else if (event_str == "onvanish")
 
5973
            }
 
5974
            else if (event_str == "onvanish")
5988
5975
            {
5989
5976
                zone->SetOnVanishCmd(cmd_str, mode_str);
5990
5977
                con << "Zone " << zone->GOID() << " command onvanish '" << cmd_str << "'\n";
5991
 
            }
5992
 
            else if (event_str == "onexit")
5993
 
            {
 
5978
            }
 
5979
            else if (event_str == "onexit")
 
5980
            {
5994
5981
                zone->SetOnExitCmd(cmd_str, mode_str);
5995
 
                con << "Zone " << zone->GOID() << " command onexit '" << cmd_str << "'\n";
 
5982
                con << "Zone " << zone->GOID() << " command onexit '" << cmd_str << "'\n";
5996
5983
            }
5997
5984
            zone_id=gZone::FindNext(object_id_str, zone_id);
5998
5985
        }
6010
5997
//!     @param  grid Grid to put the zone into
6011
5998
//!     @param  pos  Position to spawn the zone at
6012
5999
//!
6013
 
// *******************************************************************************
6014
 
 
6015
 
//  target zone color settings
6016
 
REAL sg_targetZoneColorR = 0;
6017
 
REAL sg_targetZoneColorG = 15;
6018
 
REAL sg_targetZoneColorB = 0;
6019
 
static tSettingItem<REAL> sg_targetZoneColorRConf("TARGETZONE_COLOR_R", sg_targetZoneColorR);
6020
 
static tSettingItem<REAL> sg_targetZoneColorGConf("TARGETZONE_COLOR_G", sg_targetZoneColorG);
 
6000
// *******************************************************************************
 
6001
 
 
6002
//  target zone color settings
 
6003
REAL sg_targetZoneColorR = 0;
 
6004
REAL sg_targetZoneColorG = 15;
 
6005
REAL sg_targetZoneColorB = 0;
 
6006
static tSettingItem<REAL> sg_targetZoneColorRConf("TARGETZONE_COLOR_R", sg_targetZoneColorR);
 
6007
static tSettingItem<REAL> sg_targetZoneColorGConf("TARGETZONE_COLOR_G", sg_targetZoneColorG);
6021
6008
static tSettingItem<REAL> sg_targetZoneColorBConf("TARGETZONE_COLOR_B", sg_targetZoneColorB);
6022
6009
 
6023
6010
gTargetZoneHack::gTargetZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, bool delayCreation)
6025
6012
{
6026
6013
    //color_.r = 0.0f;
6027
6014
    //color_.g = 1.0f;
6028
 
    //color_.b = 0.0f;
6029
 
 
6030
 
    color_.r = sg_targetZoneColorR / 15.0f;
6031
 
    color_.g = sg_targetZoneColorG / 15.0f;
 
6015
    //color_.b = 0.0f;
 
6016
 
 
6017
    color_.r = sg_targetZoneColorR / 15.0f;
 
6018
    color_.g = sg_targetZoneColorG / 15.0f;
6032
6019
    color_.b = sg_targetZoneColorB / 15.0f;
6033
6020
 
6034
6021
    TargetZoneCounter_++;
6042
6029
    targetEmptyTime_ = -1.0;
6043
6030
    currentState_ = State_Safe;
6044
6031
    for(int i=0; i<MAXCLIENTS; i++) playersFlags[i] = 0;
6045
 
 
 
6032
 
6046
6033
    if (!delayCreation)
6047
6034
        grid->AddGameObjectInteresting(this);
6048
6035
 
6199
6186
        (currentState_ == State_Conquered))
6200
6187
    {
6201
6188
        return;
6202
 
    }
6203
 
 
6204
 
    // RACE HACK begin
6205
 
    if ( sg_RaceTimerEnabled )
6206
 
    {
6207
 
        gRace::ZoneHit( target->Player(), time );
6208
 
    }
6209
 
    // RACE HACK end
 
6189
    }
 
6190
 
 
6191
    // RACE HACK begin
 
6192
    if ( sg_RaceTimerEnabled )
 
6193
    {
 
6194
        gRace::ZoneHit( target->Player(), time );
 
6195
    }
 
6196
    // RACE HACK end
6210
6197
 
6211
6198
    // keep first player in memory, if it's the last zone, he is the winner ...
6212
6199
    if (!firstPlayer_)
6245
6232
            zoneScore_=0;
6246
6233
            targetEmptyTime_=time;
6247
6234
        }
6248
 
    }
 
6235
    }
6249
6236
 
6250
6237
    // message in edlog
6251
6238
    if (playersFlags[target->Player()->ListID()] != 2)
6254
6241
        sg_targetzonePlayerEnterWriter.write();
6255
6242
        playersFlags[target->Player()->ListID()] = 2;
6256
6243
    }
6257
 
}
6258
 
 
 
6244
}
 
6245
 
6259
6246
// *******************************************************************************
6260
6247
// *
6261
6248
// *    OnExit
6262
6249
// *
6263
 
// *******************************************************************************
 
6250
// *******************************************************************************
6264
6251
//!
6265
6252
//!     @param  target  the cycle that has left the zone
6266
6253
//!     @param  time    the current time
6267
6254
//!
6268
 
// *******************************************************************************
6269
 
 
6270
 
static eLadderLogWriter sg_targetzonePlayerLeftWriter("TARGETZONE_PLAYER_LEFT", false);
6271
 
 
6272
 
void gTargetZoneHack::OnExit(gCycle *target, REAL time)
6273
 
{
6274
 
    //send on exit commands
6275
 
    std::istringstream stream(&OnExitCmd(0));
6276
 
    tCurrentAccessLevel elevator( sg_SetTargetCmd_conf.GetRequiredLevel(), true );
6277
 
    tConfItemBase::LoadAll(stream);
6278
 
 
 
6255
// *******************************************************************************
 
6256
 
 
6257
static eLadderLogWriter sg_targetzonePlayerLeftWriter("TARGETZONE_PLAYER_LEFT", false);
 
6258
 
 
6259
void gTargetZoneHack::OnExit(gCycle *target, REAL time)
 
6260
{
 
6261
    //send on exit commands
 
6262
    std::istringstream stream(&OnExitCmd(0));
 
6263
    tCurrentAccessLevel elevator( sg_SetTargetCmd_conf.GetRequiredLevel(), true );
 
6264
    tConfItemBase::LoadAll(stream);
 
6265
 
6279
6266
    sg_targetzonePlayerLeftWriter << this->GOID() << name_ << MapPosition().x << MapPosition().y << target->Player()->GetUserName() << target->Player()->Object()->MapPosition().x << target->Player()->Object()->MapPosition().y << target->Player()->Object()->MapDirection().x << target->Player()->Object()->MapDirection().y << time;
6280
 
    sg_targetzonePlayerLeftWriter.write();
6281
 
 
6282
 
    if (playersFlags[target->Player()->ListID()])
6283
 
        playersFlags[target->Player()->ListID()] = 0;
6284
 
 
6285
 
    // RACE HACK begin
6286
 
    if ( sg_RaceTimerEnabled )
6287
 
    {
6288
 
        gRace::ZoneOut( target->Player(), time );
6289
 
    }
6290
 
    // RACE HACK end
 
6267
    sg_targetzonePlayerLeftWriter.write();
 
6268
 
 
6269
    if (playersFlags[target->Player()->ListID()])
 
6270
        playersFlags[target->Player()->ListID()] = 0;
 
6271
 
 
6272
    // RACE HACK begin
 
6273
    if ( sg_RaceTimerEnabled )
 
6274
    {
 
6275
        gRace::ZoneOut( target->Player(), time );
 
6276
    }
 
6277
    // RACE HACK end
6291
6278
}
6292
6279
 
6293
6280
// *******************************************************************************
6312
6299
        sg_DeclareWinner( firstPlayer_->CurrentTeam(), message );
6313
6300
    }
6314
6301
    // decrement target zone counter
6315
 
    TargetZoneCounter_--;
6316
 
 
 
6302
    TargetZoneCounter_--;
 
6303
 
6317
6304
    grid->RemoveGameObjectInteresting(this);
6318
6305
}
6319
6306
 
6352
6339
 
6353
6340
    PlayersInside_=0;
6354
6341
    EnteredTime_ = -1;
6355
 
    owner_=NULL;
6356
 
 
 
6342
    owner_=NULL;
 
6343
 
6357
6344
    if (!delayCreation)
6358
6345
        grid->AddGameObjectInteresting(this);
6359
6346
 
6568
6555
    color_.r = 0.0f;
6569
6556
    color_.g = 1.0f;
6570
6557
    color_.b = 0.0f;
6571
 
 
 
6558
 
6572
6559
    if (!delayCreation)
6573
6560
        grid->AddGameObjectInteresting(this);
6574
6561
 
6673
6660
// *******************************************************************************
6674
6661
 
6675
6662
void gTeleportZoneHack::OnVanish( void )
6676
 
{
 
6663
{
6677
6664
    grid->RemoveGameObjectInteresting(this);
6678
6665
}
6679
6666
 
6695
6682
    color_.r = 0.0f;
6696
6683
    color_.g = 0.5f;
6697
6684
    color_.b = 1.0f;
6698
 
 
 
6685
 
6699
6686
    if (!delayCreation)
6700
6687
        grid->AddGameObjectInteresting(this);
6701
6688
 
6764
6751
//!     @param  target  the cycle that has been found inside the zone
6765
6752
//!     @param  time    the current time
6766
6753
//!
6767
 
// *******************************************************************************
6768
 
 
6769
 
static int sg_BlastZoneScore = -1;
6770
 
static tSettingItem<int> sg_BlastZoneScoreConf("SCORE_BLASTZONE", sg_BlastZoneScore);
 
6754
// *******************************************************************************
 
6755
 
 
6756
static int sg_BlastZoneScore = -1;
 
6757
static tSettingItem<int> sg_BlastZoneScoreConf("SCORE_BLASTZONE", sg_BlastZoneScore);
6771
6758
static eLadderLogWriter sg_deathDeathBlastZoneWriter("BLASTZONE_PLAYER_ENTER", false);
6772
6759
 
6773
6760
void gBlastZoneHack::OnEnter( gCycle * target, REAL time )
6774
6761
{
6775
 
    target->SetWallBuilding(false);
6776
 
    target->Player()->Object()->Kill();
6777
 
 
 
6762
    target->SetWallBuilding(false);
 
6763
    target->Player()->Object()->Kill();
 
6764
 
6778
6765
    tOutput lose;
6779
 
    lose << "$player_blastzone_score";
6780
 
    target->Player()->AddScore( sg_BlastZoneScore, "", lose);
6781
 
 
6782
 
    sg_deathDeathBlastZoneWriter << target->Player()->GetUserName();
 
6766
    lose << "$player_blastzone_score";
 
6767
    target->Player()->AddScore( sg_BlastZoneScore, "", lose);
 
6768
 
 
6769
    sg_deathDeathBlastZoneWriter << target->Player()->GetUserName();
6783
6770
    sg_deathDeathBlastZoneWriter.write();
6784
6771
}
6785
6772
 
6791
6778
// *******************************************************************************
6792
6779
 
6793
6780
void gBlastZoneHack::OnVanish( void )
6794
 
{
 
6781
{
6795
6782
    grid->RemoveGameObjectInteresting(this);
6796
6783
}
6797
 
 
 
6784
 
6798
6785
// *******************************************************************************
6799
6786
// *
6800
6787
// *    gSpeedZoneHack
6812
6799
    color_.r = 0.0f;
6813
6800
    color_.g = 1.5f;
6814
6801
    color_.b = 1.0f;
6815
 
 
 
6802
 
6816
6803
    if (!delayCreation)
6817
6804
        grid->AddGameObjectInteresting(this);
6818
6805
 
6881
6868
//!     @param  target  the cycle that has been found inside the zone
6882
6869
//!     @param  time    the current time
6883
6870
//!
6884
 
// *******************************************************************************
6885
 
 
 
6871
// *******************************************************************************
 
6872
 
6886
6873
void gSpeedZoneHack::OnEnter( gCycle * target, REAL time )
6887
6874
{
6888
 
    if (speedType_ == TYPE_ACCEL)
6889
 
    {
6890
 
        target->verletSpeed_ += setSpeed_;
6891
 
    }
6892
 
    else if (speedType_ == TYPE_SPEED)
6893
 
    {
6894
 
        target->verletSpeed_ = setSpeed_;
 
6875
    if (speedType_ == TYPE_ACCEL)
 
6876
    {
 
6877
        target->verletSpeed_ += setSpeed_;
 
6878
    }
 
6879
    else if (speedType_ == TYPE_SPEED)
 
6880
    {
 
6881
        target->verletSpeed_ = setSpeed_;
6895
6882
    }
6896
6883
}
6897
6884
 
6902
6889
// *******************************************************************************
6903
6890
 
6904
6891
void gSpeedZoneHack::OnVanish( void )
6905
 
{
 
6892
{
6906
6893
    grid->RemoveGameObjectInteresting(this);
6907
6894
}
6908
6895
 
6923
6910
    color_.r = 1.0f;
6924
6911
    color_.g = 0.0f;
6925
6912
    color_.b = 0.5f;
6926
 
 
 
6913
 
6927
6914
    if (!delayCreation)
6928
 
        grid->AddGameObjectInteresting(this);
6929
 
 
 
6915
        grid->AddGameObjectInteresting(this);
 
6916
 
6930
6917
    seekSpeed_ = 1.0;
6931
6918
 
6932
6919
    SetExpansionSpeed(0);
6979
6966
bool gObjectZoneHack::Timestep( REAL time )
6980
6967
{
6981
6968
    // delegate
6982
 
    bool returnStatus = gZone::Timestep( time );
6983
 
 
 
6969
    bool returnStatus = gZone::Timestep( time );
 
6970
 
6984
6971
    if (seeking_)
6985
6972
    {
6986
6973
        //Only run this every poll time to save on network traffic
7013
7000
//!     @param  target  the cycle that has been found inside the zone
7014
7001
//!     @param  time    the current time
7015
7002
//!
7016
 
// *******************************************************************************
7017
 
 
7018
 
static eLadderLogWriter sg_objectZonePlayerEntered("OBJECTZONE_PLAYER_ENTERED", false);
7019
 
static eLadderLogWriter sg_objectZoneZoneEntered("OBJECTZONE_ZONE_ENTERED", false);
 
7003
// *******************************************************************************
 
7004
 
 
7005
static eLadderLogWriter sg_objectZonePlayerEntered("OBJECTZONE_PLAYER_ENTERED", false);
 
7006
static eLadderLogWriter sg_objectZoneZoneEntered("OBJECTZONE_ZONE_ENTERED", false);
7020
7007
void gObjectZoneHack::OnEnter( gCycle * target, REAL time )
7021
 
{
7022
 
    ePlayerNetID *p = target->Player();
7023
 
    if (p)
7024
 
    {
7025
 
        sg_objectZonePlayerEntered << GOID() << name_ << MapPosition().x << MapPosition().y << p->GetUserName() << target->MapPosition().x << target->MapPosition().y << target->MapDirection().x << target->MapDirection().y << time;
7026
 
        sg_objectZonePlayerEntered.write();
7027
 
    }
7028
 
}
7029
 
 
7030
 
//  for when zones enter this object zone
7031
 
void gObjectZoneHack::OnEnter(gZone *target, REAL time)
7032
 
{
7033
 
    if (target && !target->destroyed_)
7034
 
    {
7035
 
        sg_objectZoneZoneEntered << GOID() << name_ << MapPosition().x << MapPosition().y << target->GOID() << target->GetName() << target->MapPosition().x << target->MapPosition().y << target->GetVelocity().x << target->GetVelocity().y << time;
7036
 
        sg_objectZoneZoneEntered.write();
7037
 
    }
7038
 
}
7039
 
 
7040
 
static eLadderLogWriter sg_ObjectZoneSpawned("OBJECTZONE_SPAWNED", false);
7041
 
 
7042
 
static void sg_SpawnObjectZone(std::istream &s)
7043
 
{
 
7008
{
 
7009
    ePlayerNetID *p = target->Player();
 
7010
    if (p)
 
7011
    {
 
7012
        sg_objectZonePlayerEntered << GOID() << name_ << MapPosition().x << MapPosition().y << p->GetUserName() << target->MapPosition().x << target->MapPosition().y << target->MapDirection().x << target->MapDirection().y << time;
 
7013
        sg_objectZonePlayerEntered.write();
 
7014
    }
 
7015
}
 
7016
 
 
7017
//  for when zones enter this object zone
 
7018
void gObjectZoneHack::OnEnter(gZone *target, REAL time)
 
7019
{
 
7020
    if (target && !target->destroyed_)
 
7021
    {
 
7022
        sg_objectZoneZoneEntered << GOID() << name_ << MapPosition().x << MapPosition().y << target->GOID() << target->GetName() << target->MapPosition().x << target->MapPosition().y << target->GetVelocity().x << target->GetVelocity().y << time;
 
7023
        sg_objectZoneZoneEntered.write();
 
7024
    }
 
7025
}
 
7026
 
 
7027
static eLadderLogWriter sg_ObjectZoneSpawned("OBJECTZONE_SPAWNED", false);
 
7028
 
 
7029
static void sg_SpawnObjectZone(std::istream &s)
 
7030
{
7044
7031
    eGrid *grid = eGrid::CurrentGrid();
7045
 
    if(!grid)
7046
 
        return;
7047
 
 
7048
 
    tString params;
7049
 
    params.ReadLine(s, true);
7050
 
 
7051
 
    gObjectZoneHack *Zone = NULL;
7052
 
 
7053
 
    if (params.Filter() == "")
7054
 
    {
7055
 
        goto usage;
7056
 
        return;
7057
 
    }
7058
 
    else
7059
 
    {
7060
 
        float sizeMultiplier = gArena::SizeMultiplier();
7061
 
        float radius, growth;
7062
 
        tString name;
7063
 
        std::vector<eCoord> route;
7064
 
        int pos = 0;
7065
 
 
7066
 
        name = params.ExtractNonBlankSubString(pos);
7067
 
 
 
7032
    if(!grid)
 
7033
        return;
 
7034
 
 
7035
    tString params;
 
7036
    params.ReadLine(s, true);
 
7037
 
 
7038
    gObjectZoneHack *Zone = NULL;
 
7039
 
 
7040
    if (params.Filter() == "")
 
7041
    {
 
7042
        goto usage;
 
7043
        return;
 
7044
    }
 
7045
    else
 
7046
    {
 
7047
        float sizeMultiplier = gArena::SizeMultiplier();
 
7048
        float radius, growth;
 
7049
        tString name;
 
7050
        std::vector<eCoord> route;
 
7051
        int pos = 0;
 
7052
 
 
7053
        name = params.ExtractNonBlankSubString(pos);
 
7054
 
7068
7055
        tString zonePosXStr;
7069
 
        tString zonePosYStr;
7070
 
 
7071
 
        if (name.ToLower() == "n")
7072
 
        {
7073
 
            name = params.ExtractNonBlankSubString(pos);
7074
 
            zonePosXStr = params.ExtractNonBlankSubString(pos);
7075
 
        }
7076
 
        else
7077
 
        {
7078
 
            zonePosXStr = name;
7079
 
            name  = "";
7080
 
        }
 
7056
        tString zonePosYStr;
 
7057
 
 
7058
        if (name.ToLower() == "n")
 
7059
        {
 
7060
            name = params.ExtractNonBlankSubString(pos);
 
7061
            zonePosXStr = params.ExtractNonBlankSubString(pos);
 
7062
        }
 
7063
        else
 
7064
        {
 
7065
            zonePosXStr = name;
 
7066
            name  = "";
 
7067
        }
7081
7068
 
7082
7069
        //  handle x position and get y position
7083
7070
        if(zonePosXStr == "L")
7094
7081
        else
7095
7082
        {
7096
7083
            zonePosYStr = params.ExtractNonBlankSubString(pos);
7097
 
        }
7098
 
 
 
7084
        }
 
7085
 
7099
7086
        tString zoneSizeStr       = params.ExtractNonBlankSubString(pos);
7100
7087
        tString zoneGrowthStr     = params.ExtractNonBlankSubString(pos);
7101
7088
        tString zoneDirXStr       = params.ExtractNonBlankSubString(pos);
7102
 
        tString zoneDirYStr       = params.ExtractNonBlankSubString(pos);
 
7089
        tString zoneDirYStr       = params.ExtractNonBlankSubString(pos);
7103
7090
        tString zoneInteractive   = params.ExtractNonBlankSubString(pos);
7104
7091
        tString zoneRedStr        = params.ExtractNonBlankSubString(pos);
7105
7092
        tString zoneGreenStr      = params.ExtractNonBlankSubString(pos);
7106
7093
        tString zoneBlueStr       = params.ExtractNonBlankSubString(pos);
7107
 
        tString targetRadiusStr   = params.ExtractNonBlankSubString(pos);
7108
 
        tString seekOwnerStr      = params.ExtractNonBlankSubString(pos);
7109
 
        tString seekSpeedStr      = params.ExtractNonBlankSubString(pos);
7110
 
        tString seekUpdateTimeStr = params.ExtractNonBlankSubString(pos);
7111
 
 
 
7094
        tString targetRadiusStr   = params.ExtractNonBlankSubString(pos);
 
7095
        tString seekOwnerStr      = params.ExtractNonBlankSubString(pos);
 
7096
        tString seekSpeedStr      = params.ExtractNonBlankSubString(pos);
 
7097
        tString seekUpdateTimeStr = params.ExtractNonBlankSubString(pos);
 
7098
 
7112
7099
        eCoord zonePos    = route.empty() ? eCoord(atof(zonePosXStr)*sizeMultiplier,atof(zonePosYStr)*sizeMultiplier) : route.front();
7113
7100
        REAL zoneSize     = atof(zoneSizeStr)*sizeMultiplier;
7114
 
        REAL zoneGrowth   = atof(zoneGrowthStr)*sizeMultiplier;
7115
 
 
 
7101
        REAL zoneGrowth   = atof(zoneGrowthStr)*sizeMultiplier;
 
7102
 
7116
7103
        eCoord zoneDir = eCoord(atof(zoneDirXStr)*sizeMultiplier,atof(zoneDirYStr)*sizeMultiplier);
7117
7104
        gRealColor zoneColor;
7118
7105
        bool setColorFlag = false;
7119
7106
        if ((zoneRedStr.Filter() != "") && (zoneGreenStr.Filter() != "") && (zoneBlueStr.Filter() != ""))
7120
7107
        {
7121
 
            if (zoneRedStr == "r_rand")
7122
 
            {
7123
 
                tRandomizer &randomizer = tRandomizer::GetInstance();
7124
 
                zoneColor.r = randomizer.Get(0, 15.0) / 15.0;
7125
 
            }
7126
 
            else
7127
 
            {
7128
 
                zoneColor.r = atof(zoneRedStr) / 15.0;
7129
 
            }
7130
 
 
7131
 
            if (zoneGreenStr == "g_rand")
7132
 
            {
7133
 
                tRandomizer &randomizer = tRandomizer::GetInstance();
7134
 
                zoneColor.g = randomizer.Get(0, 15.0) / 15.0;
7135
 
            }
7136
 
            else
7137
 
            {
7138
 
                zoneColor.g = atof(zoneGreenStr) / 15.0;
7139
 
            }
7140
 
 
7141
 
            if (zoneBlueStr == "b_rand")
7142
 
            {
7143
 
                tRandomizer &randomizer = tRandomizer::GetInstance();
7144
 
                zoneColor.b = randomizer.Get(0, 15.0) / 15.0;
7145
 
            }
7146
 
            else
7147
 
            {
7148
 
                zoneColor.b = atof(zoneBlueStr) / 15.0;
 
7108
            if (zoneRedStr == "r_rand")
 
7109
            {
 
7110
                tRandomizer &randomizer = tRandomizer::GetInstance();
 
7111
                zoneColor.r = randomizer.Get(0, 15.0) / 15.0;
 
7112
            }
 
7113
            else
 
7114
            {
 
7115
                zoneColor.r = atof(zoneRedStr) / 15.0;
 
7116
            }
 
7117
 
 
7118
            if (zoneGreenStr == "g_rand")
 
7119
            {
 
7120
                tRandomizer &randomizer = tRandomizer::GetInstance();
 
7121
                zoneColor.g = randomizer.Get(0, 15.0) / 15.0;
 
7122
            }
 
7123
            else
 
7124
            {
 
7125
                zoneColor.g = atof(zoneGreenStr) / 15.0;
 
7126
            }
 
7127
 
 
7128
            if (zoneBlueStr == "b_rand")
 
7129
            {
 
7130
                tRandomizer &randomizer = tRandomizer::GetInstance();
 
7131
                zoneColor.b = randomizer.Get(0, 15.0) / 15.0;
 
7132
            }
 
7133
            else
 
7134
            {
 
7135
                zoneColor.b = atof(zoneBlueStr) / 15.0;
7149
7136
            }
7150
7137
            setColorFlag = true;
7151
 
        }
7152
 
 
 
7138
        }
 
7139
 
7153
7140
        bool zoneInteractiveBool = false;
7154
7141
        if (zoneInteractive.ToLower() == "true")
7155
 
            zoneInteractiveBool = true;
7156
 
 
7157
 
        Zone = tNEW(gObjectZoneHack(grid, zonePos, true));
7158
 
        Zone->SetRadius(zoneSize);
7159
 
        Zone->SetExpansionSpeed(zoneGrowth);
7160
 
        Zone->SetVelocity(zoneDir);
7161
 
 
 
7142
            zoneInteractiveBool = true;
 
7143
 
 
7144
        Zone = tNEW(gObjectZoneHack(grid, zonePos, true));
 
7145
        Zone->SetRadius(zoneSize);
 
7146
        Zone->SetExpansionSpeed(zoneGrowth);
 
7147
        Zone->SetVelocity(zoneDir);
 
7148
 
7162
7149
        if (setColorFlag)
7163
7150
        {
7164
7151
            zoneColor.r = (zoneColor.r>1.0)?1.0:zoneColor.r;
7165
7152
            zoneColor.g = (zoneColor.g>1.0)?1.0:zoneColor.g;
7166
7153
            zoneColor.b = (zoneColor.b>1.0)?1.0:zoneColor.b;
7167
7154
            Zone->SetColor(zoneColor);
7168
 
        }
7169
 
 
7170
 
        if (zoneInteractiveBool)
7171
 
        {
7172
 
            Zone->SetWallBouncesLeft(-1);
7173
 
            Zone->SetWallInteract(zoneInteractiveBool);
7174
 
        }
7175
 
 
7176
 
        REAL targetRadius = atof(targetRadiusStr)*sizeMultiplier;
7177
 
        if(targetRadius != 0)
7178
 
            Zone->SetTargetRadius(targetRadius);
7179
 
 
7180
 
        if (seekOwnerStr.Filter() != "")
7181
 
        {
7182
 
            ePlayerNetID *seekOwnerPlayer = ePlayerNetID::FindPlayerByName(seekOwnerStr);
7183
 
            if (seekOwnerPlayer && seekOwnerPlayer->Object() && seekOwnerPlayer->Object()->Alive())
7184
 
                Zone->SetSeekingCycle(dynamic_cast<gCycle *>(seekOwnerPlayer->Object()));
7185
 
        }
7186
 
 
7187
 
        REAL seekSpeed = atof(seekSpeedStr);
7188
 
        if (seekSpeed >= 0)
7189
 
            Zone->SetSeekSpeed(seekSpeed);
7190
 
        else
7191
 
            Zone->SetSeekSpeed(1.0);
7192
 
 
7193
 
        REAL seekingUpdateTime = atof(seekUpdateTimeStr);
7194
 
        if (seekingUpdateTime >= 0)
7195
 
            Zone->SetSeekUpdate(seekingUpdateTime);
7196
 
        else
7197
 
            Zone->SetSeekUpdate(0.5);
7198
 
 
 
7155
        }
 
7156
 
 
7157
        if (zoneInteractiveBool)
 
7158
        {
 
7159
            Zone->SetWallBouncesLeft(-1);
 
7160
            Zone->SetWallInteract(zoneInteractiveBool);
 
7161
        }
 
7162
 
 
7163
        REAL targetRadius = atof(targetRadiusStr)*sizeMultiplier;
 
7164
        if(targetRadius != 0)
 
7165
            Zone->SetTargetRadius(targetRadius);
 
7166
 
 
7167
        if (seekOwnerStr.Filter() != "")
 
7168
        {
 
7169
            ePlayerNetID *seekOwnerPlayer = ePlayerNetID::FindPlayerByName(seekOwnerStr);
 
7170
            if (seekOwnerPlayer && seekOwnerPlayer->Object() && seekOwnerPlayer->Object()->Alive())
 
7171
                Zone->SetSeekingCycle(dynamic_cast<gCycle *>(seekOwnerPlayer->Object()));
 
7172
        }
 
7173
 
 
7174
        REAL seekSpeed = atof(seekSpeedStr);
 
7175
        if (seekSpeed >= 0)
 
7176
            Zone->SetSeekSpeed(seekSpeed);
 
7177
        else
 
7178
            Zone->SetSeekSpeed(1.0);
 
7179
 
 
7180
        REAL seekingUpdateTime = atof(seekUpdateTimeStr);
 
7181
        if (seekingUpdateTime >= 0)
 
7182
            Zone->SetSeekUpdate(seekingUpdateTime);
 
7183
        else
 
7184
            Zone->SetSeekUpdate(0.5);
 
7185
 
7199
7186
        Zone->SetReferenceTime();
7200
 
        Zone->SetRotationSpeed( .3f );
 
7187
        Zone->SetRotationSpeed( .3f );
7201
7188
 
7202
7189
        if(!route.empty())
7203
7190
        {
7207
7194
                Zone->AddWaypoint(*iter);
7208
7195
            }
7209
7196
        }
7210
 
        Zone->SetName(name);
 
7197
        Zone->SetName(name);
7211
7198
        Zone->SetEffect(tString("object"));
7212
 
        Zone->RequestSync();
7213
 
 
7214
 
#ifdef DEBUG
7215
 
        con << Zone->GetEffect() << " " << Zone->GOID() << " " << Zone->GetName() << " " << Zone->MapPosition().x << " " << Zone->MapPosition().y << " " << Zone->GetVelocity().x << " " << Zone->GetVelocity().y << " " << (Zone->GetWallInteract()?"true":"false") << " " << Zone->GetColor().r << " " << Zone->GetColor().g << " " << Zone->GetColor().b << "\n";
7216
 
#endif
7217
 
 
7218
 
        sg_ObjectZoneSpawned << Zone->GOID() << Zone->GetName() << Zone->MapPosition().x << Zone->MapPosition().y << Zone->GetVelocity().x << Zone->GetVelocity().y << se_GameTime();
7219
 
        sg_ObjectZoneSpawned.write();
7220
 
 
7221
 
        return;
7222
 
    }
7223
 
 
7224
 
    usage:
7225
 
    {
7226
 
        tString usageMem;
7227
 
        ePlayerNetID *rec = 0;  //  get the caller to send the message
7228
 
 
 
7199
        Zone->RequestSync();
 
7200
 
 
7201
#ifdef DEBUG
 
7202
        con << Zone->GetEffect() << " " << Zone->GOID() << " " << Zone->GetName() << " " << Zone->MapPosition().x << " " << Zone->MapPosition().y << " " << Zone->GetVelocity().x << " " << Zone->GetVelocity().y << " " << (Zone->GetWallInteract()?"true":"false") << " " << Zone->GetColor().r << " " << Zone->GetColor().g << " " << Zone->GetColor().b << "\n";
 
7203
#endif
 
7204
 
 
7205
        sg_ObjectZoneSpawned << Zone->GOID() << Zone->GetName() << Zone->MapPosition().x << Zone->MapPosition().y << Zone->GetVelocity().x << Zone->GetVelocity().y << se_GameTime();
 
7206
        sg_ObjectZoneSpawned.write();
 
7207
 
 
7208
        return;
 
7209
    }
 
7210
 
 
7211
    usage:
 
7212
    {
 
7213
        tString usageMem;
 
7214
        ePlayerNetID *rec = 0;  //  get the caller to send the message
 
7215
 
7229
7216
        usageMem << "Usage:\n"
7230
7217
                    "SPAWN_OBJECTZONE <x> <y> <size> <growth> <xdir> <ydir> <interactive> <r> <g> <b> <target_size> <seek_owner> <seek_speed> <seek_update_time>\n"
7231
 
                    "Instead of <x> <y> one can write: L <x1> <y1> <x2> <y2> [...] Z\n"
7232
 
                    "To give the zone a name, SPAWN_OBJECTZONE n <name> ...\n";
7233
 
 
7234
 
        sn_ConsoleOut(usageMem, rec->Owner());
7235
 
    }
7236
 
}
7237
 
static tConfItemFunc sg_SpawnObjectZoneConf("SPAWN_OBJECTZONE", &sg_SpawnObjectZone);
7238
 
 
 
7218
                    "Instead of <x> <y> one can write: L <x1> <y1> <x2> <y2> [...] Z\n"
 
7219
                    "To give the zone a name, SPAWN_OBJECTZONE n <name> ...\n";
 
7220
 
 
7221
        sn_ConsoleOut(usageMem, rec->Owner());
 
7222
    }
 
7223
}
 
7224
static tConfItemFunc sg_SpawnObjectZoneConf("SPAWN_OBJECTZONE", &sg_SpawnObjectZone);
 
7225
 
7239
7226
// *******************************************************************************
7240
7227
// *
7241
7228
// *    OnExit
7242
7229
// *
7243
 
// *******************************************************************************
 
7230
// *******************************************************************************
7244
7231
//!
7245
7232
//!     @param  target  the cycle that has left the zone
7246
7233
//!     @param  time    the current time
7247
7234
//!
7248
 
// *******************************************************************************
7249
 
 
7250
 
static eLadderLogWriter sg_objectZonePlayerLeft("OBJECTZONE_PLAYER_LEFT", false);
 
7235
// *******************************************************************************
 
7236
 
 
7237
static eLadderLogWriter sg_objectZonePlayerLeft("OBJECTZONE_PLAYER_LEFT", false);
7251
7238
void gObjectZoneHack::OnExit( gCycle * target, REAL time )
7252
7239
{
7253
 
    ePlayerNetID *p = target->Player();
7254
 
    if (p)
7255
 
    {
7256
 
        sg_objectZonePlayerLeft << GOID() << name_ << MapPosition().x << MapPosition().y << p->GetUserName() << target->MapPosition().x << target->MapPosition().y << target->Direction().x << target->Direction().y << se_GameTime();
7257
 
        sg_objectZonePlayerLeft.write();
 
7240
    ePlayerNetID *p = target->Player();
 
7241
    if (p)
 
7242
    {
 
7243
        sg_objectZonePlayerLeft << GOID() << name_ << MapPosition().x << MapPosition().y << p->GetUserName() << target->MapPosition().x << target->MapPosition().y << target->Direction().x << target->Direction().y << se_GameTime();
 
7244
        sg_objectZonePlayerLeft.write();
7258
7245
    }
7259
7246
}
7260
7247
 
7265
7252
// *******************************************************************************
7266
7253
 
7267
7254
void gObjectZoneHack::OnVanish( void )
7268
 
{
 
7255
{
7269
7256
    grid->RemoveGameObjectInteresting(this);
7270
 
}
7271
 
 
 
7257
}
 
7258
 
7272
7259
// *******************************************************************************
7273
7260
// *
7274
7261
// *    gSoccerZoneHack::CheckTeamAssignment
7275
7262
// *
7276
 
// *******************************************************************************
7277
 
 
7278
 
bool gSoccerZoneHack::CheckTeamAssignment()
7279
 
{
 
7263
// *******************************************************************************
 
7264
 
 
7265
bool gSoccerZoneHack::CheckTeamAssignment()
 
7266
{
7280
7267
    // find the closest player
7281
7268
    if ( !team )
7282
7269
    {
7294
7281
                eCoord otherpos = other->Position() - Position();
7295
7282
                REAL distance = otherpos.NormSquared();
7296
7283
                if (!closest || (distance < closestDistance))
7297
 
                {
7298
 
                    closest = other;
 
7284
                {
 
7285
                    closest = other;
7299
7286
                    closestDistance = distance;
7300
7287
                }
7301
7288
            }
7319
7306
            return false;
7320
7307
        }
7321
7308
    }
7322
 
    return true;
7323
 
}
7324
 
 
 
7309
    return true;
 
7310
}
 
7311
 
7325
7312
// *******************************************************************************
7326
7313
// *
7327
7314
// *    gSoccerZoneHack
7331
7318
//!     @param  grid Grid to put the zone into
7332
7319
//!     @param  pos  Position to spawn the zone at
7333
7320
//!
7334
 
// *******************************************************************************
7335
 
 
 
7321
// *******************************************************************************
 
7322
 
7336
7323
//  this is for the soccer ball
7337
7324
gSoccerZoneHack::gSoccerZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, bool delayCreation)
7338
7325
:gZone( grid, pos, dynamicCreation, delayCreation)
7339
7326
{
7340
7327
    color_.r = 1.0f;
7341
7328
    color_.g = 0.5f;
7342
 
    color_.b = 0.5f;
7343
 
 
7344
 
    originalPosition_ = pos;
7345
 
    originalVelocity_ = eCoord(0,0);
7346
 
 
7347
 
    init_ = false;
7348
 
    ballShots_ = 0;
7349
 
 
 
7329
    color_.b = 0.5f;
 
7330
 
 
7331
    originalPosition_ = pos;
 
7332
    originalVelocity_ = eCoord(0,0);
 
7333
 
 
7334
    init_ = false;
 
7335
    ballShots_ = 0;
 
7336
 
7350
7337
    teamDistance_ = 0;
7351
 
 
 
7338
 
7352
7339
    if (!delayCreation)
7353
 
        grid->AddGameObjectInteresting(this);
7354
 
 
7355
 
    zoneType = 1;
7356
 
    team = NULL;
7357
 
 
7358
 
    SetWallInteract(true);
7359
 
    SetWallBouncesLeft(-1);
 
7340
        grid->AddGameObjectInteresting(this);
 
7341
 
 
7342
    zoneType = 1;
 
7343
    team = NULL;
 
7344
 
 
7345
    SetWallInteract(true);
 
7346
    SetWallBouncesLeft(-1);
7360
7347
 
7361
7348
    SetExpansionSpeed(0);
7362
7349
    SetRotationSpeed( .3f );
7363
7350
    RequestSync();
7364
 
}
7365
 
 
7366
 
//  this is for the soccer goal
 
7351
}
 
7352
 
 
7353
//  this is for the soccer goal
7367
7354
gSoccerZoneHack::gSoccerZoneHack( eGrid * grid, const eCoord & pos, bool dynamicCreation, eTeam *teamowner, bool delayCreation)
7368
7355
:gZone( grid, pos, dynamicCreation, delayCreation)
7369
7356
{
7370
7357
    color_.r = 1.0f;
7371
7358
    color_.g = 0.5f;
7372
 
    color_.b = 0.5f;
7373
 
 
7374
 
    originalPosition_ = pos;
7375
 
    originalVelocity_ = eCoord(0,0);
7376
 
 
7377
 
    init_ = false;
7378
 
    ballShots_ = 0;
7379
 
 
 
7359
    color_.b = 0.5f;
 
7360
 
 
7361
    originalPosition_ = pos;
 
7362
    originalVelocity_ = eCoord(0,0);
 
7363
 
 
7364
    init_ = false;
 
7365
    ballShots_ = 0;
 
7366
 
7380
7367
    teamDistance_ = 0;
7381
 
 
 
7368
 
7382
7369
    if (!delayCreation)
7383
 
        grid->AddGameObjectInteresting(this);
7384
 
 
7385
 
    if (teamowner)
7386
 
    {
7387
 
        team = teamowner;
7388
 
        color_.r = team->R() / 15;
7389
 
        color_.g = team->G() / 15;
7390
 
        color_.b = team->B() / 15;
7391
 
    }
7392
 
    else
 
7370
        grid->AddGameObjectInteresting(this);
 
7371
 
 
7372
    if (teamowner)
 
7373
    {
 
7374
        team = teamowner;
 
7375
        color_.r = team->R() / 15;
 
7376
        color_.g = team->G() / 15;
 
7377
        color_.b = team->B() / 15;
 
7378
    }
 
7379
    else
7393
7380
        CheckTeamAssignment();
7394
7381
 
7395
7382
    SetExpansionSpeed(0);
7437
7424
//!
7438
7425
//!     @param  time    the current time
7439
7426
//!
7440
 
// *******************************************************************************
7441
 
 
7442
 
bool sg_soccerBallSlowdown = true;
7443
 
static tSettingItem<bool> sg_soccerBallSlowdownConf("SOCCER_BALL_SLOWDOWN", sg_soccerBallSlowdown);
7444
 
 
7445
 
REAL sg_soccerBallSlowdownSpeed = 0.07;
7446
 
bool restrictBallSlowdownSpeed(const REAL &newValue)
7447
 
{
7448
 
    //  if values are less than 0 or greater than 1, no good!
7449
 
    if ((newValue <= 0) || (newValue >= 1))
7450
 
            return false;
7451
 
 
7452
 
    //  if values are in between 0 and 1, good!
7453
 
    return true;
7454
 
}
7455
 
static tSettingItem<REAL> sg_soccerBallSlowdownSpeedConf("SOCCER_BALL_SLOWDOWN_SPEED", sg_soccerBallSlowdownSpeed, &restrictBallSlowdownSpeed);
 
7427
// *******************************************************************************
 
7428
 
 
7429
bool sg_soccerBallSlowdown = true;
 
7430
static tSettingItem<bool> sg_soccerBallSlowdownConf("SOCCER_BALL_SLOWDOWN", sg_soccerBallSlowdown);
 
7431
 
 
7432
REAL sg_soccerBallSlowdownSpeed = 0.07;
 
7433
bool restrictBallSlowdownSpeed(const REAL &newValue)
 
7434
{
 
7435
    //  if values are less than 0 or greater than 1, no good!
 
7436
    if ((newValue <= 0) || (newValue >= 1))
 
7437
            return false;
 
7438
 
 
7439
    //  if values are in between 0 and 1, good!
 
7440
    return true;
 
7441
}
 
7442
static tSettingItem<REAL> sg_soccerBallSlowdownSpeedConf("SOCCER_BALL_SLOWDOWN_SPEED", sg_soccerBallSlowdownSpeed, &restrictBallSlowdownSpeed);
7456
7443
 
7457
7444
bool gSoccerZoneHack::Timestep( REAL time )
7458
7445
{
7459
7446
    // delegate
7460
 
    bool returnStatus = gZone::Timestep( time );
7461
 
 
7462
 
    if ((zoneType == gSoccer_GOAL) && !team)
7463
 
        if (!CheckTeamAssignment()) return true;;
7464
 
 
7465
 
    if (!init_)
7466
 
    {
7467
 
        originalVelocity_ = GetVelocity();
7468
 
 
7469
 
        //  less than 0.1 seconds due to unknown reasons...
7470
 
        //  making sure original radius is found to be greater than 0
7471
 
        if ((time < 0.1) && (GetRadius() > 0))
7472
 
            originalRadius_ = GetRadius();
7473
 
        else
7474
 
            //  installazation success!
7475
 
            init_ = true;
7476
 
    }
7477
 
 
7478
 
    //  for slowing down the soccer ball
7479
 
    if ((zoneType == gSoccer_BALL) && sg_soccerBallSlowdown && (GetVelocity() != eCoord(0,0)))
7480
 
    {
7481
 
        //  store the current speed for setup
7482
 
        eCoord currentVelocity = GetVelocity();
7483
 
 
7484
 
        //  get the values working with decreasing the velocity speed
7485
 
        if (currentVelocity.x < 0)
7486
 
            currentVelocity.x += sg_soccerBallSlowdownSpeed;
7487
 
        else if (currentVelocity.x > 0)
7488
 
            currentVelocity.x -= sg_soccerBallSlowdownSpeed;
7489
 
 
7490
 
        if (currentVelocity.y < 0)
7491
 
            currentVelocity.y += sg_soccerBallSlowdownSpeed;
7492
 
        else if (currentVelocity.y > 0)
7493
 
            currentVelocity.y -= sg_soccerBallSlowdownSpeed;
7494
 
 
7495
 
        if (((currentVelocity.x > -1) && (currentVelocity.x < 0)) || ((currentVelocity.x > 0) && (currentVelocity.x < 1)))
7496
 
            currentVelocity.x = 0;
7497
 
 
7498
 
        if (((currentVelocity.y > -1) && (currentVelocity.y < 0)) || ((currentVelocity.y > 0) && (currentVelocity.y < 1)))
7499
 
            currentVelocity.y = 0;
7500
 
 
7501
 
        //  set new velocity
7502
 
        SetVelocity(currentVelocity);
7503
 
 
7504
 
        //RequestSync();
7505
 
    }
 
7447
    bool returnStatus = gZone::Timestep( time );
 
7448
 
 
7449
    if ((zoneType == gSoccer_GOAL) && !team)
 
7450
        if (!CheckTeamAssignment()) return true;;
 
7451
 
 
7452
    if (!init_)
 
7453
    {
 
7454
        originalVelocity_ = GetVelocity();
 
7455
 
 
7456
        //  less than 0.1 seconds due to unknown reasons...
 
7457
        //  making sure original radius is found to be greater than 0
 
7458
        if ((time < 0.1) && (GetRadius() > 0))
 
7459
            originalRadius_ = GetRadius();
 
7460
        else
 
7461
            //  installazation success!
 
7462
            init_ = true;
 
7463
    }
 
7464
 
 
7465
    //  for slowing down the soccer ball
 
7466
    if ((zoneType == gSoccer_BALL) && sg_soccerBallSlowdown && (GetVelocity() != eCoord(0,0)))
 
7467
    {
 
7468
        //  store the current speed for setup
 
7469
        eCoord currentVelocity = GetVelocity();
 
7470
 
 
7471
        //  get the values working with decreasing the velocity speed
 
7472
        if (currentVelocity.x < 0)
 
7473
            currentVelocity.x += sg_soccerBallSlowdownSpeed;
 
7474
        else if (currentVelocity.x > 0)
 
7475
            currentVelocity.x -= sg_soccerBallSlowdownSpeed;
 
7476
 
 
7477
        if (currentVelocity.y < 0)
 
7478
            currentVelocity.y += sg_soccerBallSlowdownSpeed;
 
7479
        else if (currentVelocity.y > 0)
 
7480
            currentVelocity.y -= sg_soccerBallSlowdownSpeed;
 
7481
 
 
7482
        if (((currentVelocity.x > -1) && (currentVelocity.x < 0)) || ((currentVelocity.x > 0) && (currentVelocity.x < 1)))
 
7483
            currentVelocity.x = 0;
 
7484
 
 
7485
        if (((currentVelocity.y > -1) && (currentVelocity.y < 0)) || ((currentVelocity.y > 0) && (currentVelocity.y < 1)))
 
7486
            currentVelocity.y = 0;
 
7487
 
 
7488
        //  set new velocity
 
7489
        SetVelocity(currentVelocity);
 
7490
 
 
7491
        //RequestSync();
 
7492
    }
7506
7493
 
7507
7494
    return (returnStatus);
7508
 
}
7509
 
 
 
7495
}
 
7496
 
7510
7497
// *******************************************************************************
7511
7498
// *
7512
7499
// *    GoHome
7513
7500
// *
7514
 
// *******************************************************************************
7515
 
 
7516
 
void gSoccerZoneHack::GoHome()
7517
 
{
7518
 
    //  clear last team to hit the soccer ball
7519
 
    lastTeamIn_ = NULL;
7520
 
 
7521
 
    //  send soccer ball back to it's oriignal place on the grid
 
7501
// *******************************************************************************
 
7502
 
 
7503
void gSoccerZoneHack::GoHome()
 
7504
{
 
7505
    //  clear last team to hit the soccer ball
 
7506
    lastTeamIn_ = NULL;
 
7507
 
 
7508
    //  send soccer ball back to it's oriignal place on the grid
7522
7509
    SetReferenceTime();
7523
7510
    SetPosition(originalPosition_);
7524
 
    SetVelocity(originalVelocity_);
 
7511
    SetVelocity(originalVelocity_);
7525
7512
    SetRadius(originalRadius_);
7526
 
    RequestSync();
 
7513
    RequestSync();
7527
7514
}
7528
7515
 
7529
7516
 
7536
7523
//!     @param  target  the cycle that has been found inside the zone
7537
7524
//!     @param  time    the current time
7538
7525
//!
7539
 
// *******************************************************************************
7540
 
 
7541
 
bool sg_soccerGoalKillEnemies = false;
7542
 
static tSettingItem<bool> sg_soccerGoalKillEnemiesConf("SOCCER_GOAL_KILL_ENEMIES", sg_soccerGoalKillEnemies);
7543
 
 
7544
 
bool sg_soccerGoalRespawnAllies = true;
7545
 
static tSettingItem<bool> sg_soccerGoalRespawnAlliesConf("SOCCER_GOAL_RESPAWN_ALLIES", sg_soccerGoalRespawnAllies);
7546
 
 
7547
 
bool sg_soccerGoalRespawnEnemies = true;
7548
 
static tSettingItem<bool> sg_soccerGoalRespawnEnemiesConf("SOCCER_GOAL_RESPAWN_ENEMIES", sg_soccerGoalRespawnEnemies);
7549
 
 
7550
 
static eLadderLogWriter sg_soccerBallPlayerEntered("SOCCER_BALL_PLAYER_ENTERED", false);
7551
 
static eLadderLogWriter sg_soccerGoalPlayerEntered("SOCCER_GOAL_PLAYER_ENTERED", false);
7552
 
 
 
7526
// *******************************************************************************
 
7527
 
 
7528
bool sg_soccerGoalKillEnemies = false;
 
7529
static tSettingItem<bool> sg_soccerGoalKillEnemiesConf("SOCCER_GOAL_KILL_ENEMIES", sg_soccerGoalKillEnemies);
 
7530
 
 
7531
bool sg_soccerGoalRespawnAllies = true;
 
7532
static tSettingItem<bool> sg_soccerGoalRespawnAlliesConf("SOCCER_GOAL_RESPAWN_ALLIES", sg_soccerGoalRespawnAllies);
 
7533
 
 
7534
bool sg_soccerGoalRespawnEnemies = true;
 
7535
static tSettingItem<bool> sg_soccerGoalRespawnEnemiesConf("SOCCER_GOAL_RESPAWN_ENEMIES", sg_soccerGoalRespawnEnemies);
 
7536
 
 
7537
static eLadderLogWriter sg_soccerBallPlayerEntered("SOCCER_BALL_PLAYER_ENTERED", false);
 
7538
static eLadderLogWriter sg_soccerGoalPlayerEntered("SOCCER_GOAL_PLAYER_ENTERED", false);
 
7539
 
7553
7540
void gSoccerZoneHack::OnEnter( gCycle *target, REAL time )
7554
 
{
7555
 
    if (!team && (zoneType == gSoccer_BALL))
7556
 
    {
7557
 
        //  calculate the bounce off. Source: gBallZoneHack
 
7541
{
 
7542
    if (!team && (zoneType == gSoccer_BALL))
 
7543
    {
 
7544
        //  calculate the bounce off. Source: gBallZoneHack
7558
7545
        eCoord p2 = target->Position();
7559
7546
        eCoord v2 = target->Direction()*target->Speed();
7560
7547
 
7592
7579
        base.Normalize();
7593
7580
        eCoord new_v1 = base*-target->Speed();
7594
7581
        eCoord new_p1 = p1c + new_v1*(-t+0.01);
7595
 
        new_v1 = new_v1*(1+sg_ballCycleBoost*target->GetAcceleration()/100);
7596
 
 
7597
 
        SetPosition(new_p1);
7598
 
        SetVelocity(new_v1);
7599
 
 
7600
 
        RequestSync();
7601
 
 
7602
 
        //  set last player to hit the zone
7603
 
        lastTeamIn_ = target->Team();
7604
 
 
7605
 
        sg_soccerBallPlayerEntered << target->Player()->GetUserName() << target->Team()->Name().Filter();
7606
 
        sg_soccerBallPlayerEntered.write();
7607
 
 
7608
 
    }
7609
 
    else if (team && (zoneType == gSoccer_GOAL))
7610
 
    {
7611
 
        if (sg_soccerGoalKillEnemies)
7612
 
        {
7613
 
            if (target && (team != target->Team()))
7614
 
            {
7615
 
                sn_ConsoleOut(tOutput("$soccer_goal_enemy_entered", target->Player()->GetColoredName(), Team()->GetColoredName()));
7616
 
                target->Kill();
7617
 
            }
7618
 
        }
7619
 
        else
7620
 
        {
7621
 
            if (sg_soccerGoalRespawnAllies && (team == target->Team()))
7622
 
            {
7623
 
                gSpawnPoint *pSpawn = Arena.ClosestSpawnPoint(GetPosition());
7624
 
                if (pSpawn)
7625
 
                {
7626
 
                    for(int i = 0; i < Team()->NumPlayers(); i++)
7627
 
                    {
7628
 
                        ePlayerNetID *p = Team()->Player(i);
7629
 
                        if (p)
7630
 
                        {
7631
 
                            gCycle *cycle = dynamic_cast<gCycle *>(p->Object());
7632
 
                            if (!cycle || (!cycle->Alive()))
7633
 
                            {
7634
 
                                eCoord cyclePos, cycleDir;
7635
 
                                pSpawn->Spawn(cyclePos, cycleDir);
7636
 
 
7637
 
                                gCycle *newCycle = new gCycle(Grid(), cyclePos, cycleDir, p);
7638
 
                                p->ControlObject(newCycle);
7639
 
                            }
7640
 
                        }
7641
 
                    }
7642
 
                }
7643
 
            }
7644
 
        }
7645
 
 
7646
 
        sg_soccerGoalPlayerEntered << target->Player()->GetUserName() << target->Team()->Name().Filter() << Team()->Name().Filter();
7647
 
        sg_soccerGoalPlayerEntered.write();
7648
 
    }
7649
 
}
7650
 
 
7651
 
int sg_soccerGoalScore = 1;
7652
 
static tSettingItem<int> sg_soccerGoalScoreConf("SOCCER_GOAL_SCORE", sg_soccerGoalScore);
7653
 
 
7654
 
bool sg_soccerBallFirstWin = false;
7655
 
static tSettingItem<bool> sg_soccerBallFirstWinConf("SOCCER_BALL_FIRST_WIN", sg_soccerBallFirstWin);
7656
 
 
7657
 
int sg_soccerBallShotsWin = 0;
7658
 
static tSettingItem<int> sg_soccerBallShotsWinConf("SOCCER_BALL_SHOTS_WIN", sg_soccerBallShotsWin);
7659
 
 
7660
 
void gSoccerZoneHack::OnEnter( gSoccerZoneHack *target, REAL time )
7661
 
{
7662
 
    //  check if the zone entering the goal is actually a soccer ball
7663
 
    if ((GetType() == gSoccer_GOAL) && (target->GetType() == gSoccer_BALL) && target->lastTeamIn_)
7664
 
    {
7665
 
        if (target->lastTeamIn_ == team)
7666
 
        {
7667
 
            sn_ConsoleOut(tOutput("$soccer_goal_self", Team()->GetColoredName()));
7668
 
 
7669
 
            //  time to return ball to home
7670
 
            target->GoHome();
7671
 
        }
7672
 
        else
7673
 
        {
7674
 
            //  increase the number of times the ball entered other team's goal
7675
 
            target->ballShots_++;
7676
 
 
7677
 
            target->lastTeamIn_->AddScore(sg_soccerGoalScore, tOutput("$soccer_goal_score", target->lastTeamIn_->GetColoredName(), Team()->GetColoredName(), sg_soccerGoalScore), tOutput());
7678
 
            if (sg_soccerBallFirstWin && (target->ballShots_ == 1))
7679
 
            {
7680
 
                sg_DeclareWinner(target->lastTeamIn_, tOutput("$soccer_winner"));
7681
 
 
7682
 
                //  ball must vanish after having a winner
7683
 
                target->Collapse();
7684
 
            }
7685
 
            else if ((sg_soccerBallShotsWin > 0) && (target->ballShots_ >= sg_soccerBallShotsWin))
7686
 
            {
7687
 
                eTeam *thisTeam = team;                     //  the team owner of the goal
7688
 
                eTeam *shotTeam = target->lastTeamIn_;      //  the last team to hit the ball
7689
 
 
7690
 
                if (thisTeam && shotTeam)
7691
 
                {
7692
 
                    //  ensure the team score's are compared
7693
 
                    if (shotTeam->Score() < thisTeam->Score())
7694
 
                        sg_DeclareWinner(thisTeam, tOutput("$soccer_winner"));
7695
 
                    else
7696
 
                        sg_DeclareWinner(shotTeam, tOutput("$soccer_winner"));
7697
 
 
7698
 
                    //  ball must vanish after having a winner
7699
 
                    target->Collapse();
7700
 
                }
7701
 
            }
7702
 
            else
7703
 
            {
7704
 
                //  return soccer ball home
7705
 
                target->GoHome();
7706
 
            }
7707
 
        }
7708
 
    }
 
7582
        new_v1 = new_v1*(1+sg_ballCycleBoost*target->GetAcceleration()/100);
 
7583
 
 
7584
        SetPosition(new_p1);
 
7585
        SetVelocity(new_v1);
 
7586
 
 
7587
        RequestSync();
 
7588
 
 
7589
        //  set last player to hit the zone
 
7590
        lastTeamIn_ = target->Team();
 
7591
 
 
7592
        sg_soccerBallPlayerEntered << target->Player()->GetUserName() << target->Team()->Name().Filter();
 
7593
        sg_soccerBallPlayerEntered.write();
 
7594
 
 
7595
    }
 
7596
    else if (team && (zoneType == gSoccer_GOAL))
 
7597
    {
 
7598
        if (sg_soccerGoalKillEnemies)
 
7599
        {
 
7600
            if (target && (team != target->Team()))
 
7601
            {
 
7602
                sn_ConsoleOut(tOutput("$soccer_goal_enemy_entered", target->Player()->GetColoredName(), Team()->GetColoredName()));
 
7603
                target->Kill();
 
7604
            }
 
7605
        }
 
7606
        else
 
7607
        {
 
7608
            if (sg_soccerGoalRespawnAllies && (team == target->Team()))
 
7609
            {
 
7610
                gSpawnPoint *pSpawn = Arena.ClosestSpawnPoint(GetPosition());
 
7611
                if (pSpawn)
 
7612
                {
 
7613
                    for(int i = 0; i < Team()->NumPlayers(); i++)
 
7614
                    {
 
7615
                        ePlayerNetID *p = Team()->Player(i);
 
7616
                        if (p)
 
7617
                        {
 
7618
                            gCycle *cycle = dynamic_cast<gCycle *>(p->Object());
 
7619
                            if (!cycle || (!cycle->Alive()))
 
7620
                            {
 
7621
                                eCoord cyclePos, cycleDir;
 
7622
                                pSpawn->Spawn(cyclePos, cycleDir);
 
7623
 
 
7624
                                gCycle *newCycle = new gCycle(Grid(), cyclePos, cycleDir, p);
 
7625
                                p->ControlObject(newCycle);
 
7626
                            }
 
7627
                        }
 
7628
                    }
 
7629
                }
 
7630
            }
 
7631
        }
 
7632
 
 
7633
        sg_soccerGoalPlayerEntered << target->Player()->GetUserName() << target->Team()->Name().Filter() << Team()->Name().Filter();
 
7634
        sg_soccerGoalPlayerEntered.write();
 
7635
    }
 
7636
}
 
7637
 
 
7638
int sg_soccerGoalScore = 1;
 
7639
static tSettingItem<int> sg_soccerGoalScoreConf("SOCCER_GOAL_SCORE", sg_soccerGoalScore);
 
7640
 
 
7641
bool sg_soccerBallFirstWin = false;
 
7642
static tSettingItem<bool> sg_soccerBallFirstWinConf("SOCCER_BALL_FIRST_WIN", sg_soccerBallFirstWin);
 
7643
 
 
7644
int sg_soccerBallShotsWin = 0;
 
7645
static tSettingItem<int> sg_soccerBallShotsWinConf("SOCCER_BALL_SHOTS_WIN", sg_soccerBallShotsWin);
 
7646
 
 
7647
void gSoccerZoneHack::OnEnter( gSoccerZoneHack *target, REAL time )
 
7648
{
 
7649
    //  check if the zone entering the goal is actually a soccer ball
 
7650
    if ((GetType() == gSoccer_GOAL) && (target->GetType() == gSoccer_BALL) && target->lastTeamIn_)
 
7651
    {
 
7652
        if (target->lastTeamIn_ == team)
 
7653
        {
 
7654
            sn_ConsoleOut(tOutput("$soccer_goal_self", Team()->GetColoredName()));
 
7655
 
 
7656
            //  time to return ball to home
 
7657
            target->GoHome();
 
7658
        }
 
7659
        else
 
7660
        {
 
7661
            //  increase the number of times the ball entered other team's goal
 
7662
            target->ballShots_++;
 
7663
 
 
7664
            target->lastTeamIn_->AddScore(sg_soccerGoalScore, tOutput("$soccer_goal_score", target->lastTeamIn_->GetColoredName(), Team()->GetColoredName(), sg_soccerGoalScore), tOutput());
 
7665
            if (sg_soccerBallFirstWin && (target->ballShots_ == 1))
 
7666
            {
 
7667
                sg_DeclareWinner(target->lastTeamIn_, tOutput("$soccer_winner"));
 
7668
 
 
7669
                //  ball must vanish after having a winner
 
7670
                target->Collapse();
 
7671
            }
 
7672
            else if ((sg_soccerBallShotsWin > 0) && (target->ballShots_ >= sg_soccerBallShotsWin))
 
7673
            {
 
7674
                eTeam *thisTeam = team;                     //  the team owner of the goal
 
7675
                eTeam *shotTeam = target->lastTeamIn_;      //  the last team to hit the ball
 
7676
 
 
7677
                if (thisTeam && shotTeam)
 
7678
                {
 
7679
                    //  ensure the team score's are compared
 
7680
                    if (shotTeam->Score() < thisTeam->Score())
 
7681
                        sg_DeclareWinner(thisTeam, tOutput("$soccer_winner"));
 
7682
                    else
 
7683
                        sg_DeclareWinner(shotTeam, tOutput("$soccer_winner"));
 
7684
 
 
7685
                    //  ball must vanish after having a winner
 
7686
                    target->Collapse();
 
7687
                }
 
7688
            }
 
7689
            else
 
7690
            {
 
7691
                //  return soccer ball home
 
7692
                target->GoHome();
 
7693
            }
 
7694
        }
 
7695
    }
7709
7696
}
7710
7697
 
7711
7698
// *******************************************************************************
7712
7699
// *
7713
7700
// *    OnVanish
7714
7701
// *
7715
 
// *******************************************************************************
 
7702
// *******************************************************************************
7716
7703
 
7717
7704
void gSoccerZoneHack::OnVanish( void )
7718
 
{
7719
 
    //  respawn soccer ball that suddenly disappears
7720
 
    if (zoneType == gSoccer_BALL)
7721
 
    {
7722
 
        GoHome();
7723
 
    }
7724
 
    else
 
7705
{
 
7706
    //  respawn soccer ball that suddenly disappears
 
7707
    if (zoneType == gSoccer_BALL)
 
7708
    {
 
7709
        GoHome();
 
7710
    }
 
7711
    else
7725
7712
        grid->RemoveGameObjectInteresting(this);
7726
 
}
7727
 
 
 
7713
}
 
7714
 
7728
7715
// *******************************************************************************
7729
7716
// *
7730
7717
// *    SpawnSoccer
7731
7718
// *
7732
 
// *******************************************************************************
7733
 
 
7734
 
static void sg_SpawnSoccer(std::istream &s)
7735
 
{
 
7719
// *******************************************************************************
 
7720
 
 
7721
static void sg_SpawnSoccer(std::istream &s)
 
7722
{
7736
7723
    eGrid *grid = eGrid::CurrentGrid();
7737
 
    if(!grid)
7738
 
        return;
7739
 
 
7740
 
    tString params;
7741
 
    params.ReadLine(s, true);
7742
 
 
7743
 
    if (params.Filter() == "")
7744
 
    {
7745
 
        goto usage;
7746
 
        return;
7747
 
    }
7748
 
    else
7749
 
    {
7750
 
        float sizeMultiplier = gArena::SizeMultiplier();
7751
 
        float radius, growth;
7752
 
        tString name, type, team;
7753
 
        std::vector<eCoord> route;
7754
 
        int pos = 0;
7755
 
        gZone *Zone = NULL;
7756
 
 
7757
 
        name = params.ExtractNonBlankSubString(pos);
7758
 
        if (name.ToLower() == "n")
7759
 
        {
7760
 
            name = params.ExtractNonBlankSubString(pos);
7761
 
            type = params.ExtractNonBlankSubString(pos);
7762
 
        }
7763
 
        else
7764
 
        {
7765
 
            type = name;
7766
 
            name = "";
7767
 
        }
7768
 
 
7769
 
        if (type.ToLower() == "soccerball")
7770
 
        {
7771
 
            //  good...