1901 lines
62 KiB
Ucode
1901 lines
62 KiB
Ucode
// Server extension mutator, by Marco.
|
|
Class ServerExtMut extends KFMutator
|
|
config(ServerExtMut);
|
|
|
|
// Webadmin
|
|
var array<FWebAdminConfigInfo> WebConfigs;
|
|
|
|
struct FInventory
|
|
{
|
|
var class<Inventory> ItemClass;
|
|
var int Values[4];
|
|
};
|
|
struct CFGCustomZedXP
|
|
{
|
|
var string zed; // zed name
|
|
var float XP1; // normal
|
|
var float XP2; // hard
|
|
var float XP3; // suicidal
|
|
var float XP4; // hoe
|
|
};
|
|
struct FSavedInvEntry
|
|
{
|
|
var Controller OwnerPlayer;
|
|
var byte Gren;
|
|
var array<FInventory> Inv;
|
|
};
|
|
var array<FSavedInvEntry> PlayerInv;
|
|
|
|
var config array<string> PerkClasses,CustomChars,AdminCommands,CustomItems,BonusGameSongs,BonusGameFX;
|
|
var config array<CFGCustomZedXP> CustomZedXP;
|
|
var array< class<Ext_PerkBase> > LoadedPerks;
|
|
var array<FCustomCharEntry> CustomCharList;
|
|
var ExtPlayerStat ServerStatLoader;
|
|
|
|
var KFPawn LastHitZed;
|
|
var int LastHitHP;
|
|
var ExtPlayerController LastDamageDealer;
|
|
var vector LastDamagePosition;
|
|
var private const array<string> DevList;
|
|
var transient private array<UniqueNetId> DevNetID;
|
|
var ExtXMLOutput FileOutput;
|
|
var transient class<DamageType> LastKillDamageType;
|
|
|
|
var SoundCue BonusGameCue;
|
|
var Object BonusGameFXObj;
|
|
|
|
var array<FCustomTraderItem> CustomItemList;
|
|
var KFGFxObject_TraderItems CustomTrader;
|
|
|
|
const SettingsTagVer=13;
|
|
var KFGameReplicationInfo KF;
|
|
var config int SettingsInit;
|
|
var config int ForcedMaxPlayers,PlayerRespawnTime,LargeMonsterHP,StatAutoSaveWaves,MinUnloadPerkLevel,PostGameRespawnCost,MaxTopPlayers;
|
|
var config float UnloadPerkExpCost;
|
|
var globalconfig string ServerMOTD,StatFileDir;
|
|
var array<Controller> PendingSpawners;
|
|
var int LastWaveNum,NumWaveSwitches;
|
|
var ExtSpawnPointHelper SpawnPointer;
|
|
var bool bRespawnCheck,bSpecialSpawn,bGameHasEnded,bIsPostGame;
|
|
var config bool bKillMessages,bDamageMessages,bEnableMapVote,bNoAdminCommands,bNoWebAdmin,bNoBoomstickJumping,bDumpXMLStats,bRagdollFromFall,bRagdollFromMomentum,bRagdollFromBackhit,bAddCountryTags;
|
|
var config bool bServerPerksMode;
|
|
var config bool bDLCWeaponsForFree;
|
|
var config bool bDontUseOriginalWeaponry;
|
|
var config bool bAllowStandartPistolUpgrade;
|
|
var config bool bDisableCustomTrader;
|
|
|
|
//Custom XP lightly array
|
|
struct CustomZedXPStruct
|
|
{
|
|
var class<KFPawn_Monster> zedclass;
|
|
var float XPValues[4];
|
|
};
|
|
var array<CustomZedXPStruct> CustomZedXPArray;
|
|
|
|
function PostBeginPlay()
|
|
{
|
|
local xVotingHandler MV;
|
|
local int i,j;
|
|
local class<Ext_PerkBase> PK;
|
|
local UniqueNetId Id;
|
|
local KFCharacterInfo_Human CH;
|
|
local ObjectReferencer OR;
|
|
local Object O;
|
|
local string S;
|
|
local bool bLock;
|
|
|
|
Super.PostBeginPlay();
|
|
if( WorldInfo.Game.BaseMutator==None )
|
|
WorldInfo.Game.BaseMutator = Self;
|
|
else WorldInfo.Game.BaseMutator.AddMutator(Self);
|
|
|
|
if( bDeleteMe ) // This was a duplicate instance of the mutator.
|
|
return;
|
|
|
|
SpawnPointer = class'ExtSpawnPointHelper'.Static.FindHelper(WorldInfo); // Start init world pathlist.
|
|
|
|
//OnlineSubsystemSteamworks(class'GameEngine'.Static.GetOnlineSubsystem()).Int64ToUniqueNetId("",Id);
|
|
//`Log("TEST"@class'OnlineSubsystem'.Static.UniqueNetIdToString(Id));
|
|
|
|
DevNetID.Length = DevList.Length;
|
|
for( i=0; i<DevList.Length; ++i )
|
|
{
|
|
class'OnlineSubsystem'.Static.StringToUniqueNetId(DevList[i],Id);
|
|
DevNetID[i] = Id;
|
|
}
|
|
ServerStatLoader = new (None) class'ExtPlayerStat';
|
|
WorldInfo.Game.HUDType = class'KFExtendedHUD';
|
|
WorldInfo.Game.PlayerControllerClass = class'ExtPlayerController';
|
|
WorldInfo.Game.PlayerReplicationInfoClass = class'ExtPlayerReplicationInfo';
|
|
WorldInfo.Game.DefaultPawnClass = class'ExtHumanPawn';
|
|
KFGameInfo(WorldInfo.Game).CustomizationPawnClass = class'ExtPawn_Customization';
|
|
KFGameInfo(WorldInfo.Game).KFGFxManagerClass = class'ExtMoviePlayer_Manager';
|
|
|
|
// trader things
|
|
if(!bDisableCustomTrader && CustomTrader==None )
|
|
{
|
|
CustomTrader = class'ExtPlayerReplicationInfo'.Static.CreateNewList();
|
|
SetTimer(0.001, false, 'EditTraiderItems');
|
|
}
|
|
|
|
if( ServerMOTD=="" )
|
|
ServerMOTD = "Message of the Day";
|
|
if( StatFileDir=="" )
|
|
{
|
|
StatFileDir = "../../KFGame/Script/%s.usa";
|
|
Default.StatFileDir = "../../KFGame/Script/%s.usa";
|
|
}
|
|
if( SettingsInit!=SettingsTagVer )
|
|
{
|
|
if( SettingsInit==0 )
|
|
ForcedMaxPlayers = 6;
|
|
if( SettingsInit<2 )
|
|
{
|
|
bKillMessages = true;
|
|
bDamageMessages = true;
|
|
LargeMonsterHP = 800;
|
|
}
|
|
if( SettingsInit<3 )
|
|
bEnableMapVote = true;
|
|
if( SettingsInit<5 )
|
|
{
|
|
StatAutoSaveWaves = 1;
|
|
PerkClasses.Length = 10;
|
|
PerkClasses[0] = PathName(class'Ext_PerkBerserker');
|
|
PerkClasses[1] = PathName(class'Ext_PerkCommando');
|
|
PerkClasses[2] = PathName(class'Ext_PerkFieldMedic');
|
|
PerkClasses[3] = PathName(class'Ext_PerkSupport');
|
|
PerkClasses[4] = PathName(class'Ext_PerkDemolition');
|
|
PerkClasses[5] = PathName(class'Ext_PerkFirebug');
|
|
PerkClasses[6] = PathName(class'Ext_PerkGunslinger');
|
|
PerkClasses[7] = PathName(class'Ext_PerkSharpshooter');
|
|
PerkClasses[8] = PathName(class'Ext_PerkSWAT');
|
|
PerkClasses[9] = PathName(class'Ext_PerkSurvivalist');
|
|
}
|
|
else if( SettingsInit<11 )
|
|
{
|
|
PerkClasses.AddItem(PathName(class'Ext_PerkSharpshooter'));
|
|
PerkClasses.AddItem(PathName(class'Ext_PerkSWAT'));
|
|
PerkClasses.AddItem(PathName(class'Ext_PerkSurvivalist'));
|
|
}
|
|
else if( SettingsInit==11 )
|
|
PerkClasses.AddItem(PathName(class'Ext_PerkSurvivalist'));
|
|
if( SettingsInit<6 )
|
|
{
|
|
MinUnloadPerkLevel = 25;
|
|
UnloadPerkExpCost = 0.1;
|
|
}
|
|
if( SettingsInit<8 )
|
|
{
|
|
AdminCommands.Length = 2;
|
|
AdminCommands[0] = "Kick:Kick Player";
|
|
AdminCommands[1] = "KickBan:Kick-Ban Player";
|
|
}
|
|
if( SettingsInit<9 )
|
|
MaxTopPlayers = 50;
|
|
|
|
if(SettingsInit < 13)
|
|
{
|
|
bDLCWeaponsForFree = True;
|
|
bAllowStandartPistolUpgrade = True;
|
|
bDisableCustomTrader = False;
|
|
}
|
|
SettingsInit = SettingsTagVer;
|
|
SaveConfig();
|
|
}
|
|
for( i=0; i<PerkClasses.Length; ++i )
|
|
{
|
|
PK = class<Ext_PerkBase>(DynamicLoadObject(PerkClasses[i],class'Class'));
|
|
if( PK!=None )
|
|
{
|
|
LoadedPerks.AddItem(PK);
|
|
PK.Static.CheckConfig();
|
|
}
|
|
}
|
|
j = 0;
|
|
for( i=0; i<CustomChars.Length; ++i )
|
|
{
|
|
bLock = Left(CustomChars[i],1)=="*";
|
|
S = (bLock ? Mid(CustomChars[i],1) : CustomChars[i]);
|
|
CH = KFCharacterInfo_Human(DynamicLoadObject(S,class'KFCharacterInfo_Human',true));
|
|
if( CH!=None )
|
|
{
|
|
CustomCharList.Length = j+1;
|
|
CustomCharList[j].bLock = bLock;
|
|
CustomCharList[j].Char = CH;
|
|
++j;
|
|
continue;
|
|
}
|
|
|
|
OR = ObjectReferencer(DynamicLoadObject(S,class'ObjectReferencer'));
|
|
if( OR!=None )
|
|
{
|
|
foreach OR.ReferencedObjects(O)
|
|
{
|
|
if( KFCharacterInfo_Human(O)!=None )
|
|
{
|
|
CustomCharList.Length = j+1;
|
|
CustomCharList[j].bLock = bLock;
|
|
CustomCharList[j].Char = KFCharacterInfo_Human(O);
|
|
CustomCharList[j].Ref = OR;
|
|
++j;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bonus (pong) game contents.
|
|
if( BonusGameSongs.Length>0 )
|
|
{
|
|
BonusGameCue = SoundCue(DynamicLoadObject(BonusGameSongs[Rand(BonusGameSongs.Length)],class'SoundCue'));
|
|
}
|
|
if( BonusGameFX.Length>0 )
|
|
{
|
|
BonusGameFXObj = DynamicLoadObject(BonusGameFX[Rand(BonusGameFX.Length)],class'Object');
|
|
if( SoundCue(BonusGameFXObj)==None && ObjectReferencer(BonusGameFXObj)==None ) // Check valid type.
|
|
BonusGameFXObj = None;
|
|
}
|
|
|
|
if( ForcedMaxPlayers>0 )
|
|
{
|
|
SetMaxPlayers();
|
|
SetTimer(0.001,false,'SetMaxPlayers');
|
|
}
|
|
bRespawnCheck = (PlayerRespawnTime>0);
|
|
if( bRespawnCheck )
|
|
SetTimer(1,true);
|
|
if( bEnableMapVote )
|
|
{
|
|
foreach DynamicActors(class'xVotingHandler',MV)
|
|
break;
|
|
if( MV==None )
|
|
MV = Spawn(class'xVotingHandler');
|
|
MV.BaseMutator = Class;
|
|
}
|
|
SetTimer(1,true,'CheckWave');
|
|
if( !bNoWebAdmin && WorldInfo.NetMode!=NM_StandAlone )
|
|
SetTimer(0.1,false,'SetupWebAdmin');
|
|
|
|
if( bDumpXMLStats )
|
|
FileOutput = Spawn(class'ExtXMLOutput');
|
|
|
|
UpdateCustomZedXPArray();
|
|
// Causes bugs
|
|
// SetTimer(0.1,'CheckPickupFactories')
|
|
}
|
|
|
|
function UpdateCustomZedXPArray()
|
|
{
|
|
local int i;
|
|
local CustomZedXPStruct zedxp;
|
|
CustomZedXPArray.Length = 0;
|
|
// Custom XP for custom zeds
|
|
for(i=0;i<CustomZedXP.Length;i++)
|
|
{
|
|
zedxp.zedclass = class<KFPawn_Monster>(DynamicLoadObject(CustomZedXP[i].zed,Class'Class'));
|
|
if(zedxp.zedclass == none)
|
|
{
|
|
`log("Error loading"@CustomZedXP[i].zed);
|
|
continue;
|
|
}
|
|
zedxp.XPValues[0] = CustomZedXP[i].XP1;
|
|
zedxp.XPValues[1] = CustomZedXP[i].XP2;
|
|
zedxp.XPValues[2] = CustomZedXP[i].XP3;
|
|
zedxp.XPValues[3] = CustomZedXP[i].XP4;
|
|
CustomZedXPArray.AddItem(zedxp);
|
|
`log("CustomXP: Loaded"@PathName(zedxp.zedclass));
|
|
}
|
|
}
|
|
|
|
// function CheckPickupFactories()
|
|
// {
|
|
// local KFPickupFactory_Item ItemFactory;
|
|
|
|
// // Disable 9mm and medpistol in all PickupFactories
|
|
// foreach AllActors(class'KFPickupFactory_Item', ItemFactory)
|
|
// {
|
|
// for(i=0;i<ItemFactory.ItemPickups.Length;i++)
|
|
// {
|
|
// if(ItemFactory.ItemPickups[i].ItemClass == class'KFGameContent.KFWeap_Pistol_9mm'
|
|
// || ItemFactory.ItemPickups[i].ItemClass == class'KFGameContent.KFWeap_Pistol_Medic')
|
|
// {
|
|
// ItemFactory.ItemPickups.Remove(i, 1);
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
function EditTraiderItems()
|
|
{
|
|
local int i;
|
|
local KFGFxObject_TraderItems Trad;
|
|
// local FCustomTraderItem CI;
|
|
// local STraderItem SI;
|
|
// var config bool bDLCWeaponsForFree;
|
|
// var config bool bDontUseOriginalWeaponry;
|
|
if(!bDontUseOriginalWeaponry)
|
|
{
|
|
Trad = KFGameReplicationInfo(WorldInfo.GRI).TraderItems;
|
|
// Remove dual 9mm, 9mm, medpistol and DLC weapons
|
|
for(i=0;i<Trad.SaleItems.Length;i++)
|
|
{
|
|
if(string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_Dual9mm"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_Medic"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_9mm")
|
|
{
|
|
// Remove pistols
|
|
continue;
|
|
}
|
|
|
|
if(bDLCWeaponsForFree)
|
|
{
|
|
// DLC Weapons
|
|
if(string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_Blunderbuss"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Blunt_ChainBat"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_ChiappaRhino"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_ChiappaRhinoDual"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Bow_CompoundBow"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Ice_FreezeThrower"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Edged_IonThruster"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Rifle_MosinNagant"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_AssaultRifle_LazerCutter"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_SMG_G18"
|
|
|| string(Trad.SaleItems[i].ClassName) ~= "KFWeap_Pistol_DualG18")
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Adding original weapon
|
|
AddCIToTraderEx(Trad.SaleItems[i].WeaponDef);
|
|
}
|
|
}
|
|
|
|
// Reinfo and resorting items
|
|
// MyKFGI.MyKFGRI.TraderItems.SetItemsInfo(MyKFGI.MyKFGRI.TraderItems.SaleItems);
|
|
// MyKFGI.MyKFGRI.TraderItems.SortItemsInfo(MyKFGI.MyKFGRI.TraderItems.SaleItems);
|
|
|
|
if(bAllowStandartPistolUpgrade)
|
|
{
|
|
// Add custom 9mm for upgrades
|
|
AddCIToTrader("ServerExt.ExtWeapDef_9mm");
|
|
|
|
// Add custom medpistol for upgrades
|
|
AddCIToTrader("ServerExt.ExtWeapDef_MedicPistol");
|
|
}
|
|
|
|
//Add DLCs weapons for free
|
|
if(bDLCWeaponsForFree)
|
|
{
|
|
AddCIToTrader("ServerExt.DLCWeapDef_Blunderbuss");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_ChainBat");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_ChiappaRhino");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_ChiappaRhinoDual");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_CompoundBow");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_FreezeThrower");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_IonThruster");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_G18");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_MosinNagant");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_LazerCutter");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_Pistol_DualG18");
|
|
AddCIToTrader("ServerExt.DLCWeapDef_Pistol_G18C");
|
|
}
|
|
|
|
// Add custom items from WebAdmin
|
|
for( i=0; i<CustomItems.Length; ++i )
|
|
{
|
|
AddCIToTrader(CustomItems[i]);
|
|
}
|
|
InitGRIList();
|
|
}
|
|
|
|
function AddCIToTrader(string weapdef)
|
|
{
|
|
local FCustomTraderItem CI;
|
|
CI.WeaponDef = class<KFWeaponDefinition>(DynamicLoadObject(weapdef,class'Class'));
|
|
if(CI.WeaponDef == None)
|
|
return;
|
|
CI.WeaponClass = class<KFWeapon>(DynamicLoadObject(CI.WeaponDef.Default.WeaponClassPath,class'Class'));
|
|
if(CI.WeaponClass == None)
|
|
return;
|
|
CustomItemList.AddItem(CI);
|
|
class'ExtPlayerReplicationInfo'.Static.SetWeaponInfo(WorldInfo.NetMode==NM_DedicatedServer,CustomTrader.SaleItems.Length,CI,CustomTrader);
|
|
}
|
|
|
|
function AddCIToTraderEx(class<KFWeaponDefinition> weapdef)
|
|
{
|
|
local FCustomTraderItem CI;
|
|
CI.WeaponDef = weapdef;
|
|
if(CI.WeaponDef == None)
|
|
return;
|
|
CI.WeaponClass = class<KFWeapon>(DynamicLoadObject(CI.WeaponDef.Default.WeaponClassPath,class'Class'));
|
|
if(CI.WeaponClass == None)
|
|
return;
|
|
CustomItemList.AddItem(CI);
|
|
class'ExtPlayerReplicationInfo'.Static.SetWeaponInfo(WorldInfo.NetMode==NM_DedicatedServer,CustomTrader.SaleItems.Length,CI,CustomTrader);
|
|
}
|
|
|
|
static final function string GetStatFile( const out UniqueNetId UID )
|
|
{
|
|
return Repl(Default.StatFileDir,"%s","U_"$class'OnlineSubsystem'.Static.UniqueNetIdToString(UID));
|
|
}
|
|
final function bool IsDev( const out UniqueNetId UID )
|
|
{
|
|
local int i;
|
|
|
|
for( i=(DevNetID.Length-1); i>=0; --i )
|
|
if( DevNetID[i]==UID )
|
|
return true;
|
|
return false;
|
|
}
|
|
function InitGRIList()
|
|
{
|
|
local ExtPlayerController PC;
|
|
|
|
KFGameReplicationInfo(WorldInfo.GRI).TraderItems = CustomTrader;
|
|
|
|
// Must sync up local client.
|
|
if( WorldInfo.NetMode==NM_StandAlone )
|
|
{
|
|
foreach LocalPlayerControllers(class'ExtPlayerController',PC)
|
|
if( PC.PurchaseHelper!=None )
|
|
PC.PurchaseHelper.TraderItems = CustomTrader;
|
|
}
|
|
}
|
|
function CheckWave()
|
|
{
|
|
if( KF==None )
|
|
{
|
|
KF = KFGameReplicationInfo(WorldInfo.GRI);
|
|
if( KF==None )
|
|
return;
|
|
}
|
|
if( LastWaveNum!=KF.WaveNum )
|
|
{
|
|
LastWaveNum = KF.WaveNum;
|
|
NotifyWaveChange();
|
|
}
|
|
if( !bGameHasEnded && KF.bMatchIsOver ) // HACK, since KFGameInfo_Survival doesn't properly notify mutators of this!
|
|
{
|
|
SaveAllPerks(true);
|
|
bGameHasEnded = true;
|
|
}
|
|
}
|
|
function NotifyWaveChange()
|
|
{
|
|
local ExtPlayerController ExtPC;
|
|
local KFProj_RicochetStickBullet KFBolt;
|
|
|
|
if( bRespawnCheck )
|
|
{
|
|
bIsPostGame = (KF.WaveMax<KF.WaveNum);
|
|
bRespawnCheck = (!bIsPostGame || PostGameRespawnCost>=0);
|
|
if( bRespawnCheck )
|
|
SavePlayerInventory();
|
|
}
|
|
if( StatAutoSaveWaves>0 && ++NumWaveSwitches>=StatAutoSaveWaves )
|
|
{
|
|
NumWaveSwitches = 0;
|
|
SaveAllPerks();
|
|
}
|
|
|
|
if( !KF.bTraderIsOpen )
|
|
{
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',ExtPC)
|
|
ExtPC.bSetPerk = false;
|
|
}
|
|
|
|
foreach WorldInfo.AllActors(class'KFProj_RicochetStickBullet', KFBolt)
|
|
{
|
|
if(KFProj_Bolt_CompoundBowSharp(KFBolt) != none ||
|
|
KFProj_Bolt_Crossbow(KFBolt) != none)
|
|
KFBolt.Destroy();
|
|
}
|
|
}
|
|
function SetupWebAdmin()
|
|
{
|
|
local WebServer W;
|
|
local WebAdmin A;
|
|
local ExtWebApp xW;
|
|
local byte i;
|
|
|
|
foreach AllActors(class'WebServer',W)
|
|
break;
|
|
if( W!=None )
|
|
{
|
|
for( i=0; (i<10 && A==None); ++i )
|
|
A = WebAdmin(W.ApplicationObjects[i]);
|
|
if( A!=None )
|
|
{
|
|
xW = new (None) class'ExtWebApp';
|
|
xW.MyMutator = Self;
|
|
A.addQueryHandler(xW);
|
|
}
|
|
else `Log("ExtWebAdmin ERROR: No valid WebAdmin application found!");
|
|
}
|
|
else `Log("ExtWebAdmin ERROR: No WebServer object found!");
|
|
}
|
|
function SetMaxPlayers()
|
|
{
|
|
local OnlineGameSettings GameSettings;
|
|
|
|
WorldInfo.Game.MaxPlayers = ForcedMaxPlayers;
|
|
WorldInfo.Game.MaxPlayersAllowed = ForcedMaxPlayers;
|
|
if( WorldInfo.Game.GameInterface!=None )
|
|
{
|
|
GameSettings = WorldInfo.Game.GameInterface.GetGameSettings(WorldInfo.Game.PlayerReplicationInfoClass.default.SessionName);
|
|
if( GameSettings!=None )
|
|
GameSettings.NumPublicConnections = ForcedMaxPlayers;
|
|
}
|
|
}
|
|
function AddMutator(Mutator M)
|
|
{
|
|
if( M!=Self ) // Make sure we don't get added twice.
|
|
{
|
|
if( M.Class==Class )
|
|
M.Destroy();
|
|
else Super.AddMutator(M);
|
|
}
|
|
}
|
|
|
|
function bool IsFromMod(Object O)
|
|
{
|
|
local string PackageName;
|
|
|
|
if( O == None )
|
|
return false;
|
|
|
|
PackageName = string(O.GetPackageName());
|
|
if( Len(PackageName)>1 && InStr(Caps(PackageName), "KF") == 0)
|
|
{
|
|
PackageName = string(O);
|
|
if( Len(PackageName)>1 && InStr(Caps(PackageName), "KF") == 0)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function ScoreKill(Controller Killer, Controller Killed)
|
|
{
|
|
local KFPawn_Monster KFM;
|
|
local int i, j;
|
|
local KFPlayerReplicationInfo DamagerKFPRI;
|
|
local float XP;
|
|
local KFPerk InstigatorPerk;
|
|
local bool cont;
|
|
|
|
local KFPlayerController KFPC;
|
|
local ExtPerkManager KillersPerk;
|
|
|
|
if( bRespawnCheck && Killed.bIsPlayer )
|
|
CheckRespawn(Killed);
|
|
KFM = KFPawn_Monster(Killed.Pawn);
|
|
if( KFM!=None && Killed.GetTeamNum()!=0 && Killer.bIsPlayer && Killer.GetTeamNum()==0 )
|
|
{
|
|
if( ExtPlayerController(Killer)!=None && ExtPlayerController(Killer).ActivePerkManager!=None )
|
|
ExtPlayerController(Killer).ActivePerkManager.PlayerKilled(KFPawn_Monster(Killed.Pawn),LastKillDamageType);
|
|
if( bKillMessages && Killer.PlayerReplicationInfo!=None )
|
|
BroadcastKillMessage(Killed.Pawn,Killer);
|
|
if( KFM.DamageHistory.Length > 0 )
|
|
{
|
|
for( i = 0; i<KFM.DamageHistory.Length; i++ )
|
|
{
|
|
DamagerKFPRI = KFPlayerReplicationInfo(KFM.DamageHistory[i].DamagerPRI);
|
|
if( DamagerKFPRI != None )
|
|
{
|
|
if( KFM.DamageHistory[i].DamagePerks.Length <= 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
cont = true;
|
|
for(j=0;j<KFM.DamageHistory[i].DamageCausers.Length;j++)
|
|
{
|
|
if(IsFromMod(KFM.DamageHistory[i].DamageCausers[j]) || IsFromMod(KFM.DamageHistory[i].DamageTypes[j]))
|
|
{
|
|
cont = false;
|
|
break;
|
|
}
|
|
}
|
|
if(cont && !IsFromMod(KFM))
|
|
continue;
|
|
|
|
// Distribute experience points
|
|
KFPC = KFPlayerController(DamagerKFPRI.Owner);
|
|
if( KFPC != none )
|
|
{
|
|
`log("ScoreKill:"@PathName(KFM));
|
|
|
|
XP = 0;
|
|
for(j=0;j<CustomZedXPArray.Length;j++)
|
|
{
|
|
if(KFM.Class == CustomZedXPArray[j].zedclass)
|
|
{
|
|
XP = CustomZedXPArray[j].XPValues[MyKFGI.GameDifficulty];
|
|
break;
|
|
}
|
|
}
|
|
if(XP == 0)
|
|
XP = KFM.static.GetXPValue(MyKFGI.GameDifficulty);
|
|
|
|
InstigatorPerk = KFPC.GetPerk();
|
|
if( InstigatorPerk.ShouldGetAllTheXP() )
|
|
{
|
|
KFPC.OnPlayerXPAdded(XP, InstigatorPerk.Class);
|
|
continue;
|
|
}
|
|
|
|
XP /= KFM.DamageHistory[i].DamagePerks.Length;
|
|
|
|
for( j = 0; j < KFM.DamageHistory[i].DamagePerks.Length; j++ )
|
|
{
|
|
KFPC.OnPlayerXPAdded(FCeil(XP), KFM.DamageHistory[i].DamagePerks[j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( MyKFGI != None && MyKFGI.IsZedTimeActive() && KFPawn_Monster(Killed.Pawn) != None )
|
|
{
|
|
KFPC = KFPlayerController(Killer);
|
|
if ( KFPC != none )
|
|
{
|
|
KillersPerk = ExtPerkManager(KFPC.GetPerk());
|
|
if ( MyKFGI.ZedTimeRemaining > 0.f && KillersPerk != none && KillersPerk.GetZedTimeExtensions( KFPC.GetLevel() ) > MyKFGI.ZedTimeExtensionsUsed )
|
|
{
|
|
MyKFGI.DramaticEvent(1.0);
|
|
MyKFGI.ZedTimeExtensionsUsed++;
|
|
}
|
|
}
|
|
}
|
|
if( ExtPlayerController(Killed)!=None )
|
|
CheckPerkChange(ExtPlayerController(Killed));
|
|
if (NextMutator != None)
|
|
NextMutator.ScoreKill(Killer, Killed);
|
|
else
|
|
Super.ScoreKill(Killer, Killed);
|
|
}
|
|
function bool PreventDeath(Pawn Killed, Controller Killer, class<DamageType> damageType, vector HitLocation)
|
|
{
|
|
if( (KFPawn_Human(Killed)!=None && CheckPreventDeath(KFPawn_Human(Killed),Killer,damageType)) || Super.PreventDeath(Killed,Killer,damageType,HitLocation) )
|
|
return true;
|
|
|
|
LastKillDamageType = damageType;
|
|
if( Killed.Controller!=None && KFPawn_Monster(Killed)!=None )
|
|
{
|
|
// Hack for when pet kills a zed.
|
|
if( Killed.GetTeamNum()!=0 )
|
|
{
|
|
if( Killer!=None && Killer!=Killed.Controller && Killer.GetTeamNum()==0 && Ext_T_MonsterPRI(Killer.PlayerReplicationInfo)!=None )
|
|
GT_PlayerKilled(Ext_T_MonsterPRI(Killer.PlayerReplicationInfo).OwnerController,Killed.Controller,damageType);
|
|
}
|
|
// Broadcast pet's deathmessage.
|
|
else if( Killed.PlayerReplicationInfo!=None && PlayerController(Killed.Controller)==None && damageType!=class'KFDT_Healing' )
|
|
BroadcastFFDeath(Killer,Killed,damageType);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Replica of KFGameInfo.Killed base.
|
|
final function GT_PlayerKilled( Controller Killer, Controller Killed, class<DamageType> damageType )
|
|
{
|
|
local ExtPlayerController KFPC;
|
|
local KFPawn_Monster MonsterPawn;
|
|
local KFGameInfo KFG;
|
|
|
|
KFG = KFGameInfo(WorldInfo.Game);
|
|
ScoreKill(Killer,Killed); // Broadcast kill message.
|
|
|
|
KFPC = ExtPlayerController(Killer);
|
|
MonsterPawn = KFPawn_Monster(Killed.Pawn);
|
|
if( KFG!=None && KFPC != none && MonsterPawn!=none )
|
|
{
|
|
//Chris: We have to do it earlier here because we need a damage type
|
|
KFPC.AddZedKill( MonsterPawn.class, KFG.GameDifficulty, damageType, false );
|
|
|
|
// Not support in v1096: KFGameInfo.CheckForBerserkerSmallRadiusKill
|
|
//if( KFPC.ActivePerkManager!=none && KFPC.ActivePerkManager.CanEarnSmallRadiusKillXP(damageType) )
|
|
// KFG.CheckForBerserkerSmallRadiusKill( MonsterPawn, KFPC );
|
|
}
|
|
}
|
|
final function bool CheckPreventDeath( KFPawn_Human Victim, Controller Killer, class<DamageType> damageType )
|
|
{
|
|
local ExtPlayerController E;
|
|
|
|
if( Victim.IsA('KFPawn_Customization') )
|
|
return false;
|
|
E = ExtPlayerController(Victim.Controller);
|
|
return (E!=None && E.ActivePerkManager!=None && E.ActivePerkManager.CurrentPerk!=None && E.ActivePerkManager.CurrentPerk.PreventDeath(Victim,Killer,damageType));
|
|
}
|
|
final function BroadcastKillMessage( Pawn Killed, Controller Killer )
|
|
{
|
|
local ExtPlayerController E;
|
|
|
|
if( Killer==None || Killer.PlayerReplicationInfo==None )
|
|
return;
|
|
|
|
if( Killed.Default.Health>=LargeMonsterHP )
|
|
{
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',E)
|
|
if( !E.bClientHideKillMsg )
|
|
E.ReceiveKillMessage(Killed.Class,true,Killer.PlayerReplicationInfo);
|
|
}
|
|
else if( ExtPlayerController(Killer)!=None && !ExtPlayerController(Killer).bClientHideKillMsg )
|
|
ExtPlayerController(Killer).ReceiveKillMessage(Killed.Class);
|
|
}
|
|
final function BroadcastFFDeath( Controller Killer, Pawn Killed, class<DamageType> damageType )
|
|
{
|
|
local ExtPlayerController E;
|
|
local PlayerReplicationInfo KillerPRI;
|
|
local string P;
|
|
local bool bFF;
|
|
|
|
P = Killed.PlayerReplicationInfo.PlayerName;
|
|
if( Killer==None || Killer==Killed.Controller )
|
|
{
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',E)
|
|
E.ClientZedKillMessage(damageType,P);
|
|
return;
|
|
}
|
|
bFF = (Killer.GetTeamNum()==0);
|
|
KillerPRI = Killer.PlayerReplicationInfo;
|
|
if( PlayerController(Killer)==None )
|
|
KillerPRI = None;
|
|
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',E)
|
|
E.ClientZedKillMessage(damageType,P,KillerPRI,Killer.Pawn.Class,bFF);
|
|
}
|
|
|
|
function NetDamage(int OriginalDamage, out int Damage, Pawn Injured, Controller InstigatedBy, vector HitLocation, out vector Momentum, class<DamageType> DamageType, Actor DamageCauser)
|
|
{
|
|
if (NextMutator != None)
|
|
NextMutator.NetDamage(OriginalDamage, Damage, Injured, InstigatedBy, HitLocation, Momentum, DamageType, DamageCauser);
|
|
|
|
if( LastDamageDealer!=None ) // Make sure no other damagers interfear with the old thing going on.
|
|
{
|
|
ClearTimer('CheckDamageDone');
|
|
CheckDamageDone();
|
|
}
|
|
if ( KFPawn_Monster(Injured) != None && InstigatedBy != none && InstigatedBy.GetTeamNum() == Injured.GetTeamNum() )
|
|
{
|
|
Momentum = vect(0,0,0);
|
|
Damage = 0;
|
|
return;
|
|
}
|
|
if( Damage>0 && InstigatedBy!=None )
|
|
{
|
|
if( KFPawn_Monster(Injured)!=None )
|
|
{
|
|
if( Injured.GetTeamNum()!=0 )
|
|
{
|
|
LastDamageDealer = ExtPlayerController(InstigatedBy);
|
|
if( bDamageMessages && LastDamageDealer!=None && !LastDamageDealer.bNoDamageTracking )
|
|
{
|
|
// Must delay this until next to get accurate damage dealt result.
|
|
LastHitZed = KFPawn(Injured);
|
|
LastHitHP = LastHitZed.Health;
|
|
LastDamagePosition = HitLocation;
|
|
SetTimer(0.001,false,'CheckDamageDone');
|
|
}
|
|
else
|
|
{
|
|
LastDamageDealer = None;
|
|
// Give credits to pet's owner.
|
|
if( Ext_T_MonsterPRI(InstigatedBy.PlayerReplicationInfo)!=None )
|
|
HackSetHistory(KFPawn(Injured),Injured,Ext_T_MonsterPRI(InstigatedBy.PlayerReplicationInfo).OwnerController,Damage,HitLocation);
|
|
}
|
|
}
|
|
else if( KFPawn(InstigatedBy.Pawn).GetTeamNum() != KFPawn(Injured).GetTeamNum() )
|
|
{
|
|
Momentum = vect(0,0,0);
|
|
Damage = 0;
|
|
}
|
|
}
|
|
else if( bDamageMessages && KFPawn_Human(Injured)!=None && Injured.GetTeamNum()==0 && InstigatedBy.GetTeamNum()!=0 && ExtPlayerController(InstigatedBy)!=None )
|
|
{
|
|
LastDamageDealer = ExtPlayerController(InstigatedBy);
|
|
if( bDamageMessages && !LastDamageDealer.bClientHideNumbers )
|
|
{
|
|
// Must delay this until next to get accurate damage dealt result.
|
|
LastHitZed = KFPawn(Injured);
|
|
LastHitHP = LastHitZed.Health;
|
|
LastDamagePosition = HitLocation;
|
|
SetTimer(0.001,false,'CheckDamageDone');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
final function CheckDamageDone()
|
|
{
|
|
local int Damage;
|
|
|
|
if( LastDamageDealer!=None && LastHitZed!=None && LastHitHP!=LastHitZed.Health )
|
|
{
|
|
Damage = LastHitHP-Max(LastHitZed.Health,0);
|
|
if( Damage>0 )
|
|
{
|
|
if( !LastDamageDealer.bClientHideDamageMsg && KFPawn_Monster(LastHitZed)!=None )
|
|
LastDamageDealer.ReceiveDamageMessage(LastHitZed.Class,Damage);
|
|
if( !LastDamageDealer.bClientHideNumbers )
|
|
LastDamageDealer.ClientNumberMsg(Damage,LastDamagePosition,DMG_PawnDamage);
|
|
}
|
|
}
|
|
LastDamageDealer = None;
|
|
}
|
|
final function HackSetHistory( KFPawn C, Pawn Injured, Controller Player, int Damage, vector HitLocation )
|
|
{
|
|
local int i;
|
|
local ExtPlayerController PC;
|
|
|
|
if( Player==None )
|
|
return;
|
|
PC = ExtPlayerController(Player);
|
|
if( bDamageMessages && PC!=None )
|
|
{
|
|
if( !PC.bClientHideDamageMsg )
|
|
PC.ReceiveDamageMessage(Injured.Class,Damage);
|
|
if( !PC.bClientHideNumbers )
|
|
PC.ClientNumberMsg(Damage,HitLocation,DMG_PawnDamage);
|
|
}
|
|
i = C.DamageHistory.Find('DamagerController',Player);
|
|
if( i==-1 )
|
|
{
|
|
i = C.DamageHistory.Length;
|
|
C.DamageHistory.Length = i+1;
|
|
C.DamageHistory[i].DamagerController = Player;
|
|
C.DamageHistory[i].DamagerPRI = Player.PlayerReplicationInfo;
|
|
C.DamageHistory[i].DamagePerks.AddItem(class'ExtPerkManager');
|
|
C.DamageHistory[i].Damage = Damage;
|
|
}
|
|
else if( (WorldInfo.TimeSeconds-C.DamageHistory[i].LastTimeDamaged)<10 )
|
|
C.DamageHistory[i].Damage += Damage;
|
|
else C.DamageHistory[i].Damage = Damage;
|
|
|
|
C.DamageHistory[i].LastTimeDamaged = WorldInfo.TimeSeconds;
|
|
C.DamageHistory[i].TotalDamage += Damage;
|
|
}
|
|
|
|
function bool HandleRestartGame()
|
|
{
|
|
if( !bGameHasEnded )
|
|
{
|
|
SaveAllPerks(true);
|
|
bGameHasEnded = true;
|
|
}
|
|
return Super.HandleRestartGame();
|
|
}
|
|
|
|
function NotifyLogout(Controller Exiting)
|
|
{
|
|
if( KFPlayerController(Exiting)!=None )
|
|
RemoveRespawn(Exiting);
|
|
if( !bGameHasEnded && ExtPlayerController(Exiting)!=None )
|
|
{
|
|
CheckPerkChange(ExtPlayerController(Exiting));
|
|
SavePlayerPerk(ExtPlayerController(Exiting));
|
|
}
|
|
if ( NextMutator != None )
|
|
NextMutator.NotifyLogout(Exiting);
|
|
}
|
|
function NotifyLogin(Controller NewPlayer)
|
|
{
|
|
if( ExtPlayerController(NewPlayer)!=None )
|
|
{
|
|
if( ExtPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo)!=None )
|
|
InitCustomChars(ExtPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo));
|
|
if( bAddCountryTags && NetConnection(PlayerController(NewPlayer).Player)!=None )
|
|
ExtPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo).SetPlayerNameTag(class'CtryDatabase'.Static.GetClientCountryStr(PlayerController(NewPlayer).GetPlayerNetworkAddress()));
|
|
ExtPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo).bIsDev = IsDev(NewPlayer.PlayerReplicationInfo.UniqueId);
|
|
if( WorldInfo.NetMode!=NM_StandAlone )
|
|
ExtPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo).OnRepNextItem = GetNextItem;
|
|
if( BonusGameCue!=None || BonusGameFXObj!=None )
|
|
ExtPlayerController(NewPlayer).ClientSetBonus(BonusGameCue,BonusGameFXObj);
|
|
if( bRespawnCheck )
|
|
CheckRespawn(NewPlayer);
|
|
if( !bGameHasEnded )
|
|
InitializePerks(ExtPlayerController(NewPlayer));
|
|
SendMOTD(ExtPlayerController(NewPlayer));
|
|
}
|
|
if ( NextMutator != None )
|
|
NextMutator.NotifyLogin(NewPlayer);
|
|
}
|
|
final function InitializePerks( ExtPlayerController Other )
|
|
{
|
|
local ExtPerkManager PM;
|
|
local Ext_PerkBase P;
|
|
local int i;
|
|
|
|
Other.OnChangePerk = PlayerChangePerk;
|
|
Other.OnBoughtStats = PlayerBuyStats;
|
|
Other.OnBoughtTrait = PlayerBoughtTrait;
|
|
Other.OnPerkReset = ResetPlayerPerk;
|
|
Other.OnAdminHandle = AdminCommand;
|
|
Other.OnSetMOTD = AdminSetMOTD;
|
|
Other.OnRequestUnload = PlayerUnloadInfo;
|
|
Other.OnSpectateChange = PlayerChangeSpec;
|
|
Other.OnClientGetStat = class'ExtStatList'.Static.GetStat;
|
|
PM = Other.ActivePerkManager;
|
|
PM.InitPerks();
|
|
for( i=0; i<LoadedPerks.Length; ++i )
|
|
{
|
|
P = Spawn(LoadedPerks[i],Other);
|
|
PM.RegisterPerk(P);
|
|
}
|
|
ServerStatLoader.FlushData();
|
|
if( ServerStatLoader.LoadStatFile(Other) )
|
|
{
|
|
ServerStatLoader.ToStart();
|
|
PM.LoadData(ServerStatLoader);
|
|
if( Default.MaxTopPlayers>0 )
|
|
class'ExtStatList'.Static.SetTopPlayers(Other);
|
|
}
|
|
PM.ServerInitPerks();
|
|
PM.InitiateClientRep();
|
|
}
|
|
final function SendMOTD( ExtPlayerController PC )
|
|
{
|
|
local string S;
|
|
local int i;
|
|
|
|
S = ServerMOTD;
|
|
while( Len(S)>510 )
|
|
{
|
|
PC.ReceiveServerMOTD(Left(S,500),false);
|
|
S = Mid(S,500);
|
|
}
|
|
PC.ReceiveServerMOTD(S,true);
|
|
|
|
for( i=0; i<AdminCommands.Length; ++i )
|
|
PC.AddAdminCmd(AdminCommands[i]);
|
|
}
|
|
final function SavePlayerPerk( ExtPlayerController PC )
|
|
{
|
|
if( PC.ActivePerkManager!=None && PC.ActivePerkManager.bStatsDirty )
|
|
{
|
|
// Verify broken stats.
|
|
if( PC.ActivePerkManager.bUserStatsBroken )
|
|
{
|
|
PC.ClientMessage("Warning: Your stats are broken, not saving.",'Priority');
|
|
return;
|
|
}
|
|
ServerStatLoader.FlushData();
|
|
if( ServerStatLoader.LoadStatFile(PC) && ServerStatLoader.GetSaveVersion()!=PC.ActivePerkManager.UserDataVersion )
|
|
{
|
|
PC.ActivePerkManager.bUserStatsBroken = true;
|
|
PC.ClientMessage("Warning: Your stats save data version differs from what is loaded, stat saving disabled to prevent stats loss.",'Priority');
|
|
return;
|
|
}
|
|
|
|
// Actually save.
|
|
ServerStatLoader.FlushData();
|
|
PC.ActivePerkManager.SaveData(ServerStatLoader);
|
|
ServerStatLoader.SaveStatFile(PC);
|
|
PC.ActivePerkManager.bStatsDirty = false;
|
|
|
|
// Write XML output.
|
|
if( FileOutput!=None )
|
|
FileOutput.DumpXML(PC.ActivePerkManager);
|
|
}
|
|
}
|
|
function SaveAllPerks( optional bool bOnEndGame )
|
|
{
|
|
local ExtPlayerController PC;
|
|
|
|
if( bGameHasEnded )
|
|
return;
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',PC)
|
|
if( PC.ActivePerkManager!=None && PC.ActivePerkManager.bStatsDirty )
|
|
{
|
|
if( bOnEndGame )
|
|
CheckPerkChange(PC);
|
|
SavePlayerPerk(PC);
|
|
}
|
|
}
|
|
|
|
function CheckRespawn( Controller PC )
|
|
{
|
|
if( !PC.bIsPlayer || ExtPlayerReplicationInfo(PC.PlayerReplicationInfo)==None || PC.PlayerReplicationInfo.bOnlySpectator || WorldInfo.Game.bWaitingToStartMatch || WorldInfo.Game.bGameEnded )
|
|
return;
|
|
|
|
// VS redead.
|
|
if( ExtHumanPawn(PC.Pawn)!=None && ExtHumanPawn(PC.Pawn).bPendingRedead )
|
|
return;
|
|
|
|
if( bIsPostGame && PC.PlayerReplicationInfo.Score<PostGameRespawnCost )
|
|
{
|
|
if( PlayerController(PC)!=None )
|
|
PlayerController(PC).ClientMessage("You can't afford to respawn anymore (need "$PostGameRespawnCost@Chr(163)$")!",'LowCriticalEvent');
|
|
return;
|
|
}
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = PlayerRespawnTime;
|
|
PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
if( PendingSpawners.Find(PC)<0 )
|
|
PendingSpawners.AddItem(PC);
|
|
}
|
|
function RemoveRespawn( Controller PC )
|
|
{
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = -1;
|
|
PendingSpawners.RemoveItem(PC);
|
|
}
|
|
|
|
final function InitPlayer( ExtHumanPawn Other )
|
|
{
|
|
local ExtPlayerReplicationInfo PRI;
|
|
|
|
PRI = ExtPlayerReplicationInfo(Other.PlayerReplicationInfo);
|
|
if( PRI!=None && PRI.PerkManager!=None && PRI.PerkManager.CurrentPerk!=None )
|
|
PRI.PerkManager.CurrentPerk.ApplyEffectsTo(Other);
|
|
Other.bRagdollFromFalling = bRagdollFromFall;
|
|
Other.bRagdollFromMomentum = bRagdollFromMomentum;
|
|
Other.bRagdollFromBackhit = bRagdollFromBackhit;
|
|
}
|
|
function ModifyPlayer(Pawn Other)
|
|
{
|
|
if( ExtHumanPawn(Other)!=None )
|
|
InitPlayer(ExtHumanPawn(Other));
|
|
if ( NextMutator != None )
|
|
NextMutator.ModifyPlayer(Other);
|
|
}
|
|
|
|
function Timer()
|
|
{
|
|
local int i;
|
|
local Controller PC;
|
|
local bool bSpawned,bAllDead;
|
|
|
|
bAllDead = (KFGameInfo(WorldInfo.Game).GetLivingPlayerCount()<=0 || WorldInfo.Game.bGameEnded || !bRespawnCheck);
|
|
for( i=0; i<PendingSpawners.Length; ++i )
|
|
{
|
|
PC = PendingSpawners[i];
|
|
if( bAllDead || PC==None || PC.PlayerReplicationInfo.bOnlySpectator || (PC.Pawn!=None && PC.Pawn.IsAliveAndWell()) )
|
|
{
|
|
if( PC!=None )
|
|
{
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = -1;
|
|
PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
}
|
|
PendingSpawners.Remove(i--,1);
|
|
}
|
|
else if( bIsPostGame && PC.PlayerReplicationInfo.Score<PostGameRespawnCost )
|
|
{
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = -1;
|
|
PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
|
|
if( PlayerController(PC)!=None )
|
|
PlayerController(PC).ClientMessage("You can't afford to respawn anymore (need "$PostGameRespawnCost@Chr(163)$")!",'LowCriticalEvent');
|
|
PendingSpawners.Remove(i--,1);
|
|
}
|
|
else if( --ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter<=0 )
|
|
{
|
|
PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = 0;
|
|
if( !bSpawned ) // Spawn only one player at time (so game doesn't crash if many players spawn in same time).
|
|
{
|
|
bSpawned = true;
|
|
if( RespawnPlayer(PC) )
|
|
{
|
|
if( bIsPostGame )
|
|
{
|
|
if( PlayerController(PC)!=None )
|
|
PlayerController(PC).ClientMessage("This respawn cost you "$PostGameRespawnCost@Chr(163)$"!",'LowCriticalEvent');
|
|
PC.PlayerReplicationInfo.Score-=PostGameRespawnCost;
|
|
}
|
|
ExtPlayerReplicationInfo(PC.PlayerReplicationInfo).RespawnCounter = -1;
|
|
PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
}
|
|
}
|
|
}
|
|
else PC.PlayerReplicationInfo.bForceNetUpdate = true;
|
|
}
|
|
}
|
|
final function SavePlayerInventory()
|
|
{
|
|
local KFPawn_Human P;
|
|
local int i,j;
|
|
local Inventory Inv;
|
|
local KFWeapon K;
|
|
|
|
PlayerInv.Length = 0;
|
|
i = 0;
|
|
foreach WorldInfo.AllPawns(class'KFPawn_Human',P)
|
|
if( P.IsAliveAndWell() && P.InvManager!=None && P.Controller!=None && P.Controller.PlayerReplicationInfo!=None )
|
|
{
|
|
PlayerInv.Length = i+1;
|
|
PlayerInv[i].OwnerPlayer = P.Controller;
|
|
PlayerInv[i].Gren = KFInventoryManager(P.InvManager).GrenadeCount;
|
|
j = 0;
|
|
|
|
foreach P.InvManager.InventoryActors(class'Inventory',Inv)
|
|
{
|
|
if( KFInventory_Money(Inv)!=None )
|
|
continue;
|
|
K = KFWeapon(Inv);
|
|
if( K!=None && !K.bCanThrow ) // Skip non-throwable items.
|
|
continue;
|
|
PlayerInv[i].Inv.Length = j+1;
|
|
PlayerInv[i].Inv[j].ItemClass = Inv.Class;
|
|
if( K!=None )
|
|
{
|
|
PlayerInv[i].Inv[j].Values[0] = K.SpareAmmoCount[0];
|
|
PlayerInv[i].Inv[j].Values[1] = K.SpareAmmoCount[1];
|
|
PlayerInv[i].Inv[j].Values[2] = K.AmmoCount[0];
|
|
PlayerInv[i].Inv[j].Values[3] = K.AmmoCount[1];
|
|
}
|
|
++j;
|
|
}
|
|
++i;
|
|
}
|
|
}
|
|
final function bool AddPlayerSpecificInv( Pawn Other )
|
|
{
|
|
local int i,j;
|
|
local Inventory Inv;
|
|
local KFWeapon K;
|
|
|
|
for( i=(PlayerInv.Length-1); i>=0; --i )
|
|
if( PlayerInv[i].OwnerPlayer==Other.Controller )
|
|
{
|
|
KFInventoryManager(Other.InvManager).bInfiniteWeight = true;
|
|
KFInventoryManager(Other.InvManager).GrenadeCount = PlayerInv[i].Gren;
|
|
for( j=(PlayerInv[i].Inv.Length-1); j>=0; --j )
|
|
{
|
|
Inv = Other.InvManager.FindInventoryType(PlayerInv[i].Inv[j].ItemClass,false);
|
|
if( Inv==None )
|
|
{
|
|
Inv = Other.InvManager.CreateInventory(PlayerInv[i].Inv[j].ItemClass);
|
|
}
|
|
K = KFWeapon(Inv);
|
|
if( K!=None )
|
|
{
|
|
K.SpareAmmoCount[0] = PlayerInv[i].Inv[j].Values[0];
|
|
K.SpareAmmoCount[1] = PlayerInv[i].Inv[j].Values[1];
|
|
K.AmmoCount[0] = PlayerInv[i].Inv[j].Values[2];
|
|
K.AmmoCount[1] = PlayerInv[i].Inv[j].Values[3];
|
|
K.ClientForceAmmoUpdate(K.AmmoCount[0],K.SpareAmmoCount[0]);
|
|
K.ClientForceSecondaryAmmoUpdate(K.AmmoCount[1]);
|
|
}
|
|
}
|
|
if( Other.InvManager.FindInventoryType(class'KFInventory_Money',true)==None )
|
|
Other.InvManager.CreateInventory(class'KFInventory_Money');
|
|
KFInventoryManager(Other.InvManager).bInfiniteWeight = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
final function Pawn SpawnDefaultPawnFor(Controller NewPlayer, Actor StartSpot) // Clone of GameInfo one, but with Actor StartSpot.
|
|
{
|
|
local class<Pawn> PlayerClass;
|
|
local Rotator R;
|
|
local Pawn ResultPawn;
|
|
|
|
PlayerClass = WorldInfo.Game.GetDefaultPlayerClass(NewPlayer);
|
|
R.Yaw = StartSpot.Rotation.Yaw;
|
|
ResultPawn = Spawn(PlayerClass,,,StartSpot.Location,R,,true);
|
|
return ResultPawn;
|
|
}
|
|
final function bool RespawnPlayer( Controller NewPlayer )
|
|
{
|
|
local KFPlayerReplicationInfo KFPRI;
|
|
local KFPlayerController KFPC;
|
|
local Actor startSpot;
|
|
local int Idx;
|
|
local array<SequenceObject> Events;
|
|
local SeqEvent_PlayerSpawned SpawnedEvent;
|
|
local LocalPlayer LP;
|
|
|
|
if( NewPlayer.Pawn!=None )
|
|
NewPlayer.Pawn.Destroy();
|
|
|
|
// figure out the team number and find the start spot
|
|
StartSpot = SpawnPointer.PickBestSpawn();
|
|
|
|
// if a start spot wasn't found,
|
|
if (startSpot == None)
|
|
{
|
|
// check for a previously assigned spot
|
|
if (NewPlayer.StartSpot != None)
|
|
{
|
|
StartSpot = NewPlayer.StartSpot;
|
|
`warn("Player start not found, using last start spot");
|
|
}
|
|
else
|
|
{
|
|
// otherwise abort
|
|
`warn("Player start not found, failed to restart player");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// try to create a pawn to use of the default class for this player
|
|
NewPlayer.Pawn = SpawnDefaultPawnFor(NewPlayer, StartSpot);
|
|
|
|
if (NewPlayer.Pawn == None)
|
|
{
|
|
NewPlayer.GotoState('Dead');
|
|
if ( PlayerController(NewPlayer) != None )
|
|
PlayerController(NewPlayer).ClientGotoState('Dead','Begin');
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// initialize and start it up
|
|
if( NavigationPoint(startSpot)!=None )
|
|
NewPlayer.Pawn.SetAnchor(NavigationPoint(startSpot));
|
|
if ( PlayerController(NewPlayer) != None )
|
|
{
|
|
PlayerController(NewPlayer).TimeMargin = -0.1;
|
|
if( NavigationPoint(startSpot)!=None )
|
|
NavigationPoint(startSpot).AnchoredPawn = None; // SetAnchor() will set this since IsHumanControlled() won't return true for the Pawn yet
|
|
}
|
|
NewPlayer.Pawn.LastStartSpot = PlayerStart(startSpot);
|
|
NewPlayer.Pawn.LastStartTime = WorldInfo.TimeSeconds;
|
|
NewPlayer.Possess(NewPlayer.Pawn, false);
|
|
NewPlayer.Pawn.PlayTeleportEffect(true, true);
|
|
NewPlayer.ClientSetRotation(NewPlayer.Pawn.Rotation, TRUE);
|
|
|
|
if ( !WorldInfo.bNoDefaultInventoryForPlayer )
|
|
{
|
|
AddPlayerSpecificInv(NewPlayer.Pawn);
|
|
WorldInfo.Game.AddDefaultInventory(NewPlayer.Pawn);
|
|
}
|
|
WorldInfo.Game.SetPlayerDefaults(NewPlayer.Pawn);
|
|
|
|
// activate spawned events
|
|
if (WorldInfo.GetGameSequence() != None)
|
|
{
|
|
WorldInfo.GetGameSequence().FindSeqObjectsByClass(class'SeqEvent_PlayerSpawned',TRUE,Events);
|
|
for (Idx = 0; Idx < Events.Length; Idx++)
|
|
{
|
|
SpawnedEvent = SeqEvent_PlayerSpawned(Events[Idx]);
|
|
if (SpawnedEvent != None &&
|
|
SpawnedEvent.CheckActivate(NewPlayer,NewPlayer))
|
|
{
|
|
SpawnedEvent.SpawnPoint = startSpot;
|
|
SpawnedEvent.PopulateLinkedVariableValues();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
KFPC = KFPlayerController(NewPlayer);
|
|
KFPRI = KFPlayerReplicationInfo(NewPlayer.PlayerReplicationInfo);
|
|
|
|
// To fix custom post processing chain when not running in editor or PIE.
|
|
if (KFPC != none)
|
|
{
|
|
LP = LocalPlayer(KFPC.Player);
|
|
if(LP != None)
|
|
{
|
|
LP.RemoveAllPostProcessingChains();
|
|
LP.InsertPostProcessingChain(LP.Outer.GetWorldPostProcessChain(),INDEX_NONE,true);
|
|
if(KFPC.myHUD != None)
|
|
{
|
|
KFPC.myHUD.NotifyBindPostProcessEffects();
|
|
}
|
|
}
|
|
}
|
|
|
|
KFGameInfo(WorldInfo.Game).SetTeam( NewPlayer, KFGameInfo(WorldInfo.Game).Teams[0] );
|
|
|
|
if( KFPC != none )
|
|
{
|
|
// Initialize game play post process effects such as damage, low health, etc.
|
|
KFPC.InitGameplayPostProcessFX();
|
|
}
|
|
if( KFPRI!=None )
|
|
{
|
|
if( KFPRI.Deaths == 0 )
|
|
KFPRI.Score = KFGameInfo(WorldInfo.Game).DifficultyInfo.GetAdjustedStartingCash();
|
|
KFPRI.PlayerHealth = NewPlayer.Pawn.Health;
|
|
KFPRI.PlayerHealthPercent = FloatToByte( float(NewPlayer.Pawn.Health) / float(NewPlayer.Pawn.HealthMax) );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function PlayerBuyStats( ExtPlayerController PC, class<Ext_PerkBase> Perk, int iStat, int Amount )
|
|
{
|
|
local Ext_PerkBase P;
|
|
local int i;
|
|
|
|
if( bGameHasEnded )
|
|
return;
|
|
|
|
P = PC.ActivePerkManager.FindPerk(Perk);
|
|
if( P==None || !P.bPerkNetReady || iStat>=P.PerkStats.Length )
|
|
return;
|
|
Amount = Min(Amount,P.PerkStats[iStat].MaxValue-P.PerkStats[iStat].CurrentValue);
|
|
if( Amount<=0 )
|
|
return;
|
|
i = Amount*P.PerkStats[iStat].CostPerValue;
|
|
if( i>P.CurrentSP )
|
|
{
|
|
Amount = P.CurrentSP/P.PerkStats[iStat].CostPerValue;
|
|
if( Amount<=0 )
|
|
return;
|
|
i = Amount*P.PerkStats[iStat].CostPerValue;
|
|
}
|
|
P.CurrentSP-=i;
|
|
if( !P.IncrementStat(iStat,Amount) )
|
|
PC.ClientMessage("Failed to buy stat.");
|
|
}
|
|
function PlayerChangePerk( ExtPlayerController PC, class<Ext_PerkBase> NewPerk )
|
|
{
|
|
if( bGameHasEnded )
|
|
return;
|
|
if( NewPerk==PC.ActivePerkManager.CurrentPerk.Class )
|
|
{
|
|
if( PC.PendingPerkClass!=None )
|
|
{
|
|
PC.ClientMessage("You will remain the same perk now.");
|
|
PC.PendingPerkClass = None;
|
|
}
|
|
}
|
|
else if( PC.ActivePerkManager.CurrentPerk==None || KFPawn_Customization(PC.Pawn)!=None || (!PC.bSetPerk && KFGameReplicationInfo(WorldInfo.GRI).bTraderIsOpen) )
|
|
{
|
|
if( PC.ActivePerkManager.ApplyPerkClass(NewPerk) )
|
|
{
|
|
PC.ClientMessage("You have changed your perk to "$NewPerk.Default.PerkName);
|
|
PC.bSetPerk = true;
|
|
}
|
|
else PC.ClientMessage("Invalid perk "$NewPerk.Default.PerkName);
|
|
}
|
|
else if( PC.bSetPerk )
|
|
PC.ClientMessage("Can only change perks once per wave");
|
|
else
|
|
{
|
|
PC.ClientMessage("You will change to perk '"$NewPerk.Default.PerkName$"' during trader time.");
|
|
PC.PendingPerkClass = NewPerk;
|
|
}
|
|
}
|
|
function CheckPerkChange( ExtPlayerController PC )
|
|
{
|
|
if( PC.PendingPerkClass!=None )
|
|
{
|
|
if( PC.ActivePerkManager.ApplyPerkClass(PC.PendingPerkClass) )
|
|
{
|
|
PC.ClientMessage("You have changed your perk to "$PC.PendingPerkClass.Default.PerkName);
|
|
PC.bSetPerk = true;
|
|
}
|
|
else PC.ClientMessage("Invalid perk "$PC.PendingPerkClass.Default.PerkName);
|
|
PC.PendingPerkClass = None;
|
|
}
|
|
}
|
|
function Tick(float DeltaTime)
|
|
{
|
|
local bool bCheckedWave;
|
|
local ExtPlayerController ExtPC;
|
|
|
|
if( KFGameReplicationInfo(WorldInfo.GRI).bTraderIsOpen && !bCheckedWave )
|
|
{
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',ExtPC)
|
|
CheckPerkChange(ExtPC);
|
|
|
|
bCheckedWave = true;
|
|
}
|
|
else if( bCheckedWave )
|
|
bCheckedWave = false;
|
|
}
|
|
function PlayerBoughtTrait( ExtPlayerController PC, class<Ext_PerkBase> PerkClass, class<Ext_TraitBase> Trait )
|
|
{
|
|
local Ext_PerkBase P;
|
|
local int i,cost;
|
|
|
|
if( bGameHasEnded )
|
|
return;
|
|
|
|
P = PC.ActivePerkManager.FindPerk(PerkClass);
|
|
if( P==None || !P.bPerkNetReady )
|
|
return;
|
|
|
|
for( i=0; i<P.PerkTraits.Length; ++i )
|
|
{
|
|
if( P.PerkTraits[i].TraitType==Trait )
|
|
{
|
|
if( P.PerkTraits[i].CurrentLevel>=Trait.Default.NumLevels )
|
|
return;
|
|
cost = Trait.Static.GetTraitCost(P.PerkTraits[i].CurrentLevel);
|
|
if( cost>P.CurrentSP || !Trait.Static.MeetsRequirements(P.PerkTraits[i].CurrentLevel,P) )
|
|
return;
|
|
|
|
PC.ActivePerkManager.bStatsDirty = true;
|
|
P.CurrentSP-=cost;
|
|
P.bForceNetUpdate = true;
|
|
++P.PerkTraits[i].CurrentLevel;
|
|
P.ClientReceiveTraitLvl(i,P.PerkTraits[i].CurrentLevel);
|
|
if( P.PerkTraits[i].CurrentLevel==1 )
|
|
P.PerkTraits[i].Data = Trait.Static.InitializeFor(P,PC);
|
|
|
|
if( PC.ActivePerkManager.CurrentPerk==P )
|
|
{
|
|
Trait.Static.TraitDeActivate(P,P.PerkTraits[i].CurrentLevel-1,P.PerkTraits[i].Data);
|
|
Trait.Static.TraitActivate(P,P.PerkTraits[i].CurrentLevel,P.PerkTraits[i].Data);
|
|
if( KFPawn_Human(PC.Pawn)!=None )
|
|
{
|
|
Trait.Static.CancelEffectOn(KFPawn_Human(PC.Pawn),P,P.PerkTraits[i].CurrentLevel-1,P.PerkTraits[i].Data);
|
|
Trait.Static.ApplyEffectOn(KFPawn_Human(PC.Pawn),P,P.PerkTraits[i].CurrentLevel,P.PerkTraits[i].Data);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function PlayerUnloadInfo( ExtPlayerController PC, byte CallID, class<Ext_PerkBase> PerkClass, bool bUnload )
|
|
{
|
|
local Ext_PerkBase P;
|
|
local int LostExp,NewLvl;
|
|
|
|
// Verify if client tries to cause errors.
|
|
if( PC==None || PerkClass==None || PC.ActivePerkManager==None )
|
|
return;
|
|
|
|
// Perk unloading disabled on this server.
|
|
if( MinUnloadPerkLevel==-1 )
|
|
{
|
|
if( !bUnload )
|
|
PC.ClientGotUnloadInfo(CallID,0);
|
|
return;
|
|
}
|
|
|
|
P = PC.ActivePerkManager.FindPerk(PerkClass);
|
|
if( P==None ) // More client hack attempts.
|
|
return;
|
|
|
|
if( P.CurrentLevel<MinUnloadPerkLevel ) // Verify minimum level.
|
|
{
|
|
if( !bUnload )
|
|
PC.ClientGotUnloadInfo(CallID,1,MinUnloadPerkLevel);
|
|
return;
|
|
}
|
|
|
|
// Calc how much EXP is lost on this progress.
|
|
LostExp = Round(float(P.CurrentEXP) * UnloadPerkExpCost);
|
|
|
|
if( !bUnload )
|
|
{
|
|
if( LostExp==0 ) // Generous server admin!
|
|
PC.ClientGotUnloadInfo(CallID,2,0,0);
|
|
else
|
|
{
|
|
// Calc how many levels are dropped.
|
|
NewLvl = P.CalcLevelForExp(P.CurrentEXP-LostExp);
|
|
PC.ClientGotUnloadInfo(CallID,2,LostExp,P.CurrentLevel-NewLvl);
|
|
}
|
|
return;
|
|
}
|
|
P.UnloadStats();
|
|
P.CurrentEXP -= LostExp;
|
|
P.SetInitialLevel();
|
|
PC.ActivePerkManager.PRIOwner.SetLevelProgress(P.CurrentLevel,P.CurrentPrestige,P.MinimumLevel,P.MaximumLevel);
|
|
if( PC.Pawn!=None )
|
|
PC.Pawn.Suicide();
|
|
}
|
|
|
|
|
|
function ResetPlayerPerk( ExtPlayerController PC, class<Ext_PerkBase> PerkClass, bool bPrestige )
|
|
{
|
|
local Ext_PerkBase P;
|
|
|
|
if( bGameHasEnded )
|
|
return;
|
|
|
|
P = PC.ActivePerkManager.FindPerk(PerkClass);
|
|
if( P==None || !P.bPerkNetReady )
|
|
return;
|
|
if( bPrestige )
|
|
{
|
|
if( !P.CanPrestige() )
|
|
{
|
|
PC.ClientMessage("Prestige for this perk is not allowed.");
|
|
return;
|
|
}
|
|
++P.CurrentPrestige;
|
|
}
|
|
P.FullReset(bPrestige);
|
|
}
|
|
|
|
function bool CheckReplacement(Actor Other)
|
|
{
|
|
if( bNoBoomstickJumping && KFWeap_Shotgun_DoubleBarrel(Other)!=None )
|
|
KFWeap_Shotgun_DoubleBarrel(Other).DoubleBarrelKickMomentum = 5.f;
|
|
return true;
|
|
}
|
|
|
|
final function InitCustomChars( ExtPlayerReplicationInfo PRI )
|
|
{
|
|
PRI.CustomCharList = CustomCharList;
|
|
}
|
|
|
|
final function bool HasPrivs( ExtPlayerReplicationInfo P )
|
|
{
|
|
return WorldInfo.NetMode==NM_StandAlone || (P!=None && P.ShowAdminName() && (P.AdminType<=1 || P.AdminType==255));
|
|
}
|
|
function AdminCommand( ExtPlayerController PC, int PlayerID, int Action )
|
|
{
|
|
local ExtPlayerController E;
|
|
local int i;
|
|
|
|
if( bNoAdminCommands )
|
|
{
|
|
PC.ClientMessage("Admin level commands are disabled.",'Priority');
|
|
return;
|
|
}
|
|
if( !HasPrivs(ExtPlayerReplicationInfo(PC.PlayerReplicationInfo)) )
|
|
{
|
|
PC.ClientMessage("You do not have enough admin priveleges.",'Priority');
|
|
return;
|
|
}
|
|
|
|
foreach WorldInfo.AllControllers(class'ExtPlayerController',E)
|
|
if( E.PlayerReplicationInfo.PlayerID==PlayerID )
|
|
break;
|
|
|
|
if( E==None )
|
|
{
|
|
PC.ClientMessage("Action failed, missing playerID: "$PlayerID,'Priority');
|
|
return;
|
|
}
|
|
|
|
if( Action>=100 ) // Set perk level.
|
|
{
|
|
if( E.ActivePerkManager.CurrentPerk==None )
|
|
{
|
|
PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
return;
|
|
}
|
|
if( Action>=100000 ) // Set prestige level.
|
|
{
|
|
if( E.ActivePerkManager.CurrentPerk.MinLevelForPrestige<0 )
|
|
{
|
|
PC.ClientMessage("Perk "$E.ActivePerkManager.CurrentPerk.Default.PerkName$" has prestige disabled!",'Priority');
|
|
return;
|
|
}
|
|
Action = Min(Action-100000,E.ActivePerkManager.CurrentPerk.MaxPrestige);
|
|
E.ActivePerkManager.CurrentPerk.CurrentPrestige = Action;
|
|
PC.ClientMessage("Set "$E.PlayerReplicationInfo.PlayerName$"' perk "$E.ActivePerkManager.CurrentPerk.Default.PerkName$" prestige level to "$Action,'Priority');
|
|
|
|
E.ActivePerkManager.CurrentPerk.FullReset(true);
|
|
}
|
|
else
|
|
{
|
|
Action = Clamp(Action-100,E.ActivePerkManager.CurrentPerk.MinimumLevel,E.ActivePerkManager.CurrentPerk.MaximumLevel);
|
|
E.ActivePerkManager.CurrentPerk.CurrentEXP = E.ActivePerkManager.CurrentPerk.GetNeededExp(Action-1);
|
|
PC.ClientMessage("Set "$E.PlayerReplicationInfo.PlayerName$"' perk "$E.ActivePerkManager.CurrentPerk.Default.PerkName$" level to "$Action,'Priority');
|
|
|
|
E.ActivePerkManager.CurrentPerk.SetInitialLevel();
|
|
E.ActivePerkManager.CurrentPerk.UpdatePRILevel();
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch( Action )
|
|
{
|
|
case 0: // Reset ALL Stats
|
|
for( i=0; i<E.ActivePerkManager.UserPerks.Length; ++i )
|
|
E.ActivePerkManager.UserPerks[i].FullReset();
|
|
PC.ClientMessage("Reset EVERY perk for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
break;
|
|
case 1: // Reset Current Perk Stats
|
|
if( E.ActivePerkManager.CurrentPerk!=None )
|
|
{
|
|
E.ActivePerkManager.CurrentPerk.FullReset();
|
|
PC.ClientMessage("Reset perk "$E.ActivePerkManager.CurrentPerk.Default.PerkName$" for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
}
|
|
else PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
break;
|
|
case 2: // Add 1,000 XP
|
|
case 3: // Add 10,000 XP
|
|
case 4: // Advance Perk Level
|
|
if( E.ActivePerkManager.CurrentPerk!=None )
|
|
{
|
|
if( Action==2 )
|
|
i = 1000;
|
|
else if( Action==3 )
|
|
i = 10000;
|
|
else i = Max(E.ActivePerkManager.CurrentPerk.NextLevelEXP - E.ActivePerkManager.CurrentPerk.CurrentEXP,0);
|
|
E.ActivePerkManager.EarnedEXP(i);
|
|
PC.ClientMessage("Gave "$i$" XP for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
}
|
|
else PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
break;
|
|
case 5: // Unload all stats
|
|
if( E.ActivePerkManager.CurrentPerk!=None )
|
|
{
|
|
E.ActivePerkManager.CurrentPerk.UnloadStats(1);
|
|
PC.ClientMessage("Unloaded all stats for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
}
|
|
else PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
break;
|
|
case 6: // Unload all traits
|
|
if( E.ActivePerkManager.CurrentPerk!=None )
|
|
{
|
|
E.ActivePerkManager.CurrentPerk.UnloadStats(2);
|
|
PC.ClientMessage("Unloaded all traits for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
}
|
|
else PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
break;
|
|
case 7: // Remove 1,000 XP
|
|
case 8: // Remove 10,000 XP
|
|
if( E.ActivePerkManager.CurrentPerk!=None )
|
|
{
|
|
if( Action==6 )
|
|
i = 1000;
|
|
else i = 10000;
|
|
E.ActivePerkManager.CurrentPerk.CurrentEXP = Max(E.ActivePerkManager.CurrentPerk.CurrentEXP-i,0);
|
|
PC.ClientMessage("Removed "$i$" XP from "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
}
|
|
else PC.ClientMessage(E.PlayerReplicationInfo.PlayerName$" has no perk selected!!!",'Priority');
|
|
break;
|
|
case 9: // Show Debug Info
|
|
PC.ClientMessage("DEBUG info for "$E.PlayerReplicationInfo.PlayerName,'Priority');
|
|
PC.ClientMessage("PerkManager "$E.ActivePerkManager$" Current Perk: "$E.ActivePerkManager.CurrentPerk,'Priority');
|
|
PC.ClientMessage("Perks Count: "$E.ActivePerkManager.UserPerks.Length,'Priority');
|
|
for( i=0; i<E.ActivePerkManager.UserPerks.Length; ++i )
|
|
PC.ClientMessage("Perk "$i$": "$E.ActivePerkManager.UserPerks[i]$" XP:"$E.ActivePerkManager.UserPerks[i].CurrentEXP$" Lv:"$E.ActivePerkManager.UserPerks[i].CurrentLevel$" Rep:"$E.ActivePerkManager.UserPerks[i].bPerkNetReady,'Priority');
|
|
break;
|
|
default:
|
|
PC.ClientMessage("Unknown admin action.",'Priority');
|
|
}
|
|
}
|
|
function AdminSetMOTD( ExtPlayerController PC, string S )
|
|
{
|
|
if( !HasPrivs(ExtPlayerReplicationInfo(PC.PlayerReplicationInfo)) )
|
|
return;
|
|
ServerMOTD = S;
|
|
SaveConfig();
|
|
PC.ClientMessage("Message of the Day updated.",'Priority');
|
|
}
|
|
|
|
function PlayerChangeSpec( ExtPlayerController PC, bool bSpectator )
|
|
{
|
|
if( bSpectator==PC.PlayerReplicationInfo.bOnlySpectator || PC.NextSpectateChange>WorldInfo.TimeSeconds )
|
|
return;
|
|
PC.NextSpectateChange = WorldInfo.TimeSeconds+0.5;
|
|
|
|
if( WorldInfo.Game.bGameEnded )
|
|
PC.ClientMessage("Can't change spectate mode after end-game.");
|
|
else if( WorldInfo.Game.bWaitingToStartMatch )
|
|
PC.ClientMessage("Can't change spectate mode before game has started.");
|
|
else if( WorldInfo.Game.AtCapacity(bSpectator,PC.PlayerReplicationInfo.UniqueId) )
|
|
PC.ClientMessage("Can't change spectate mode because game is at its maximum capacity.");
|
|
else if( bSpectator )
|
|
{
|
|
PC.NextSpectateChange = WorldInfo.TimeSeconds+2.5;
|
|
if( PC.PlayerReplicationInfo.Team!=None )
|
|
PC.PlayerReplicationInfo.Team.RemoveFromTeam(PC);
|
|
PC.PlayerReplicationInfo.bOnlySpectator = true;
|
|
if( PC.Pawn!=None )
|
|
PC.Pawn.KilledBy(None);
|
|
PC.Reset();
|
|
--WorldInfo.Game.NumPlayers;
|
|
++WorldInfo.Game.NumSpectators;
|
|
WorldInfo.Game.Broadcast(PC,PC.PlayerReplicationInfo.GetHumanReadableName()@"became a spectator");
|
|
RemoveRespawn(PC);
|
|
}
|
|
else
|
|
{
|
|
PC.PlayerReplicationInfo.bOnlySpectator = false;
|
|
if( !WorldInfo.Game.ChangeTeam(PC,WorldInfo.Game.PickTeam(0,PC,PC.PlayerReplicationInfo.UniqueId),false) )
|
|
{
|
|
PC.PlayerReplicationInfo.bOnlySpectator = true;
|
|
PC.ClientMessage("Can't become an active player, failed to set a team.");
|
|
return;
|
|
}
|
|
PC.NextSpectateChange = WorldInfo.TimeSeconds+2.5;
|
|
++WorldInfo.Game.NumPlayers;
|
|
--WorldInfo.Game.NumSpectators;
|
|
PC.Reset();
|
|
WorldInfo.Game.Broadcast(PC,PC.PlayerReplicationInfo.GetHumanReadableName()@"became an active player");
|
|
if( bRespawnCheck )
|
|
CheckRespawn(PC);
|
|
}
|
|
}
|
|
|
|
function bool GetNextItem( ExtPlayerReplicationInfo PRI, int RepIndex )
|
|
{
|
|
if( RepIndex>=CustomItemList.Length )
|
|
return false;
|
|
PRI.ClientAddTraderItem(RepIndex,CustomItemList[RepIndex]);
|
|
return true;
|
|
}
|
|
|
|
function InitWebAdmin( ExtWebAdmin_UI UI )
|
|
{
|
|
local int i;
|
|
|
|
UI.AddSettingsPage("Main Server Ext",Class,WebConfigs,WebAdminGetValue,WebAdminSetValue);
|
|
for( i=0; i<LoadedPerks.Length; ++i )
|
|
LoadedPerks[i].Static.InitWebAdmin(UI);
|
|
}
|
|
function string WebAdminGetValue( name PropName, int ElementIndex )
|
|
{
|
|
switch( PropName )
|
|
{
|
|
case 'StatFileDir':
|
|
return StatFileDir;
|
|
case 'ForcedMaxPlayers':
|
|
return string(ForcedMaxPlayers);
|
|
case 'PlayerRespawnTime':
|
|
return string(PlayerRespawnTime);
|
|
case 'StatAutoSaveWaves':
|
|
return string(StatAutoSaveWaves);
|
|
case 'PostGameRespawnCost':
|
|
return string(PostGameRespawnCost);
|
|
case 'bKillMessages':
|
|
return string(bKillMessages);
|
|
case 'LargeMonsterHP':
|
|
return string(LargeMonsterHP);
|
|
case 'bDamageMessages':
|
|
return string(bDamageMessages);
|
|
case 'bEnableMapVote':
|
|
return string(bEnableMapVote);
|
|
case 'bNoBoomstickJumping':
|
|
return string(bNoBoomstickJumping);
|
|
case 'bNoAdminCommands':
|
|
return string(bNoAdminCommands);
|
|
case 'bDumpXMLStats':
|
|
return string(bDumpXMLStats);
|
|
case 'bRagdollFromFall':
|
|
return string(bRagdollFromFall);
|
|
case 'bRagdollFromMomentum':
|
|
return string(bRagdollFromMomentum);
|
|
case 'bRagdollFromBackhit':
|
|
return string(bRagdollFromBackhit);
|
|
case 'bAddCountryTags':
|
|
return string(bAddCountryTags);
|
|
case 'MaxTopPlayers':
|
|
return string(MaxTopPlayers);
|
|
case 'MinUnloadPerkLevel':
|
|
return string(MinUnloadPerkLevel);
|
|
case 'bDontUseOriginalWeaponry':
|
|
return string(bDontUseOriginalWeaponry);
|
|
case 'bDisableCustomTrader':
|
|
return string(bDisableCustomTrader);
|
|
case 'bAllowStandartPistolUpgrade':
|
|
return string(bAllowStandartPistolUpgrade);
|
|
case 'bDLCWeaponsForFree':
|
|
return string(bDLCWeaponsForFree);
|
|
case 'UnloadPerkExpCost':
|
|
return string(UnloadPerkExpCost);
|
|
case 'PerkClasses':
|
|
return (ElementIndex==-1 ? string(PerkClasses.Length) : PerkClasses[ElementIndex]);
|
|
case 'CustomChars':
|
|
return (ElementIndex==-1 ? string(CustomChars.Length) : CustomChars[ElementIndex]);
|
|
case 'AdminCommands':
|
|
return (ElementIndex==-1 ? string(AdminCommands.Length) : AdminCommands[ElementIndex]);
|
|
case 'CustomItems':
|
|
return (ElementIndex==-1 ? string(CustomItems.Length) : CustomItems[ElementIndex]);
|
|
case 'ServerMOTD':
|
|
return Repl(ServerMOTD,"|",Chr(10));
|
|
case 'BonusGameSongs':
|
|
return (ElementIndex==-1 ? string(BonusGameSongs.Length) : BonusGameSongs[ElementIndex]);
|
|
case 'BonusGameFX':
|
|
return (ElementIndex==-1 ? string(BonusGameFX.Length) : BonusGameFX[ElementIndex]);
|
|
}
|
|
}
|
|
final function UpdateArray( out array<string> Ar, int Index, const out string Value )
|
|
{
|
|
if( Value=="#DELETE" )
|
|
Ar.Remove(Index,1);
|
|
else
|
|
{
|
|
if( Index>=Ar.Length )
|
|
Ar.Length = Index+1;
|
|
Ar[Index] = Value;
|
|
}
|
|
}
|
|
function WebAdminSetValue( name PropName, int ElementIndex, string Value )
|
|
{
|
|
switch( PropName )
|
|
{
|
|
case 'StatFileDir':
|
|
StatFileDir = Value; break;
|
|
case 'ForcedMaxPlayers':
|
|
ForcedMaxPlayers = int(Value); break;
|
|
case 'PlayerRespawnTime':
|
|
PlayerRespawnTime = int(Value); break;
|
|
case 'StatAutoSaveWaves':
|
|
StatAutoSaveWaves = int(Value); break;
|
|
case 'PostGameRespawnCost':
|
|
PostGameRespawnCost = int(Value); break;
|
|
case 'bKillMessages':
|
|
bKillMessages = bool(Value); break;
|
|
case 'LargeMonsterHP':
|
|
LargeMonsterHP = int(Value); break;
|
|
case 'MinUnloadPerkLevel':
|
|
MinUnloadPerkLevel = int(Value); break;
|
|
case 'UnloadPerkExpCost':
|
|
UnloadPerkExpCost = float(Value); break;
|
|
case 'bDamageMessages':
|
|
bDamageMessages = bool(Value); break;
|
|
case 'bEnableMapVote':
|
|
bEnableMapVote = bool(Value); break;
|
|
case 'bNoAdminCommands':
|
|
bNoAdminCommands = bool(Value); break;
|
|
case 'bDumpXMLStats':
|
|
bDumpXMLStats = bool(Value); break;
|
|
case 'bNoBoomstickJumping':
|
|
bNoBoomstickJumping = bool(Value); break;
|
|
case 'bRagdollFromFall':
|
|
bRagdollFromFall = bool(Value); break;
|
|
case 'bRagdollFromMomentum':
|
|
bRagdollFromMomentum = bool(Value); break;
|
|
case 'bRagdollFromBackhit':
|
|
bRagdollFromBackhit = bool(Value); break;
|
|
case 'bDontUseOriginalWeaponry':
|
|
bDontUseOriginalWeaponry = bool(Value); break;
|
|
case 'bDisableCustomTrader':
|
|
bDisableCustomTrader = bool(Value); break;
|
|
case 'bAllowStandartPistolUpgrade':
|
|
bAllowStandartPistolUpgrade = bool(Value); break;
|
|
case 'bDLCWeaponsForFree':
|
|
bDLCWeaponsForFree = bool(Value); break;
|
|
case 'bAddCountryTags':
|
|
bAddCountryTags = bool(Value); break;
|
|
case 'MaxTopPlayers':
|
|
MaxTopPlayers = int(Value); break;
|
|
case 'ServerMOTD':
|
|
ServerMOTD = Repl(Value,Chr(13)$Chr(10),"|"); break;
|
|
case 'PerkClasses':
|
|
UpdateArray(PerkClasses,ElementIndex,Value); break;
|
|
case 'CustomChars':
|
|
UpdateArray(CustomChars,ElementIndex,Value); break;
|
|
case 'AdminCommands':
|
|
UpdateArray(AdminCommands,ElementIndex,Value); break;
|
|
case 'CustomItems':
|
|
UpdateArray(CustomItems,ElementIndex,Value); break;
|
|
case 'BonusGameSongs':
|
|
UpdateArray(BonusGameSongs,ElementIndex,Value); break;
|
|
case 'BonusGameFX':
|
|
UpdateArray(BonusGameFX,ElementIndex,Value); break;
|
|
default:
|
|
return;
|
|
}
|
|
SaveConfig();
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
// Main devs
|
|
DevList.Add("0x0110000100E8984E") // Marco
|
|
DevList.Add("0x01100001023DF8A8") // ForrestMarkX
|
|
|
|
// Some fixes and changes
|
|
DevList.Add("0x011000010AF1C7CA") // inklesspen
|
|
DevList.Add("0x011000010276FBCB") // GenZmeY
|
|
|
|
WebConfigs.Add((PropType=0,PropName="StatFileDir",UIName="Stat File Dir",UIDesc="Location of the stat files on the HDD (%s = unique player ID)"))
|
|
WebConfigs.Add((PropType=0,PropName="ForcedMaxPlayers",UIName="Server Max Players",UIDesc="A forced max players value of the server (0 = use standard KF2 setting)"))
|
|
WebConfigs.Add((PropType=0,PropName="PlayerRespawnTime",UIName="Respawn Time",UIDesc="Players respawn time in seconds after they die (0 = no respawning)"))
|
|
WebConfigs.Add((PropType=0,PropName="PostGameRespawnCost",UIName="Post-Game Respawn Cost",UIDesc="Amount of dosh it'll cost to be respawned after end-game (only for custom gametypes that support this)."))
|
|
WebConfigs.Add((PropType=0,PropName="StatAutoSaveWaves",UIName="Stat Auto-Save Waves",UIDesc="How often should stats be auto-saved (1 = every wave, 2 = every second wave etc)"))
|
|
WebConfigs.Add((PropType=0,PropName="MinUnloadPerkLevel",UIName="Min Unload Perk Level",UIDesc="Minimum level a player should be on before they can use the perk stat unload (-1 = never)."))
|
|
WebConfigs.Add((PropType=0,PropName="UnloadPerkExpCost",UIName="Perk Unload XP Cost",UIDesc="The percent of XP it costs for a player to use a perk unload (1 = all XP, 0 = none)."))
|
|
WebConfigs.Add((PropType=1,PropName="bKillMessages",UIName="Show Kill Messages",UIDesc="Display on players HUD a kill counter every time they kill something"))
|
|
WebConfigs.Add((PropType=0,PropName="LargeMonsterHP",UIName="Large Monster HP",UIDesc="If the enemy kill a monster with more HP then this, broadcast kill message to everyone"))
|
|
WebConfigs.Add((PropType=1,PropName="bDamageMessages",UIName="Show Damage Messages",UIDesc="Display on players HUD a damage counter every time they damage an enemy"))
|
|
WebConfigs.Add((PropType=1,PropName="bEnableMapVote",UIName="Enable MapVote",UIDesc="Enable MapVote X on this server"))
|
|
WebConfigs.Add((PropType=1,PropName="bNoBoomstickJumping",UIName="No Boomstick Jumps",UIDesc="Disable boomstick knockback, so people can't glitch with it on maps"))
|
|
WebConfigs.Add((PropType=1,PropName="bNoAdminCommands",UIName="Disable Admin menu",UIDesc="Disable admin menu commands so admins can't modify XP or levels of players"))
|
|
WebConfigs.Add((PropType=1,PropName="bDumpXMLStats",UIName="Dump XML stats",UIDesc="Dump XML stat files for some external stat loggers"))
|
|
WebConfigs.Add((PropType=1,PropName="bRagdollFromFall",UIName="Ragdoll From Fall",UIDesc="Make players ragdoll if they fall from a high place"))
|
|
WebConfigs.Add((PropType=1,PropName="bRagdollFromMomentum",UIName="Ragdoll From Momentum",UIDesc="Make players ragdoll if they take a damage with high momentum transfer"))
|
|
WebConfigs.Add((PropType=1,PropName="bRagdollFromBackhit",UIName="Ragdoll From Backhit",UIDesc="Make players ragdoll if they take a big hit to their back"))
|
|
WebConfigs.Add((PropType=1,PropName="bAddCountryTags",UIName="Add Country Tags",UIDesc="Add player country tags to their names"))
|
|
WebConfigs.Add((PropType=0,PropName="MaxTopPlayers",UIName="Max top players",UIDesc="Maximum top players to broadcast of and to keep track of."))
|
|
WebConfigs.Add((PropType=2,PropName="PerkClasses",UIName="Perk Classes",UIDesc="List of RPG perks players can play as (careful with removing them, because any perks removed will permanently delete the gained XP for every player for that perk)!",NumElements=-1))
|
|
WebConfigs.Add((PropType=2,PropName="CustomChars",UIName="Custom Chars",UIDesc="List of custom characters for this server (prefix with * to mark as admin character).",NumElements=-1))
|
|
WebConfigs.Add((PropType=2,PropName="AdminCommands",UIName="Admin Commands",UIDesc="List of Admin commands to show on scoreboard UI for admins (use : to split actual command with display name for the command)",NumElements=-1))
|
|
WebConfigs.Add((PropType=3,PropName="ServerMOTD",UIName="MOTD",UIDesc="Message of the Day"))
|
|
WebConfigs.Add((PropType=2,PropName="BonusGameSongs",UIName="Bonus Game Songs",UIDesc="List of custom musics to play during level change pong game.",NumElements=-1))
|
|
WebConfigs.Add((PropType=2,PropName="BonusGameFX",UIName="Bonus Game FX",UIDesc="List of custom FX to play on pong game.",NumElements=-1))
|
|
|
|
WebConfigs.Add((PropType=1,PropName="bDisableCustomTrader",UIName="Disable custom trader",UIDesc="Warning! That option will disable all settings below"))
|
|
WebConfigs.Add((PropType=2,PropName="CustomItems",UIName="Custom Inventory",UIDesc="List of custom inventory to add to trader (must be KFWeaponDefinition class).",NumElements=-1))
|
|
WebConfigs.Add((PropType=1,PropName="bDontUseOriginalWeaponry",UIName="Disable original weapons",UIDesc="Allows to buy default weapons"))
|
|
WebConfigs.Add((PropType=1,PropName="bDLCWeaponsForFree",UIName="Free DLC weapons",UIDesc="Allows to buy DLC weapons"))
|
|
WebConfigs.Add((PropType=1,PropName="bAllowStandartPistolUpgrade",UIName="Standard pistol upgrades",UIDesc="Allows to upgrade standard pistol"))
|
|
}
|