[UT2004] Suche Respawn Delay Mutator (Spieler und Bots)...besonders für CTF

[Silent3sniper]

Hi,


Wir spielen zu dritt ab und zu ein bischen ut2004 CTF gegen Bots. Am meisten Spaß macht es zu 1:2 (Verhältnis Spieler zu Bots (gegnerisches Team)).

Das Problem ist, dass es eine Spawnprotection time gibt (2s), jedoch keine Respawn-Delay Zeit.
D.h. bei der gegnerischen Flagge sind effektiv 6 bots gegen maximal 1-2 Spieler. Das suckt ein wenig, selbst wenn man sie tötet haben sie 2 Sekunden Zeit einen abzuschießen ohne das man was tun kann.

Habe recht lange nach einem Mod dafür gesucht aber nichts gefunden. Vielleicht hat ja jemand von euch mal das gleiche Problem gehabt oder so einen Mutator noch in einer alten ut2004 Installation.

Viele Seiten die ut2004 Zeug hatten sind inzwischen sowieso down. Suchergebnisse die auf Foren verweisen sind oft defekt / verlinken nicht mehr in die entsprechenden Threads.



http://ericdives.com/UT2004-UnCodex/unrealgame/ctfgame.html#_SpawnWait-
http://forums.epicgames.com/threads/424664-Player-respawn-delay

Habe das hier gefunden, aber ich finde die originalen Gametypes (DM, TDM, CTF usw) nicht. Würde einfach den originalen CTF Gametype ändern, die Funktion gibt es wohl. Spawnwait(). Für Spieler lautet die Funktion sogar anders. Wäre also perfekt, wenn man wüsste wo man das ändern kann.

Scheint in der UnrealGame.u zu sein

Hier mal die Datei: http://www52.zippyshare.com/v/11821776/file.html

Unter defaultproperties muss Spawnwait reingemacht werden. Mit was kann man die Datei vernünftig öffnen?
edit: Geht im unrealeditor (unrealed.exe)

Könnte jemand der weiß was er tut hier spawnwait(5) in diese beiden code-schnipsel einarbeiten?


//=============================================================================
// CTFGame.
//=============================================================================
class CTFGame extends TeamGame
CacheExempt
config;

var(LoadingHints) private localized array<string> CTFHints;

function PostBeginPlay()
{
Super.PostBeginPlay();
SetTeamFlags();
}

function RegisterVehicle(Vehicle V)
{
Super.RegisterVehicle(V);
//V.bTeamLocked = false;
}

static function PrecacheGameAnnouncements(AnnouncerVoice V, bool bRewardSounds)
{
Super.PrecacheGameAnnouncements(V,bRewardSounds);
if ( !bRewardSounds )
{
V.PrecacheSound('Red_Flag_Returned');
V.PrecacheSound('Blue_Flag_Returned');
V.PrecacheSound('Red_Flag_Dropped');
V.PrecacheSound('Blue_Flag_Dropped');
V.PrecacheSound('Red_Flag_Taken');
V.PrecacheSound('Blue_Flag_Taken');
}
else
V.PrecacheSound('Denied');
}

/* OBSOLETE UpdateAnnouncements() - preload all announcer phrases used by this actor */
simulated function UpdateAnnouncements() {}

function bool NearGoal(Controller C)
{
local PlayerReplicationInfo P;

P = C.PlayerReplicationInfo;
return ( CTFBase(P.Team.HomeBase).myFlag.bHome && (VSize(C.Pawn.Location - P.Team.HomeBase.Location) < 1000) );
}

static function int OrderToIndex(int Order)
{
if(Order == 2)
return 10;

if(Order == 0)
return 11;

return Order;
}

function float SpawnWait(AIController B)
{
if ( B.PlayerReplicationInfo.bOutOfLives )
return 999;
if ( Level.NetMode == NM_Standalone )
{
if ( NumBots < 4 )
return 0;
if ( !CTFSquadAI(Bot(B).Squad).FriendlyFlag.bHome && (Numbots <= 16) )
return FRand();
return ( 0.5 * FMax(2,NumBots-4) * FRand() );
}
return FRand();
}

function SetTeamFlags()
{
local CTFFlag F;

// associate flags with teams
ForEach AllActors(Class'CTFFlag',F)
{
F.Team = Teams[F.TeamNum];
F.Team.HomeBase = F.HomeBase;
CTFTeamAI(F.Team.AI).FriendlyFlag = F;
if ( F.TeamNum == 0 )
CTFTeamAI(Teams[1].AI).EnemyFlag = F;
else
CTFTeamAI(Teams[0].AI).EnemyFlag = F;
}
}

