public LimitsGUI()
{
ErrorGUIStyle.normal.textColor = new Color(255f, 0f, 0f);
CaptainStyle.alignment = TextAnchor.MiddleCenter;
CaptainStyle.normal.textColor = PLPlayer.GetClassColorFromID(0);
CaptainStyle.fixedWidth = 100f;
CaptainStyle.clipping = TextClipping.Clip;
PilotStyle.alignment = TextAnchor.MiddleCenter;
PilotStyle.normal.textColor = PLPlayer.GetClassColorFromID(1);
PilotStyle.fixedWidth = 100f;
PilotStyle.clipping = TextClipping.Clip;
ScienceStyle.alignment = TextAnchor.MiddleCenter;
ScienceStyle.normal.textColor = PLPlayer.GetClassColorFromID(2);
ScienceStyle.fixedWidth = 100f;
ScienceStyle.clipping = TextClipping.Clip;
WeaponsStyle.alignment = TextAnchor.MiddleCenter;
WeaponsStyle.normal.textColor = PLPlayer.GetClassColorFromID(3);
WeaponsStyle.fixedWidth = 100f;
WeaponsStyle.clipping = TextClipping.Clip;
EngineerStyle.alignment = TextAnchor.MiddleCenter;
EngineerStyle.normal.textColor = PLPlayer.GetClassColorFromID(4);
EngineerStyle.fixedWidth = 100f;
EngineerStyle.clipping = TextClipping.Clip;
}
IEnumerator TeleportWithWait(PLPlayer player, PlayerPos info, int inID)
{
yield return(new WaitForEndOfFrame());
while (PulsarModLoader.Utilities.HelperMethods.GetPlayerFromPlayerID(inID).GetPawn() == null || PulsarModLoader.Utilities.HelperMethods.GetPlayerFromPlayerID(inID).GetPawn().transform?.position == null)
{
yield return(new WaitForEndOfFrame());
}
int pause = 0;
while (pause < 5)
{
yield return(new WaitForEndOfFrame());
pause++;
}
player.photonView.RPC("NetworkTeleportToSubHub", PhotonTargets.All, new object[]
{
info.hubid,
info.ttiid
});
player.photonView.RPC("RecallPawnToPos", PhotonTargets.All, new object[]
{
info.pos
});
Plugin.pos.Remove(player.GetClassID());
#if DEBUG
PulsarPluginLoader.Utilities.Logger.Info($"Apply for {inID}");
#endif
}
public static void Notification(string message, PLPlayer recipient = null, int subjectPlayerId = 0, int durationMs = 6000, bool addToShipLog = false)
{
if (recipient == null && PLNetworkManager.Instance != null)
{
recipient = PLNetworkManager.Instance.LocalPlayer;
}
Notification(message, recipient.GetPhotonPlayer(), subjectPlayerId, durationMs, addToShipLog);
}
public static void ChatMessage(PLPlayer recipient, string message, int sendingPlayerId = -1)
{
if (sendingPlayerId == -1)
{
sendingPlayerId = PLNetworkManager.Instance.LocalPlayerID;
}
ChatMessage(recipient.GetPhotonPlayer(), message, sendingPlayerId);
}
public override void HandleRPC(object[] arguments, PhotonMessageInfo sender)
{
PLPlayer player = PLServer.GetPlayerForPhotonPlayer(sender.sender);
string name = player.GetPlayerName();
string message = (string)arguments[0];
Messaging.Echo(PLNetworkManager.Instance.LocalPlayer.GetPhotonPlayer(), $"[&%~[C{player.GetClassID()} {name} ]&%~] <color=#a0a0a0>whispers to you: {message}</color>");
}
public static void Echo(PLPlayer recipient, string message)
{
if (recipient == null || message == null)
{
AntiNullReferenceException($"{(recipient == null ? "recipent: null" : "recipent: PLPlayer")}, {(message == null ? "message: null" : $"message: \"{message}\"")}");
return;
}
Echo(recipient.GetPhotonPlayer(), message);
}
public static void Centerprint(string message, PLPlayer recipient, string tag = "msg", Color color = new Color(), EWarningType type = EWarningType.E_NORMAL)
{
if (recipient == null || message == null || tag == null)
{
AntiNullReferenceException($"{(recipient == null ? "recipent: null" : "recipent: PLPlayer")}, {(message == null ? "message: null" : $"message: \"{message}\"")}, ..., {(tag == null ? "tag: null" : $"tag: \"{tag}\"")}");
return;
}
Centerprint(message, recipient.GetPhotonPlayer(), tag, color, type);
}
static bool Prefix(ref int classID)
{
PLPlayer player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(classID);
if (Global.ProtectionEnabled && player != null && !player.IsBot)
{
Debug.Log("[DragonWarning] Someone is trying to remove remove Player of class " + classID);
PLServer.Instance.AddNotification("[DragonWarning] Someone is trying to remove Player of class " + classID, PLNetworkManager.Instance.LocalPlayerID, PLServer.Instance.GetEstimatedServerMs() + 6000, true);
return(false);
}
return(true);
}
static bool Prefix(ref int inPlayerID)
{
PLPlayer player = PLServer.Instance.GetPlayerFromPlayerID(inPlayerID);
if (Global.ProtectionEnabled && player != null && !player.IsBot)
{
Debug.Log("[DragonWarning] Someone is trying to delete PlayerID " + inPlayerID);
PLServer.Instance.AddNotification("[DragonWarning] Someone is trying to delete PlayerID " + inPlayerID, PLNetworkManager.Instance.LocalPlayerID, PLServer.Instance.GetEstimatedServerMs() + 6000, true);
return(false);
}
return(true);
}
private static void Postfix(ref List <PLPlayer> ___LocalCachedPlayerByClass)
{
for (int i = 0; i < 5; i++)
{
int playerid = Global.roleleads[i];
PLPlayer RoleLead = PLServer.Instance.GetPlayerFromPlayerID(playerid);
if (RoleLead != null && RoleLead.GetClassID() == i)
{
___LocalCachedPlayerByClass[i] = RoleLead;
}
}
}
public static void ChatMessage(PLPlayer recipient, string message, int sendingPlayerId = -1)
{
if (recipient == null || message == null)
{
AntiNullReferenceException($"{(recipient == null ? "recipent: null" : "recipent: PLPlayer")}, {(message == null ? "message: null" : $"message: \"{message}\"")}, sendingPlayerId: {sendingPlayerId}");
return;
}
if (sendingPlayerId == -1)
{
sendingPlayerId = PLNetworkManager.Instance.LocalPlayerID;
}
ChatMessage(recipient.GetPhotonPlayer(), message, sendingPlayerId);
}
static void Postfix(PLServer __instance, int inID)
{
if (PhotonNetwork.isMasterClient && ChatCommandRouter.Instance.getPublicCommandAliases().Length > 1)
{
PLPlayer player = __instance.GetPlayerFromPlayerID(inID);
if (player != null && player.GetPhotonPlayer() != null)
{
Messaging.Echo(player, $"[&%~[C0 Welcome ]&%~] {player.GetPlayerName()}!");
Messaging.Echo(player, "This game has some commands available.");
Messaging.Echo(player, "Type [&%~[C2 !help ]&%~] for more information.");
}
}
}
/// <summary>
/// Attempts GetPlayerFromPlayerID, GetPlayerFromClassName, then GetPlayerFromPlayerName. Returns the first player found, or null if no player matches.
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public static PLPlayer GetPlayer(string argument)
{
PLPlayer player = GetPlayerFromPlayerID(argument);
if (player != null)
{
return(player);
}
if (argument.Length == 1)
{
player = GetPlayerFromClassName(argument);
}
if (player != null)
{
return(player);
}
player = GetPlayerFromPlayerName(argument);
return(player);
}
public override void Execute(string arguments, int SenderID)
{
if (PhotonNetwork.isMasterClient)
{
if (arguments.ToLower() == "scomo")
{
Messaging.Echo(PhotonTargets.All, "<color=#ffff00>Scomo <Marketing></color> : I don't hold a teleporter mate.");
}
else
{
PLPlayer player = HelperMethods.GetPlayerFromPlayerID(SenderID);
int hubID = PLEncounterManager.Instance.PlayerShip.MyTLI.SubHubID;
player.photonView.RPC("NetworkTeleportToSubHub", PhotonTargets.All, new object[]
{
hubID,
0
});
}
}
}
public PlayerRemovedEvent(PLPlayer player) : base(player)
{
}
private static bool Prefix(PLServer __instance, ref int playerID, ref int classID, PhotonMessageInfo pmi)
{
//runs vanilla if client isn't hosting
if (!PhotonNetwork.isMasterClient)
{
return(true);
}
//fails if client not trying to be class -1 through 4
if (classID < -1 || classID > 4)
{
return(false);
}
//Protect Players from bad actors changing other player's classes.
PLPlayer playerForPhotonPlayer = PLServer.GetPlayerForPhotonPlayer(pmi.sender);
if (playerForPhotonPlayer != null && playerForPhotonPlayer.GetPlayerID() != playerID)
{
return(false);
}
PLPlayer PlayerFromID = __instance.GetPlayerFromPlayerID(playerID);
if (PlayerFromID != null)
{
//stop if player is already in the specified class
if (PlayerFromID.GetClassID() == classID)
{
return(false);
}
Global.Generateplayercount();
if (CanJoinClass(classID))
{
//sends the classchangemessage, sets the player to the class id
PlayerFromID.SetClassID(classID);
AccessTools.Method(__instance.GetType(), "ClassChangeMessage", null, null).Invoke(__instance, new object[] { PlayerFromID.GetPlayerName(false), classID });
}
else //Couldn't become role, send available options.
{
string options = "";
for (int classid = 0; classid < 5; classid++)
{
if (CanJoinClass(classid))
{
options += $"{PLPlayer.GetClassNameFromID(classid)}\n";
}
}
if (string.IsNullOrEmpty(options))
{
Messaging.Centerprint("There are no slots available. Ask the host to change this or leave.", PlayerFromID, "ROL", PLPlayer.GetClassColorFromID(classID), EWarningType.E_NORMAL);
Messaging.Notification($"Player {PlayerFromID.GetPlayerName()} Is trying to join as {PLPlayer.GetClassNameFromID(classID)}. There are no Roles available.");
}
else
{
Messaging.Centerprint("That slot is full, choose another one. options on the left", PlayerFromID, "ROL", PLPlayer.GetClassColorFromID(classID), EWarningType.E_NORMAL);
Messaging.Notification(options, PlayerFromID, playerID, 10000 + PLServer.Instance.GetEstimatedServerMs());
Messaging.Notification($"Player {PlayerFromID.GetPlayerName()} Is trying to join as {PLPlayer.GetClassNameFromID(classID)}");
}
}
}
return(false);
}
static bool Prefix(PLSaveGameIO __instance, ref string inFileName, ref ObscuredInt ___CurrentVersionSaveID, ref ObscuredInt ___CurrentVersionGalaxySaveID)
{
if (PLNetworkManager.Instance.VersionString == "28.1")
{
return(true);
}
if (PLServer.Instance != null && PLEncounterManager.Instance.PlayerShip != null)
{
string text = inFileName + "_temp";
if (File.Exists(text))
{
text += "0";
}
if (File.Exists(text))
{
text += "0";
}
FileStream fileStream = File.Create(text);
BinaryWriter binaryWriter = new BinaryWriter(fileStream);
binaryWriter.Write(___CurrentVersionSaveID);
binaryWriter.Write(___CurrentVersionGalaxySaveID);
binaryWriter.Write(DateTime.Now.ToBinary());
binaryWriter.Write(PLServer.Instance.GalaxySeed);
binaryWriter.Write(PLNetworkManager.Instance.Stats_GameEndTime);
binaryWriter.Write(PLServer.Instance.CurrentCrewCredits);
binaryWriter.Write(PLServer.Instance.CurrentCrewLevel);
binaryWriter.Write(PLServer.Instance.CurrentCrewXP);
binaryWriter.Write(PLServer.Instance.GetCurrentHubID());
binaryWriter.Write(PLServer.Instance.IronmanModeIsActive);
binaryWriter.Write(PLServer.Instance.PlayerCrew_BiscuitsSold);
binaryWriter.Write(PLServer.Instance.PlayerCrew_WonFBContest);
binaryWriter.Write(PLServer.Instance.PlayerCrew_BiscuitsSold_WhenContestEnded);
binaryWriter.Write(PLServer.Instance.BiscuitBombAvailable);
binaryWriter.Write(PLServer.Instance.CurrentUpgradeMats);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.WeapUpgrade_PawnItemInLockerHash);
binaryWriter.Write(PLServer.Instance.RepLevels[0]);
binaryWriter.Write(PLServer.Instance.RepLevels[1]);
binaryWriter.Write(PLServer.Instance.RepLevels[2]);
binaryWriter.Write(PLServer.Instance.RepLevels[3]);
binaryWriter.Write(PLServer.Instance.RepLevels[4]);
binaryWriter.Write(PLServer.Instance.BiscuitContestIsOver);
binaryWriter.Write(PLServer.Instance.ActiveBountyHunter_SectorID);
binaryWriter.Write(PLServer.Instance.ActiveBountyHunter_SecondsSinceWarp);
binaryWriter.Write(PLServer.Instance.ActiveBountyHunter_TypeID);
binaryWriter.Write(PLServer.Instance.ActiveBountyHunter_ProcessedChaosLevel);
binaryWriter.Write(PLServer.Instance.PacifistRun);
binaryWriter.Write(PLServer.Instance.CreditsSpent_InRun);
binaryWriter.Write(PLServer.Instance.PerfectBiscuitStreak);
binaryWriter.Write(PLServer.Instance.BlindJumpCount);
binaryWriter.Write(PLServer.Instance.CrewPurchaseLimitsEnabled);
binaryWriter.Write(PLGlobal.Instance.Galaxy.StormPosition.x);
binaryWriter.Write(PLGlobal.Instance.Galaxy.StormPosition.y);
binaryWriter.Write(PLGlobal.Instance.Galaxy.StormPosition.z);
binaryWriter.Write(PLServer.Instance.RacesWonBitfield);
binaryWriter.Write(PLServer.Instance.RacesLostBitfield);
binaryWriter.Write(PLServer.Instance.RacesStartedBitfield);
binaryWriter.Write(PhotonNetwork.room.name);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.ShipNameValue);
binaryWriter.Write((int)PLEncounterManager.Instance.PlayerShip.ShipTypeID);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.NumberOfFuelCapsules);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.MyStats.HullCurrent);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.FBCrateSupply);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.ReactorCoolantLevelPercent);
byte[] additionalDataForSaveIO = PLEncounterManager.Instance.PlayerShip.GetAdditionalDataForSaveIO();
binaryWriter.Write(additionalDataForSaveIO.Length);
binaryWriter.Write(additionalDataForSaveIO);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.MyStats.AllComponents.Count);
for (int i = 0; i < PLEncounterManager.Instance.PlayerShip.MyStats.AllComponents.Count; i++)
{
PLShipComponent plshipComponent = PLEncounterManager.Instance.PlayerShip.MyStats.AllComponents[i];
if (plshipComponent != null)
{
binaryWriter.Write(plshipComponent.getHash());
binaryWriter.Write(plshipComponent.SortID);
binaryWriter.Write(plshipComponent.SubTypeData);
}
else
{
binaryWriter.Write(0U);
binaryWriter.Write(-1);
binaryWriter.Write(0);
}
}
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems.Count);
for (int j = 0; j < PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems.Count; j++)
{
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems[j].ItemHash);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems[j].Position.x);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems[j].Position.y);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.AllPlayerDroppedItems[j].Position.z);
}
for (int k = 0; k < 5; k++)
{
PLPlayer cachedFriendlyPlayerOfClass = PLServer.Instance.GetCachedFriendlyPlayerOfClass(k);
PLPawnInventoryBase plpawnInventoryBase = null;
PLPawnInventoryBase plpawnInventoryBase2 = null;
if (cachedFriendlyPlayerOfClass != null)
{
plpawnInventoryBase = cachedFriendlyPlayerOfClass.MyInventory;
}
PLServerClassInfo plserverClassInfo = PLServer.Instance.ClassInfos[k];
if (plserverClassInfo != null)
{
plpawnInventoryBase2 = plserverClassInfo.ClassLockerInventory;
}
int num = 0;
if (plpawnInventoryBase != null)
{
foreach (List <PLPawnItem> list in plpawnInventoryBase.GetAllItems(true))
{
foreach (PLPawnItem plpawnItem in list)
{
if (plpawnItem != null)
{
num++;
}
}
}
}
if (plpawnInventoryBase2 != null)
{
foreach (List <PLPawnItem> list2 in plpawnInventoryBase2.GetAllItems(false))
{
foreach (PLPawnItem plpawnItem2 in list2)
{
if (plpawnItem2 != null)
{
num++;
}
}
}
}
binaryWriter.Write(num);
if (plpawnInventoryBase != null)
{
foreach (List <PLPawnItem> list3 in plpawnInventoryBase.GetAllItems(true))
{
foreach (PLPawnItem plpawnItem3 in list3)
{
if (plpawnItem3 != null)
{
binaryWriter.Write((int)plpawnItem3.PawnItemType);
binaryWriter.Write(plpawnItem3.SubType);
binaryWriter.Write(plpawnItem3.Level);
}
}
}
}
if (plpawnInventoryBase2 != null)
{
foreach (List <PLPawnItem> list4 in plpawnInventoryBase2.GetAllItems(false))
{
foreach (PLPawnItem plpawnItem4 in list4)
{
if (plpawnItem4 != null)
{
binaryWriter.Write((int)plpawnItem4.PawnItemType);
binaryWriter.Write(plpawnItem4.SubType);
binaryWriter.Write(plpawnItem4.Level);
}
}
}
}
}
int num2 = 0;
foreach (PLFactionInfo plfactionInfo in PLGlobal.Instance.Galaxy.AllFactions)
{
if (plfactionInfo != null)
{
num2++;
}
}
binaryWriter.Write(num2);
foreach (PLFactionInfo plfactionInfo2 in PLGlobal.Instance.Galaxy.AllFactions)
{
if (plfactionInfo2 != null)
{
binaryWriter.Write(plfactionInfo2.FactionID);
binaryWriter.Write(plfactionInfo2.FactionAI_Continuous_GalaxySpreadLimit);
binaryWriter.Write(plfactionInfo2.FactionAI_Continuous_GalaxySpreadFactor);
}
}
binaryWriter.Write(PLServer.Instance.ChaosLevel);
binaryWriter.Write(PLServer.Instance.ActiveChaosEvents);
binaryWriter.Write(PLServer.Instance.TalentLockedStatus);
binaryWriter.Write((int)PLServer.Instance.TalentToResearch);
binaryWriter.Write(PLServer.Instance.JumpsNeededToResearchTalent);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[0]);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[1]);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[2]);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[3]);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[4]);
binaryWriter.Write(PLServer.Instance.ResearchMaterials[5]);
int count = PLServer.Instance.ResearchLockerInventory.AllItems.Count;
binaryWriter.Write(count);
foreach (PLPawnItem plpawnItem5 in PLServer.Instance.ResearchLockerInventory.AllItems)
{
if (plpawnItem5 != null)
{
binaryWriter.Write((int)plpawnItem5.PawnItemType);
binaryWriter.Write(plpawnItem5.SubType);
binaryWriter.Write(plpawnItem5.Level);
}
}
for (int l = 0; l < 5; l++)
{
PLPlayer cachedFriendlyPlayerOfClass2 = PLServer.Instance.GetCachedFriendlyPlayerOfClass(l);
if (cachedFriendlyPlayerOfClass2 != null)
{
binaryWriter.Write(true);
binaryWriter.Write(cachedFriendlyPlayerOfClass2.TalentPointsAvailable);
PLServerClassInfo plserverClassInfo2 = PLServer.Instance.ClassInfos[l];
if (plserverClassInfo2 != null)
{
binaryWriter.Write(plserverClassInfo2.SurvivalBonusCounter);
}
else
{
binaryWriter.Write(0);
}
int num3 = cachedFriendlyPlayerOfClass2.Talents.Length;
binaryWriter.Write(num3);
for (int m = 0; m < num3; m++)
{
binaryWriter.Write(cachedFriendlyPlayerOfClass2.Talents[m]);
}
int count2 = cachedFriendlyPlayerOfClass2.MyInventory.AllItems.Count;
binaryWriter.Write(count2);
for (int n = 0; n < count2; n++)
{
binaryWriter.Write((int)cachedFriendlyPlayerOfClass2.MyInventory.AllItems[n].PawnItemType);
binaryWriter.Write(cachedFriendlyPlayerOfClass2.MyInventory.AllItems[n].SubType);
binaryWriter.Write(cachedFriendlyPlayerOfClass2.MyInventory.AllItems[n].Level);
binaryWriter.Write(cachedFriendlyPlayerOfClass2.MyInventory.AllItems[n].EquipID);
}
}
else
{
binaryWriter.Write(false);
}
}
binaryWriter.Write(PLServer.Instance.CrewFactionID);
binaryWriter.Write(PLEncounterManager.Instance.PlayerShip.IsFlagged);
binaryWriter.Write(PLServer.Instance.IsCrewRepRevealed);
binaryWriter.Write(PLServer.Instance.LongRangeCommsDisabled);
int count3 = PLServer.Instance.AlreadyAttemptedToStartPickupMissionID.Count;
binaryWriter.Write(count3);
foreach (ObscuredInt value in PLServer.Instance.AlreadyAttemptedToStartPickupMissionID)
{
int value2 = value;
binaryWriter.Write(value2);
}
binaryWriter.Write(PLNetworkManager.Instance.SelectedShipTypeID);
binaryWriter.Write(PLServer.ServerSpaceTargetIDCounter);
int num4 = 0;
foreach (PLPersistantDialogueActor plpersistantDialogueActor in PLServer.Instance.AllPDAs)
{
if (plpersistantDialogueActor != null)
{
num4++;
}
}
binaryWriter.Write(num4);
foreach (PLPersistantDialogueActor plpersistantDialogueActor2 in PLServer.Instance.AllPDAs)
{
if (plpersistantDialogueActor2 != null)
{
PLPersistantDialogueActorNPC plpersistantDialogueActorNPC = plpersistantDialogueActor2 as PLPersistantDialogueActorNPC;
PLPersistantDialogueActorShip plpersistantDialogueActorShip = plpersistantDialogueActor2 as PLPersistantDialogueActorShip;
if (plpersistantDialogueActorNPC != null)
{
binaryWriter.Write(0);
binaryWriter.Write(plpersistantDialogueActorNPC.Hostile);
binaryWriter.Write(plpersistantDialogueActorNPC.DialogueActorID);
try
{
binaryWriter.Write(plpersistantDialogueActorNPC.NPCName);
}
catch (ArgumentNullException ex)
{
Debug.DebugBreak();
}
}
else if (plpersistantDialogueActorShip != null)
{
binaryWriter.Write(1);
binaryWriter.Write(plpersistantDialogueActorShip.Hostile);
binaryWriter.Write(plpersistantDialogueActorShip.DialogueActorID);
binaryWriter.Write(plpersistantDialogueActorShip.ShipName);
binaryWriter.Write(plpersistantDialogueActorShip.SpecialActionCompleted);
binaryWriter.Write(plpersistantDialogueActorShip.LinesToShowPercent.Count);
foreach (ObscuredInt value3 in plpersistantDialogueActorShip.LinesToShowPercent)
{
int value4 = value3;
binaryWriter.Write(value4);
}
}
else
{
binaryWriter.Write(2);
}
int count4 = plpersistantDialogueActor2.LinesAleradyDisplayed.Count;
binaryWriter.Write(count4);
foreach (ObscuredInt value5 in plpersistantDialogueActor2.LinesAleradyDisplayed)
{
int value6 = value5;
binaryWriter.Write(value6);
}
}
}
int num5 = 0;
foreach (PLPersistantShipInfo plpersistantShipInfo in PLServer.Instance.AllPSIs)
{
if (plpersistantShipInfo != null)
{
num5++;
}
}
binaryWriter.Write(num5);
foreach (PLPersistantShipInfo plpersistantShipInfo2 in PLServer.Instance.AllPSIs)
{
if (plpersistantShipInfo2 != null)
{
binaryWriter.Write((int)plpersistantShipInfo2.Type);
binaryWriter.Write(plpersistantShipInfo2.FactionID);
binaryWriter.Write(plpersistantShipInfo2.IsShipDestroyed);
if (plpersistantShipInfo2.MyCurrentSector != null)
{
binaryWriter.Write(plpersistantShipInfo2.MyCurrentSector.ID);
}
else
{
binaryWriter.Write(-1);
}
binaryWriter.Write(plpersistantShipInfo2.ShipName);
binaryWriter.Write(plpersistantShipInfo2.CompOverrides.Count);
foreach (ComponentOverrideData componentOverrideData in plpersistantShipInfo2.CompOverrides)
{
binaryWriter.Write(componentOverrideData.CompLevel);
binaryWriter.Write(componentOverrideData.CompTypeToReplace);
binaryWriter.Write(componentOverrideData.CompSubType);
binaryWriter.Write(componentOverrideData.CompType);
binaryWriter.Write(componentOverrideData.ReplaceExistingComp);
binaryWriter.Write(componentOverrideData.CompSubTypeToReplace);
binaryWriter.Write(componentOverrideData.SlotNumberToReplace);
binaryWriter.Write(componentOverrideData.IsCargo);
}
binaryWriter.Write(plpersistantShipInfo2.HullPercent);
binaryWriter.Write(plpersistantShipInfo2.ShldPercent);
binaryWriter.Write(plpersistantShipInfo2.Modifiers);
binaryWriter.Write(plpersistantShipInfo2.IsFlagged);
binaryWriter.Write(plpersistantShipInfo2.ForcedHostile);
binaryWriter.Write(plpersistantShipInfo2.ForcedHostileAll);
binaryWriter.Write(plpersistantShipInfo2.ForcedHostileName);
binaryWriter.Write(plpersistantShipInfo2.SelectedActorID);
if (___CurrentVersionSaveID >= 29)
{
binaryWriter.Write(plpersistantShipInfo2.BiscuitsSold);
}
if (___CurrentVersionSaveID >= 34)
{
PLPersistantShipInfo_FBRival plpersistantShipInfo_FBRival = plpersistantShipInfo2 as PLPersistantShipInfo_FBRival;
if (plpersistantShipInfo_FBRival != null)
{
binaryWriter.Write(plpersistantShipInfo_FBRival.WonFBContest);
}
else
{
binaryWriter.Write(false);
}
}
if (___CurrentVersionSaveID >= 36)
{
binaryWriter.Write(plpersistantShipInfo2.EnsureNoCrew);
}
}
}
int num6 = 0;
foreach (PLMissionBase x in PLServer.Instance.AllMissions)
{
if (x != null)
{
num6++;
}
}
binaryWriter.Write(num6);
foreach (PLMissionBase plmissionBase in PLServer.Instance.AllMissions)
{
if (plmissionBase != null)
{
binaryWriter.Write(plmissionBase.MissionTypeID);
binaryWriter.Write(plmissionBase.Abandoned);
binaryWriter.Write(plmissionBase.Ended);
int num7 = 0;
foreach (PLMissionObjective plmissionObjective in plmissionBase.Objectives)
{
if (plmissionObjective != null)
{
num7++;
}
}
binaryWriter.Write(num7);
foreach (PLMissionObjective plmissionObjective2 in plmissionBase.Objectives)
{
if (plmissionObjective2 != null)
{
binaryWriter.Write(plmissionObjective2.IsCompleted);
binaryWriter.Write(plmissionObjective2.AmountCompleted);
binaryWriter.Write(plmissionObjective2.AmountNeeded);
binaryWriter.Write(plmissionObjective2.HasShownCompletedMessage);
}
}
binaryWriter.Write(plmissionBase.IsPickupMission);
PLPickupMissionBase plpickupMissionBase = plmissionBase as PLPickupMissionBase;
if (plpickupMissionBase != null)
{
binaryWriter.Write(plpickupMissionBase.RanStartRewards);
}
else
{
binaryWriter.Write(false);
}
}
}
int num8 = 0;
foreach (PLSectorInfo plsectorInfo in PLGlobal.Instance.Galaxy.AllSectorInfos.Values)
{
if (plsectorInfo != null)
{
num8++;
}
}
binaryWriter.Write(num8);
foreach (PLSectorInfo plsectorInfo2 in PLGlobal.Instance.Galaxy.AllSectorInfos.Values)
{
if (plsectorInfo2 != null)
{
binaryWriter.Write(plsectorInfo2.ID);
binaryWriter.Write((int)plsectorInfo2.VisualIndication);
binaryWriter.Write(plsectorInfo2.FactionStrength);
binaryWriter.Write(plsectorInfo2.MySPI.Faction);
binaryWriter.Write(plsectorInfo2.Position.x);
binaryWriter.Write(plsectorInfo2.Position.y);
binaryWriter.Write(plsectorInfo2.Position.z);
binaryWriter.Write(plsectorInfo2.Name);
binaryWriter.Write(plsectorInfo2.MissionSpecificID);
binaryWriter.Write(plsectorInfo2.LockedToFaction);
binaryWriter.Write(plsectorInfo2.LastCalculatedSectorStength);
binaryWriter.Write(plsectorInfo2.IsPartOfLongRangeWarpNetwork);
binaryWriter.Write(plsectorInfo2.Visited);
binaryWriter.Write(plsectorInfo2.BiscuitsSoldCounter);
PLPersistantEncounterInstance persistantEncounterInstanceAtID = PLEncounterManager.Instance.GetPersistantEncounterInstanceAtID(plsectorInfo2.ID);
if (persistantEncounterInstanceAtID != null)
{
binaryWriter.Write(true);
__instance.WriteDictionaryIntTPDE(persistantEncounterInstanceAtID.MyPersistantData.GetTraderInfoDictionary(), binaryWriter);
__instance.WriteDictionaryIntSENE(persistantEncounterInstanceAtID.MyPersistantData.SpecialNetObjectPersistantData, binaryWriter);
__instance.WriteDictionaryIntBool(persistantEncounterInstanceAtID.MyPersistantData.PickupObjectPersistantData, binaryWriter);
__instance.WriteDictionaryIntBool(persistantEncounterInstanceAtID.MyPersistantData.PickupComponentPersistantData, binaryWriter);
__instance.WriteDictionaryIntBool(persistantEncounterInstanceAtID.MyPersistantData.PickupRandomComponentPersistantData, binaryWriter);
__instance.WriteDictionaryIntBool(persistantEncounterInstanceAtID.MyPersistantData.ProbePickupPersistantData, binaryWriter);
__instance.WriteDictionaryStringString(persistantEncounterInstanceAtID.MyPersistantData.MiscPersistantData, binaryWriter);
__instance.WriteDictionaryStringDPO(persistantEncounterInstanceAtID.MyPersistantData.DPOPersistantData, binaryWriter);
__instance.WriteDictionaryStringDSO(persistantEncounterInstanceAtID.MyPersistantData.DSOPersistantData, binaryWriter);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems.Count);
for (int num9 = 0; num9 < persistantEncounterInstanceAtID.AllPlayerDroppedItems.Count; num9++)
{
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].ItemHash);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].Position.x);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].Position.y);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].Position.z);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].SubHubID);
binaryWriter.Write(persistantEncounterInstanceAtID.AllPlayerDroppedItems[num9].InteriorID);
}
}
else
{
binaryWriter.Write(false);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
binaryWriter.Write(0);
}
}
}
AIData loadedAIData = PLGlobal.Instance.LoadedAIData;
PLAIIO.WriteToBinary(loadedAIData, binaryWriter);
binaryWriter.Close();
fileStream.Close();
if (File.Exists(inFileName))
{
File.Delete(inFileName);
}
File.Move(text, inFileName);
string relativeSaveFileName = PLNetworkManager.Instance.FileNameToRelative(inFileName);
string item = "Game has been saved to file: " + relativeSaveFileName;
PLNetworkManager.Instance.ConsoleText.Insert(0, item);
bool flag = false;
if (relativeSaveFileName.StartsWith(__instance.LocalSaveDir))
{
flag = true;
}
if (!PLServer.Instance.IronmanModeIsActive && !flag)
{
PLNetworkManager.Instance.SteamCloud_WriteFileName(relativeSaveFileName, delegate(RemoteStorageFileWriteAsyncComplete_t pCallback, bool bIOFailure)
{
__instance.OnRemoteFileWriteAsyncComplete(pCallback, bIOFailure, relativeSaveFileName);
});
}
}
return(false);
}
public override void Execute(string arguments)
{
string[] args = new string[2];
args = arguments.Split(' ');
int[] CommandArg = new int[2];
bool[] ArgConvertSuccess = new bool[2];
string LowerCaseArg = args[0].ToLower();
if (PhotonNetwork.isMasterClient)
{
if (args.Length >= 1 && !string.IsNullOrEmpty(LowerCaseArg))
{
if (args.Length >= 2)
{
ArgConvertSuccess[0] = int.TryParse(args[1], out CommandArg[0]);
if (args.Length >= 3)
{
ArgConvertSuccess[1] = int.TryParse(args[2], out CommandArg[1]);
}
}
PLPlayer player = null;
switch (LowerCaseArg)
{
default:
Messaging.Notification("Not a valid subcommand. Subcommands: SetPlayerLimit, SetSlotLimit, kit, SetRoleLead ; The short versions of the commands are their capital letters, ie: SetPlayerLimit = spl");
break;
case "spl":
case "setplayerlimit":
if (ArgConvertSuccess[0])
{
if (CommandArg[0] > byte.MaxValue)
{
Messaging.Notification("Cannot input a value higher than 255");
break;
}
Global.MaxPlayers = (byte)CommandArg[0];
PLXMLOptionsIO.Instance.CurrentOptions.SetStringValue("MaxPlayerLimit", $"{Global.MaxPlayers}");
PhotonNetwork.room.MaxPlayers = CommandArg[0];
Messaging.Notification($"set room player limit to {CommandArg[0]}");
}
else
{
Messaging.Notification("Use a number. example: /setplayerlimit 2");
}
break;
case "ssl":
case "setslotlimit":
if (ArgConvertSuccess[1])
{
int classid = CommandArg[0];
if (!ArgConvertSuccess[0])
{
classid = HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]);
}
if (ArgConvertSuccess[0])
{
Global.rolelimits[classid] = CommandArg[1];
//Protect against rolelimits.sum being greater than 255
int num = Global.rolelimits.Sum();
if (num > 255)
{
Global.MaxPlayers = 255;
}
else
{
Global.MaxPlayers = (byte)num;
}
PhotonNetwork.room.MaxPlayers = Global.MaxPlayers;
Messaging.Notification($"{PLPlayer.GetClassNameFromID(classid)} player limit set to {CommandArg[1]}. Player limit is now {Global.MaxPlayers}");
SetSavedPlayerLimits();
}
}
else
{
Global.Generateplayercount();
Messaging.Notification($"current count : Capacity: \nCap {Global.playercount[1]} : {Global.rolelimits[0]} Pil {Global.playercount[2]} : {Global.rolelimits[1]} \nSci {Global.playercount[3]} : {Global.rolelimits[2]} Wep {Global.playercount[4]} : {Global.rolelimits[3]} Eng {Global.playercount[5]} : {Global.rolelimits[4]}");
}
break;
case "kit":
{
player = PLServer.Instance.GetPlayerFromPlayerID(CommandArg[0]);
if (!ArgConvertSuccess[0] && args.Length >= 2)
{
player = PLServer.Instance.GetPlayerFromPlayerID(HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]));
}
if (ArgConvertSuccess[0])
{
int level = 0;
if (ArgConvertSuccess[1])
{
level = CommandArg[1];
}
if (player != null)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 2, 0, level, 1);
if (PLServer.Instance.CrewFactionID == 4)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 24, 0, level, 2);
}
else
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 3, 0, level, 2);
}
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 4, 0, level, 3);
}
}
else
{
Messaging.Notification("Cannot find specified player. Try using a player id or class letter. Set item levels with a 2nd number. usage: /mp kit p 0");
}
break;
}
case "kit1":
{
player = PLServer.Instance.GetPlayerFromPlayerID(CommandArg[0]);
if (!ArgConvertSuccess[0] && args.Length >= 2)
{
player = PLServer.Instance.GetPlayerFromPlayerID(HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]));
}
if (ArgConvertSuccess[0])
{
int level = 0;
if (ArgConvertSuccess[1])
{
level = CommandArg[1];
}
if (player != null)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 10, 0, level, 1);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 12, 0, level, 2);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 16, 0, level, 3);
if (PLServer.Instance.CrewFactionID == 4)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 24, 0, level, 4);
}
else
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 3, 0, level, 4);
}
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 4, 0, level, 5);
}
}
else
{
Messaging.Notification("Cannot find specified player. Try using a player id or class letter. Set item levels with a 2nd number. usage: /mp kit p 0");
}
break;
}
case "kit2":
player = PLServer.Instance.GetPlayerFromPlayerID(CommandArg[0]);
if (!ArgConvertSuccess[0] && args.Length >= 2)
{
player = PLServer.Instance.GetPlayerFromPlayerID(HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]));
}
if (ArgConvertSuccess[0])
{
int level = 0;
if (ArgConvertSuccess[1])
{
level = CommandArg[1];
}
if (player != null)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 9, 0, level, 1);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 7, 0, level, 2);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 26, 0, level, 3);
if (PLServer.Instance.CrewFactionID == 4)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 24, 0, level, 4);
}
else
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 3, 0, level, 4);
}
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 4, 0, level, 5);
}
}
else
{
Messaging.Notification("Cannot find specified player. Try using a player id or class letter. Set item levels with a 2nd number. usage: /mp kit p 0");
}
break;
case "kit3":
player = PLServer.Instance.GetPlayerFromPlayerID(CommandArg[0]);
if (!ArgConvertSuccess[0] && args.Length >= 2)
{
player = PLServer.Instance.GetPlayerFromPlayerID(HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]));
}
if (ArgConvertSuccess[0])
{
int level = 0;
if (ArgConvertSuccess[1])
{
level = CommandArg[1];
}
if (player != null)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 2, 0, level, 1);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 19, 0, level, 2);
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 33, 0, level, 3);
if (PLServer.Instance.CrewFactionID == 4)
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 24, 0, level, 4);
}
else
{
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 3, 0, level, 4);
}
player.MyInventory.UpdateItem(PLServer.Instance.PawnInvItemIDCounter++, 4, 0, level, 5);
}
}
else
{
Messaging.Notification("Cannot find specified player. Try using a player id or class letter. Set item levels with a 2nd number. usage: /mp kit p 0");
}
break;
case "setrolelead":
case "srl":
if (ArgConvertSuccess[1])
{
int classid = CommandArg[0];
if (!ArgConvertSuccess[0])
{
classid = HelperMethods.GetClassIDFromClassName(args[1], out ArgConvertSuccess[0]);
}
if (ArgConvertSuccess[0])
{
if (classid > -1 && classid < 5)
{
Global.roleleads[classid] = CommandArg[1];
foreach (PhotonPlayer photonPlayer in ModMessageHelper.Instance.PlayersWithMods.Keys)
{
if (ModMessageHelper.Instance.GetPlayerMods(photonPlayer).Contains(ModMessageHelper.Instance.GetModName("Max_Players")))
{
ModMessage.SendRPC("Dragon.Max_Players", "Max_Players.SendRoleLeads", photonPlayer, new object[] { Global.roleleads });
}
}
Messaging.Notification($"Player of ID {CommandArg[1]} is now the role lead of {PLPlayer.GetClassNameFromID(classid)}");
}
else //classid is not in bounds
{
Messaging.Notification("Received a number not equal to a number between 0-4");
}
}
else //Second arg conversion was successfull, first was not.
{
Messaging.Notification("Could not find classID, set it to the first letter of the player's class or their class ID (class names in displayed order 0-4)");
}
}
else //Second arg conversion was unsuccessfull
{
Messaging.Notification("Did not detect a second argument! Try using a number");
}
break;
}
}
else
{
Messaging.Notification("Use a Subcommand. Subcommands: SetPlayerLimit, SetSlotLimit, kit, SetRoleLead ; The short versions of the commands are their capital letters, ie: SetPlayerLimit = spl");
}
}
else
{
Messaging.Notification("Must be host to perform this action.");
}
}
public static void Echo(PLPlayer recipient, string message)
{
Echo(recipient.GetPhotonPlayer(), message);
}
public override void Execute(string arguments, int SenderID)
{
if (PLNetworkManager.Instance.LocalPlayer.GetPhotonPlayer().IsMasterClient)
{
IOrderedEnumerable <Tuple <PublicCommand, PulsarPlugin> > publicCommands = ChatCommandRouter.Instance.GetPublicCommands();
if (publicCommands.Count() <= 1)
{
return;
}
PLPlayer sender = PLServer.Instance.GetPlayerFromPlayerID(SenderID);
int page = 1;
if (!string.IsNullOrWhiteSpace(arguments))
{
if (!int.TryParse(arguments, out page))
{
if (arguments[0] == '!')
{
arguments = arguments.Substring(1);
}
Tuple <PublicCommand, PulsarPlugin> t = ChatCommandRouter.Instance.GetPublicCommand(arguments);
if (t != null)
{
PublicCommand cmd = t.Item1;
string name = t.Item2 != null ? t.Item2.Name : "Pulsar Plugin Loader";
Messaging.Echo(sender, $"[&%~[C3 !{cmd.CommandAliases()[0]} ]&%~] - {cmd.Description()} <color=#ff6600ff>[{name}]</color>");
Messaging.Echo(sender, $"Aliases: !{string.Join($", !", cmd.CommandAliases())}");
Messaging.Echo(sender, $"Usage: {cmd.UsageExamples()[0]}");
for (int i = 1; i < cmd.UsageExamples().Length; i++)
{
Messaging.Echo(sender, $" {cmd.UsageExamples()[i]}");
}
}
else
{
Messaging.Echo(sender, $"Command !{arguments} not found");
}
return;
}
}
int commandsPerPage = 13 /*(PLXMLOptionsIO.Instance.CurrentOptions.GetStringValueAsInt("ChatNumLines") * 5 + 10) - 2*/; //Minimum value
int pages = Mathf.CeilToInt(publicCommands.Count() / (float)commandsPerPage);
page--; //Pages start from 1
if (page < 0)
{
page = 0;
}
string header = pages == 1 && page == 0 ? $"[&%~[C3 Available Commands: ]&%~]" : $"[&%~[C3 Available Commands: ]&%~] Page {page + 1} : {pages}";
Messaging.Echo(sender, header);
for (int i = 0; i < commandsPerPage; i++)
{
int index = i + page * commandsPerPage;
if (i + page * commandsPerPage >= publicCommands.Count())
{
break;
}
PublicCommand command = publicCommands.ElementAt(index).Item1;
Messaging.Echo(sender, $"!{command.CommandAliases()[0]} - {command.Description()}");
}
Messaging.Echo(sender, "Use [&%~[C2 !help <command> ]&%~] for details about a specific command");
}
}
public static void Centerprint(string message, PLPlayer recipient, string tag = "msg", Color color = new Color(), EWarningType type = EWarningType.E_NORMAL)
{
Centerprint(message, recipient.GetPhotonPlayer(), tag, color, type);
}
public PlayerAddedEvent(PLPlayer player) : base(player)
{
}
public static void OnPlayerRemoved(PLPlayer player)
{
PostEvent(typeof(PlayerAddedEvent), new object[] { new PlayerRemovedEvent(player) });
}
public override void Execute(string arguments)
{
string arg1 = arguments.Split(' ')[0].ToLower();
string message = arguments.Substring(arg1.Length);
PLPlayer player = null;
switch (arg1)
{
case "c":
case "captain":
player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(0);
break;
case "p":
case "pilot":
player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(1);
break;
case "s":
case "scientist":
player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(2);
break;
case "w":
case "weapons":
player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(3);
break;
case "e":
case "engineer":
player = PLServer.Instance.GetCachedFriendlyPlayerOfClass(4);
break;
default:
foreach (PLPlayer p in PLServer.Instance.AllPlayers)
{
if (p != null && p.GetPlayerName().ToLower().StartsWith(arg1))
{
player = p;
break;
}
}
break;
}
if (player != null)
{
if (!player.IsBot)
{
Messaging.Echo(PLNetworkManager.Instance.LocalPlayer.GetPhotonPlayer(), $"<color=#a0a0a0>You whisper to</color> [&%~[C{player.GetClassID()} {player.GetPlayerName()} ]&%~]<color=#a0a0a0>: {message}</color>");
PrivateMessage.SendMessage(player.GetPhotonPlayer(), message);
}
else
{
Messaging.Notification("Can't send messages to bots");
}
}
else
{
Messaging.Notification("Could not find the specified player");
}
}
public PlayerEvent(PLPlayer player)
{
Player = player;
}