function GameObject GetGameObject( Name GameObjectName )
{
local int i;

for ( i = 0; i < ArrayCount(Teams); i++ )
{
if ( CTFTeamAI(Teams[i].AI).FriendlyFlag.IsA(GameObjectName) )
return CTFTeamAI(Teams[i].AI).FriendlyFlag;
}

return Super.GetGameObject(GameObjectName);
}

function Logout(Controller Exiting)
{
if ( Exiting.PlayerReplicationInfo.HasFlag != None )
CTFFlag(Exiting.PlayerReplicationInfo.HasFlag).Drop(vect(0,0,0));
Super.Logout(Exiting);
}

function bool CheckEndGame(PlayerReplicationInfo Winner, string Reason)
{
local CTFFlag BestFlag;
local Controller P;
local PlayerController Player;
local bool bLastMan;

if ( bOverTime )
{
if ( Numbots + NumPlayers == 0 )
return true;
bLastMan = true;
for ( P=Level.ControllerList; P!=None; P=P.nextController )
if ( (P.PlayerReplicationInfo != None) && !P.PlayerReplicationInfo.bOutOfLives )
{
bLastMan = false;
break;
}
if ( bLastMan )
return true;
}

bLastMan = ( Reason ~= "LastMan" );

if ( (GameRulesModifiers != None) && !GameRulesModifiers.CheckEndGame(Winner, Reason) )
return false;

if ( bLastMan )
GameReplicationInfo.Winner = Winner.Team;
else
{
if ( Teams[1].Score == Teams[0].Score )
{
if ( !bOverTimeBroadcast )
{
StartupStage = 7;
PlayStartupMessage();
bOverTimeBroadcast = true;
}
return false;
}
if ( Teams[1].Score > Teams[0].Score )
GameReplicationInfo.Winner = Teams[1];
else
GameReplicationInfo.Winner = Teams[0];
}

BestFlag = CTFTeamAI(UnrealTeamInfo(GameReplicationInfo.Winner).AI).FriendlyFlag;
EndGameFocus = BestFlag.HomeBase;
EndGameFocus.bHidden = false;

EndTime = Level.TimeSeconds + EndTimeDelay;
for ( P=Level.ControllerList; P!=None; P=P.nextController )
{
P.GameHasEnded();
Player = PlayerController(P);
if ( Player != None )
{
Player.ClientSetBehindView(true);
Player.ClientSetViewTarget(EndGameFocus);
Player.SetViewTarget(EndGameFocus);
if ( !Player.PlayerReplicationInfo.bOnlySpectator )
PlayWinMessage(Player, (Player.PlayerReplicationInfo.Team == GameReplicationInfo.Winner));
Player.ClientGameEnded();
if ( CurrentGameProfile != None )
CurrentGameProfile.bWonMatch = (Player.PlayerReplicationInfo.Team == GameReplicationInfo.Winner);
}
}
BestFlag.HomeBase.bHidden = false;
BestFlag.bHidden = true;
return true;
}

function ScoreGameObject( Controller C, GameObject GO )
{
Super.ScoreGameObject(C,GO);
if ( GO.IsA('CTFFlag') )
ScoreFlag(C, CTFFlag(GO));
}

function ScoreFlag(Controller Scorer, CTFFlag theFlag)
{
local float Dist,oppDist;
local int i;
local float ppp,numtouch;
local vector FlagLoc;

if ( Scorer.PlayerReplicationInfo.Team == theFlag.Team )
{
Scorer.AwardAdrenaline(ADR_Return);
FlagLoc = TheFlag.Position().Location;
Dist = vsize(FlagLoc - TheFlag.HomeBase.Location);

if (TheFlag.TeamNum==0)
oppDist = vsize(FlagLoc - Teams[1].HomeBase.Location);
else
oppDist = vsize(FlagLoc - Teams[0].HomeBase.Location);

GameEvent("flag_returned",""$theFlag.Team.TeamIndex,Scorer.PlayerReplicationInfo);
BroadcastLocalizedMessage( class'CTFMessage', 1, Scorer.PlayerReplicationInfo, None, TheFlag.Team );

if (Dist>1024)
{
// figure out who's closer
if (Dist<=oppDist) // In your team's zone
{
Scorer.PlayerReplicationInfo.Score += 3;
ScoreEvent(Scorer.PlayerReplicationInfo,3,"flag_ret_friendly");
}
else
{
Scorer.PlayerReplicationInfo.Score += 5;
ScoreEvent(Scorer.PlayerReplicationInfo,5,"flag_ret_enemy");

if (oppDist<=1024) // Denial
{
Scorer.PlayerReplicationInfo.Score += 7;
ScoreEvent(Scorer.PlayerReplicationInfo,7,"flag_denial");
}

}
}
return;
}

// Figure out Team based scoring.
if (TheFlag.FirstTouch!=None) // Original Player to Touch it gets 5
{
ScoreEvent(TheFlag.FirstTouch.PlayerReplicationInfo,5,"flag_cap_1st_touch");
TheFlag.FirstTouch.PlayerReplicationInfo.Score += 5;
TheFlag.FirstTouch.PlayerReplicationInfo.NetUpdateTime = Level.TimeSeconds - 1;
}

// Guy who caps gets 5
Scorer.PlayerReplicationInfo.NetUpdateTime = Level.TimeSeconds - 1;
Scorer.PlayerReplicationInfo.Score += 5;
IncrementGoalsScored(Scorer.PlayerReplicationInfo);
Scorer.AwardAdrenaline(ADR_Goal);

// Each player gets 20/x but it's guarenteed to be at least 1 point but no more than 5 points
numtouch=0;
for (i=0;i<TheFlag.Assists.length;i++)
{
if (TheFlag.Assists[i]!=None)
numtouch = numtouch + 1.0;
}

ppp = FClamp(20/numtouch,1,5);

for (i=0;i<TheFlag.Assists.length;i++)
{
if (TheFlag.Assists[i]!=None)
{
ScoreEvent(TheFlag.Assists[i].PlayerReplicationInfo,ppp,"flag_cap_assist");
TheFlag.Assists[i].PlayerReplicationInfo.Score += int(ppp);
}
}

// Apply the team score
Scorer.PlayerReplicationInfo.Team.Score += 1.0;
Scorer.PlayerReplicationInfo.Team.NetUpdateTime = Level.TimeSeconds - 1;
ScoreEvent(Scorer.PlayerReplicationInfo,5,"flag_cap_final");
TeamScoreEvent(Scorer.PlayerReplicationInfo.Team.TeamIndex,1,"flag_cap");
GameEvent("flag_captured",""$theflag.Team.TeamIndex,Scorer.PlayerReplicationInfo);

BroadcastLocalizedMessage( class'CTFMessage', 0, Scorer.PlayerReplicationInfo, None, TheFlag.Team );
AnnounceScore(Scorer.PlayerReplicationInfo.Team.TeamIndex);
CheckScore(Scorer.PlayerReplicationInfo);

if ( bOverTime )
{
EndGame(Scorer.PlayerReplicationInfo,"timelimit");
}
}

function DiscardInventory( Pawn Other )
{
if ( (Other.PlayerReplicationInfo != None) && (Other.PlayerReplicationInfo.HasFlag != None) )
CTFFlag(Other.PlayerReplicationInfo.HasFlag).Drop(0.5 * Other.Velocity);

Super.DiscardInventory(Other);

}

static function array<string> GetAllLoadHints(optional bool bThisClassOnly)
{
local int i;
local array<string> Hints;

if ( !bThisClassOnly || default.CTFHints.Length == 0 )
Hints = Super.GetAllLoadHints();

for ( i = 0; i < default.CTFHints.Length; i++ )
Hints[Hints.Length] = default.CTFHints[i];

return Hints;
}

State MatchOver
{
function ScoreFlag(Controller Scorer, CTFFlag theFlag)
{
}
}




class InstagibCTF extends xCTFGame;

var globalconfig bool bZoomInstagib;
var globalconfig bool bAllowBoost;
var globalconfig bool bLowGrav;
var localized string ZoomDisplayText, ZoomDescText;


static function bool AllowMutator( string MutatorClassName )
{
if ( MutatorClassName == "" )
return false;

if ( static.IsVehicleMutator(MutatorClassName) )
return false;
if ( MutatorClassName ~= "xGame.MutInstagib" )
return false;
if ( MutatorClassName ~= "xGame.MutZoomInstagib" )
return false;

return super.AllowMutator(MutatorClassName);
}

static function FillPlayInfo(PlayInfo PlayInfo)
{
Super.FillPlayInfo(PlayInfo);

PlayInfo.AddSetting(default.RulesGroup, "bAllowBoost", class'MutInstagib'.default.BoostDisplayText, 0, 1, "Check");
PlayInfo.AddSetting(default.RulesGroup, "bZoomInstagib", default.ZoomDisplayText, 0, 1, "Check");
PlayInfo.AddSetting(default.RulesGroup, "bLowGrav", class'MutLowGrav'.default.Description, 0, 1, "Check");
}

static event string GetDescriptionText(string PropName)
{
switch (PropName)
{
case "bAllowBoost": return class'MutInstagib'.default.BoostDescText;
case "bZoomInstagib": return default.ZoomDescText;
case "bLowGrav": return class'MutLowGrav'.default.Description;
}

return Super.GetDescriptionText(PropName);
}

static event bool AcceptPlayInfoProperty(string PropertyName)
{
if ( InStr(PropertyName, "bWeaponStay") != -1 )
return false;
if ( InStr(PropertyName, "bAllowWeaponThrowing") != -1 )
return false;

return Super.AcceptPlayInfoProperty(PropertyName);
}