private void Start()
{
animator = GetComponent <Animator>();
FullScreenButton.SetActive(value: false);
ZonePopup.ZonePopupClosed += onZonePopupClosed;
ZonePopup.gameObject.SetActive(value: false);
Service.Get <EventDispatcher>().DispatchEvent(new AwayFromKeyboardEvent(AwayFromKeyboardStateType.Map, faceCamera: true));
zoneButtons = new Dictionary <ZoneDefinition, WorldMapZoneButton>();
WorldMapZoneButton[] componentsInChildren = GetComponentsInChildren <WorldMapZoneButton>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
zoneButtons.Add(componentsInChildren[i].ZoneDefinition, componentsInChildren[i]);
}
currentZoneDefinition = Service.Get <ZoneTransitionService>().CurrentZone;
if (zoneButtons.ContainsKey(currentZoneDefinition))
{
YouAreHereIcon.transform.position = zoneButtons[currentZoneDefinition].PopupPoint.position;
}
else
{
YouAreHereIcon.gameObject.SetActive(value: false);
}
getRoomPopulations();
logMapOpen();
}
protected override IEnumerator setup()
{
yield return(base.setup());
eventDispatcher = Service.Get <EventDispatcher>();
Service.Set(SpashScreenCanvas);
Service.Set(SpashScreenCanvas.gameObject.AddComponent <LoadingController>());
base.gameObject.AddComponent <KeyChainManager>();
Service.Set(new GameSettings());
initDataModel();
initContentAction();
yield return(StartTestCoroutine(initSchedulerAction(), this, "initSchedulerAction"));
initNetworkServices();
SceneTransitionService sts = base.gameObject.AddComponent <SceneTransitionService>();
sts.LoadingMode = LoadSceneMode.Additive;
Service.Set(sts);
TestZoneDefinition = ScriptableObject.CreateInstance <ZoneDefinition>();
TestZoneDefinition.ZoneName = "EmptySceneForLoadingTests";
TestZoneDefinition.SceneName = "EmptySceneForLoadingTests";
TestZoneDefinition.SceneFilePath = "Assets/Game/Core/Tests/IntegrationTests/ZoneAndSceneTransitionTests/EmptySceneForLoadingTests.unity";
Manifest zoneManifest = ScriptableObject.CreateInstance <Manifest>();
zoneManifest.Assets = new ScriptableObject[1] {
TestZoneDefinition
};
zts = base.gameObject.AddComponent <ZoneTransitionService>();
zts.SetZonesFromManifest(zoneManifest);
Service.Set(zts);
yield return(null);
}
public override void OnEnter()
{
dispatcher = Service.Get <EventDispatcher>();
transition = GameObject.Find(Zone + "Transition");
ZoneDefinition currentZone = Service.Get <ZoneTransitionService>().CurrentZone;
if (currentZone != null && currentZone.SceneName == Zone)
{
Finish();
return;
}
if (transition != null)
{
dispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(transition.transform));
return;
}
ZoneDefinition currentZone2 = Service.Get <ZoneTransitionService>().CurrentZone;
string value = ((currentZone2 != null) ? currentZone2.SceneName : "");
int num = Array.IndexOf(zoneMap, Zone);
int num2 = Array.IndexOf(zoneMap, value);
int num3 = -1;
string text = "";
if (num != -1 && num != num2)
{
num3 = ((num > num2) ? (num2 + 1) : (num2 - 1));
text = zoneMap[num3];
GameObject gameObject = GameObject.Find(text + "Transition");
if (gameObject != null)
{
dispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(gameObject.transform));
}
}
}
public override void OnEnter()
{
dispatcher = Service.Get <EventDispatcher>();
waypointTarget = GameObject.Find(WaypointName);
if (waypointTarget != null)
{
dispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(waypointTarget.transform, ShowOnscreenIndicator));
if (WaypointType == WaypointType.COLLIDER)
{
dispatcher.AddListener <QuestEvents.QuestWaypointTriggerEntered>(onQuestWaypointTriggerEntered);
}
else if (WaypointType == WaypointType.INTERACT)
{
GameObject localPlayerGameObject = SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject;
if (localPlayerGameObject != null)
{
localPlayerGameObject.GetComponent <LocomotionEventBroadcaster>().OnInteractionStartedEvent += onInteractionStarted;
}
}
}
else
{
ZoneDefinition currentZone = Service.Get <ZoneTransitionService>().CurrentZone;
string nextZoneInPath = Service.Get <ZonePathing>().GetNextZoneInPath(currentZone.ZoneName, WaypointZone);
GameObject gameObject = GameObject.Find(nextZoneInPath + "Transition");
if (gameObject != null)
{
dispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(gameObject.transform, ShowOnscreenIndicator));
}
}
}
void CreateZoneByDefinition(ZoneDefinition definition)
{
GameObject zoneObject = new GameObject(GameObjectPrefix + definition.Id);
RectZone zoneComponent = zoneObject.AddComponent <RectZone>();
zoneComponent.SetZone(definition);
currentZones.Add(zoneObject);
}
public override void OnExit()
{
ZoneDefinition currentZone = Service.Get <ZoneTransitionService>().CurrentZone;
if ((currentZone == null || currentZone.SceneName != Zone) && transition != null)
{
dispatcher.DispatchEvent(default(HudEvents.SetNavigationTarget));
}
}
void NewZone(ZoneDefinition zonedef)
{
if (zonedef == null)
{
return;
}
var newgameObject = new UnityEngine.GameObject();
var newZone = newgameObject.AddComponent <Zone>();
newZone.SetInfo(zonedef);
}
private SpawnPlayerParams(Vector3 position, Quaternion rotation, ZoneDefinition zone, string sceneName, SpawnedAction spawnedAction, bool nudgePlayer, bool getOutOfSwimming, Reward pendingReward)
{
Position = position;
Rotation = rotation;
Zone = zone;
SceneName = sceneName;
SpawnedAction = spawnedAction;
NudgePlayer = nudgePlayer;
GetOutOfSwimming = getOutOfSwimming;
PendingReward = pendingReward;
}
public void SetInfo(ZoneDefinition info)
{
this.info = info;
GetComponent <UnityEngine.Transform>().position = info.Location.GetPosition();
GetComponent <UnityEngine.SphereCollider>().radius = info.Location.GetRadius();
radiationamount = 0f;
if (float.TryParse(info.radiation, out radiationamount))
{
radiationzone = gameObject.AddComponent <RadiationZone>();
}
}
public void SetWaypoint(DWaypoint waypointData)
{
currentWaypointData = waypointData;
GameObject gameObject = string.IsNullOrEmpty(waypointData.WaypointName) ? waypointData.WaypointObject : GameObject.Find(waypointData.WaypointName.Trim());
CustomZonePathingTrigger[] array = Object.FindObjectsOfType <CustomZonePathingTrigger>();
for (int i = 0; i < array.Length; i++)
{
if (array[i].IsInTrigger && array[i].IsOverrideActive())
{
if (gameObject == null)
{
gameObject = array[i].OverrideWaypointTarget.gameObject;
break;
}
CustomZonePathingTarget component = gameObject.GetComponent <CustomZonePathingTarget>();
if (component == null || component.IsCustomWaypointActive())
{
gameObject = array[i].OverrideWaypointTarget.gameObject;
break;
}
}
}
EventDispatcher eventDispatcher = Service.Get <EventDispatcher>();
bool flag = true;
Vector3 onScreenIndicatorOffset = waypointData.OnScreenIndicatorOffset;
if (gameObject != null)
{
flag = false;
CustomZonePathingTarget component = gameObject.GetComponent <CustomZonePathingTarget>();
if (component != null && component.IsCustomWaypointActive())
{
gameObject = component.WaypointPosition;
}
eventDispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(gameObject.transform, waypointData.ShowOnScreenIndicator, onScreenIndicatorOffset));
}
else if (waypointData.WaypointZone != null)
{
ZoneDefinition currentZone = Service.Get <ZoneTransitionService>().CurrentZone;
string nextZoneInPath = GetNextZoneInPath(currentZone.ZoneName, waypointData.WaypointZone);
GameObject gameObject2 = GameObject.Find(nextZoneInPath + "Transition");
if (gameObject2 != null)
{
flag = false;
eventDispatcher.DispatchEvent(new HudEvents.SetNavigationTarget(gameObject2.transform));
}
}
if (flag)
{
eventDispatcher.DispatchEvent(default(HudEvents.SetNavigationTarget));
}
}
public void SetInfo(ZoneDefinition info)
{
this.info = info;
GetComponent <UnityEngine.Transform>().position = info.Location.GetPosition();
GetComponent <UnityEngine.SphereCollider>().radius = info.Location.GetRadius();
radiationamount = 0f;
this.rigidbody.position = GetComponent <UnityEngine.Transform>().position;
this.rigidbody.constraints = UnityEngine.RigidbodyConstraints.FreezeAll;
if (float.TryParse(info.radiation, out radiationamount))
{
radiationzone = gameObject.AddComponent <RadiateZone>();
}
}
public RoomPopulation GetZonePopulation(ZoneDefinition zoneDefinition)
{
if (roomPopulations != null)
{
for (int i = 0; i < roomPopulations.Count; i++)
{
if (roomPopulations[i].identifier.zoneId.name == zoneDefinition.SceneName)
{
return(roomPopulations[i]);
}
}
}
return(new RoomPopulation(new RoomIdentifier(), RoomPopulationScale.ZERO));
}
public void LoadZone(ZoneDefinition zone, string transitionScene = null, string worldName = null)
{
if (zone.Type == ZoneDefinition.ZoneType.Igloo)
{
ZoneId zoneId = new ZoneId();
zoneId.name = zone.ZoneName;
zoneId.instanceId = CurrentInstanceId;
LoadIgloo(zoneId, Service.Get <Localizer>().Language, SceneStateData.SceneState.Play, transitionScene);
}
else
{
LoadZone(zone.SceneName, transitionScene, worldName);
}
}
private void goToActivityNotification(Reward reward)
{
if (notificationData.Definition is CellPhoneQuestActivityDefinition)
{
CellPhoneQuestActivityDefinition cellPhoneQuestActivityDefinition = (CellPhoneQuestActivityDefinition)notificationData.Definition;
Mascot mascot = Service.Get <MascotService>().GetMascot(cellPhoneQuestActivityDefinition.Quest.Mascot.name);
Vector3 spawnPlayerNearMascotPosition = mascot.Definition.SpawnPlayerNearMascotPosition;
ZoneDefinition zone = mascot.Definition.Zone;
goToLocationInZone(spawnPlayerNearMascotPosition, zone.ZoneName, notificationData.Definition, reward);
}
else if (notificationData.Definition.GetType() == typeof(CellPhoneLocationActivityDefinition) || notificationData.Definition.GetType().IsSubclassOf(typeof(CellPhoneLocationActivityDefinition)))
{
goToLocationInZone((CellPhoneLocationActivityDefinition)notificationData.Definition, reward);
}
}
private bool connectToIgloo(ZoneId zoneId, ZoneDefinition zoneToJoin, Language language, string onJoinNotificationTag)
{
if (!startZoneTransition(zoneToJoin.SceneName, onJoinNotificationTag))
{
return(false);
}
ContentIdentifier contentIdentifier = generateContentIdentifier();
targetWorldToJoin = null;
Service.Get <INetworkServicesManager>().WorldService.JoinIgloo(zoneId, LocalizationLanguage.GetLanguageString(language), this);
PreviousZone = CurrentZone;
CurrentZone = zoneToJoin;
CurrentInstanceId = zoneId.instanceId;
return(IsConnecting);
}
private void InitDisplays()
{
rectTrans = GetComponentInChildren <RectTransform>();
textUI = GetComponentInChildren <Text>();
imageUI = GetComponentInChildren <Image>();
if (displayString != "" || attachedDefinition != null)
{
hasString = true;
}
if (displaySprite != null)
{
hasSprite = true;
}
if (textUI != null && hasString)
{
if (!string.IsNullOrEmpty(displayString))
{
textUI.text = Service.Get <Localizer>().GetTokenTranslation(displayString);
}
else
{
bool flag = false;
ZoneDefinition zoneDefinition = attachedDefinition as ZoneDefinition;
if (zoneDefinition != null)
{
textUI.text = Service.Get <Localizer>().GetTokenTranslation(zoneDefinition.ZoneToken);
flag = true;
}
if (!flag)
{
PropDefinition propDefinition = attachedDefinition as PropDefinition;
if (propDefinition != null)
{
textUI.text = Service.Get <Localizer>().GetTokenTranslation(propDefinition.Name);
flag = true;
}
}
if (flag)
{
}
}
}
if (imageUI != null && hasSprite)
{
imageUI.sprite = displaySprite;
}
EnableDisplays(status: false);
}
public void SetZone(ZoneDefinition zoneDefinition, bool zoneIsIgloo = false, bool showPopulationBar = true)
{
ZoneText.text = Service.Get <Localizer>().GetTokenTranslation(zoneDefinition.ZoneToken);
this.zoneDefinition = zoneDefinition;
updateZonePanel(!zoneIsIgloo);
IglooPanel.SetActive(zoneIsIgloo);
if (showPopulationBar)
{
PopulationPanel.SetActive(value: true);
UpdatePopulationBar();
}
else
{
PopulationPanel.SetActive(value: false);
}
}
private bool isPresenceDataValidForJump(PresenceData remotePresenceData)
{
if (!string.IsNullOrEmpty(remotePresenceData.World) && !string.IsNullOrEmpty(remotePresenceData.Room))
{
ZoneDefinition zone = Service.Get <ZoneTransitionService>().GetZone(remotePresenceData.Room);
if (zone != null)
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
if (cPDataEntityCollection.TryGetComponent <PresenceData>(cPDataEntityCollection.LocalPlayerHandle, out var component) && component.ContentIdentifier == remotePresenceData.ContentIdentifier)
{
return(!zone.IsQuestOnly && (zone.Type != ZoneDefinition.ZoneType.Igloo || remotePresenceData.IsInInstancedRoom));
}
}
}
return(false);
}
private void setUpPresenceData(PresenceData presenceData)
{
DetailsController.PresenceDataUpdated(FriendStatus, presenceData);
Localizer localizer = Service.Get <Localizer>();
bool flag = false;
ZoneDefinition zoneDefinition = null;
if (presenceData.IsInInstancedRoom && !string.IsNullOrEmpty(presenceData.InstanceRoom.name))
{
zoneDefinition = Service.Get <ZoneTransitionService>().GetZone(presenceData.InstanceRoom.name);
}
else if (!presenceData.IsInInstancedRoom && !string.IsNullOrEmpty(presenceData.Room))
{
zoneDefinition = Service.Get <ZoneTransitionService>().GetZone(presenceData.Room);
}
if (zoneDefinition != null)
{
OnlineSpriteSelector.IsOn = true;
flag = true;
bool flag2 = false;
if (dataEntityCollection.TryGetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle, out var component))
{
flag2 = component.ContentIdentifier == presenceData.ContentIdentifier;
}
if (flag2)
{
if (zoneDefinition.Type == ZoneDefinition.ZoneType.Igloo)
{
StatusText.text = localizer.GetTokenTranslation("PlayerCard.FriendStatus.OwnIgloo");
}
else
{
StatusText.text = localizer.GetTokenTranslationFormatted("PlayerCard.InZoneText", zoneDefinition.ZoneToken);
}
}
else
{
StatusText.text = localizer.GetTokenTranslation("GlobalUI.JumpToFriend.Disabled");
}
}
if (!flag)
{
StatusText.text = localizer.GetTokenTranslation("PlayerCard.OfflineText");
OnlineSpriteSelector.IsOn = false;
}
StatusText.gameObject.SetActive(value: true);
}
public void SetInfo(ZoneDefinition info)
{
this.info = info;
GetComponent <UnityEngine.Transform>().position = info.Location.GetPosition();
GetComponent <UnityEngine.SphereCollider>().radius = info.Location.GetRadius();
radiationamount = 0f;
zoneMask = 0;
if (info.undestr != null || info.nodecay != null)
{
zoneMask |= ((int)1) << UnityEngine.LayerMask.NameToLayer("Construction");
zoneMask |= ((int)1) << UnityEngine.LayerMask.NameToLayer("Deployed");
}
if (info.nogather != null)
{
zoneMask |= ((int)1) << UnityEngine.LayerMask.NameToLayer("Resource");
zoneMask |= ((int)1) << UnityEngine.LayerMask.NameToLayer("Tree");
}
if (info.nopve != null)
{
zoneMask |= ((int)1) << UnityEngine.LayerMask.NameToLayer("AI");
}
if (zoneMask != 0)
{
InvokeRepeating("CheckCollisions", 0f, 10f);
}
if (info.autolights != null)
{
float currentTime = GetSkyHour();
if (currentTime > AutolightOffTime && currentTime < AutolightOnTime)
{
lightsOn = true;
}
else
{
lightsOn = false;
}
InvokeRepeating("CheckLights", 0f, 10f);
}
if (float.TryParse(info.radiation, out radiationamount))
{
radiationzone = gameObject.AddComponent <RadiationZone>();
}
}
private bool spawnNearTransition(ZoneDefinition previousZone)
{
bool result = false;
GameObject gameObject = null;
ZoneTransition[] array = Object.FindObjectsOfType <ZoneTransition>();
foreach (ZoneTransition zoneTransition in array)
{
if (zoneTransition.Zone == null)
{
Log.LogErrorFormatted(this, "Invalid zone transition found while attempting to spawn player. No zone definition assigned to transition '{0}'", zoneTransition.GetPath());
}
else if (zoneTransition.Zone.ZoneName == previousZone.ZoneName)
{
gameObject = zoneTransition.gameObject;
break;
}
}
if (gameObject != null)
{
SpawnPointSelector component = gameObject.GetComponent <SpawnPointSelector>();
if (component != null)
{
result = true;
setPositionToSpawnPoint(component);
}
else
{
result = false;
}
}
else
{
MapTransition mapTransition = Object.FindObjectOfType <MapTransition>();
if (mapTransition != null)
{
SpawnPointSelector component = mapTransition.GetComponent <SpawnPointSelector>();
if (component != null)
{
result = true;
setPositionToSpawnPoint(component);
}
}
}
return(result);
}
private void onLotButton(IglooCustomizationButton customizationButton)
{
LotDefinition key = inventoryCountPairs[customizationButton.DefinitionId].Key;
ZoneDefinition zoneDefinition = zoneDefinitions[key.ZoneDefintion.Id];
if (!Service.Get <SceneTransitionService>().IsTransitioning&& Service.Get <SceneTransitionService>().CurrentScene != zoneDefinition.SceneName)
{
if (sceneLayoutData != null)
{
sceneLayoutData.LotZoneName = zoneDefinition.ZoneName;
Service.Get <ICPSwrveService>().Action("igloo", "lot_selection", sceneLayoutData.LotZoneName);
}
lastSelected.SetSelected(isSelected: false);
customizationButton.SetSelected(isSelected: true);
lastSelected = customizationButton;
eventDispatcher.DispatchEvent(new IglooUIEvents.SwapScene(zoneDefinition.SceneName));
}
}
public bool spawnAtSceneLocation()
{
bool flag = false;
ZoneDefinition previousZone = Service.Get <ZoneTransitionService>().PreviousZone;
if (previousZone != null)
{
flag = spawnNearTransition(previousZone);
}
if (!flag)
{
flag = spawnNearDefaultLocation();
}
if (ClubPenguin.Core.SceneRefs.IsSet <BaseCamera>())
{
ClubPenguin.Core.SceneRefs.Get <BaseCamera>().Snap();
}
return(flag);
}
public void OnZoneButtonPressed(WorldMapZoneButton zoneButton)
{
if (currentZonePopupZone == null || currentZonePopupZone != zoneButton.ZoneDefinition)
{
if (zoneButton == iglooZoneButton)
{
zoneButton.GetComponent <ShowIglooListButton>().OnButton();
Service.Get <ICPSwrveService>().Action("igloo", "igloo_list", "map");
Object.Destroy(base.gameObject);
return;
}
ZonePopup.gameObject.SetActive(value: true);
currentZonePopupZone = zoneButton.ZoneDefinition;
ZonePopup.SetPosition(new Vector2(zoneButton.PopupPoint.position.x, zoneButton.PopupPoint.position.y));
ZonePopup.SetZone(zoneButton.ZoneDefinition, zoneButton == iglooZoneButton, zoneButton != iglooZoneButton);
ZonePopup.Open();
logZonePressed(zoneButton.ZoneDefinition);
}
}
public void SetZonesFromManifest(Manifest manifest)
{
Zones.Clear();
ScriptableObject[] assets = manifest.Assets;
for (int i = 0; i < assets.Length; i++)
{
ZoneDefinition item = (ZoneDefinition)assets[i];
Zones.Add(item);
}
string name = SceneManager.GetActiveScene().name;
foreach (ZoneDefinition zone in Zones)
{
if (zone.SceneName == name)
{
CurrentZone = zone;
break;
}
}
}
void cmdChatZoneAdd(BasePlayer player, string command, string[] args)
{
if (!hasPermission(player, "zone"))
{
SendMessage(player, "You don't have access to this command"); return;
}
var newzoneinfo = new ZoneDefinition(player.transform.position);
newzoneinfo.ID = GetRandom(1, 99999999).ToString();
NewZone(newzoneinfo);
if (zonedefinitions[newzoneinfo.ID] != null)
{
storedData.ZoneDefinitions.Remove(zonedefinitions[newzoneinfo.ID]);
}
zonedefinitions[newzoneinfo.ID] = newzoneinfo;
LastZone[player] = newzoneinfo.ID;
storedData.ZoneDefinitions.Add(zonedefinitions[newzoneinfo.ID]);
SaveData();
SendMessage(player, "New Zone created, you may now edit it: " + newzoneinfo.Location.String());
}
public bool ConnectToZone(string sceneName, string worldName = null, string onJoinNotificationTag = null)
{
ZoneDefinition zoneBySceneName = GetZoneBySceneName(sceneName);
if (zoneBySceneName == null)
{
Log.LogError(this, "Attempting to join a zone that doesn't exist");
return(false);
}
if (!startZoneTransition(sceneName, onJoinNotificationTag))
{
return(false);
}
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle);
ContentIdentifier contentIdentifier = generateContentIdentifier();
if (!string.IsNullOrEmpty(worldName))
{
targetWorldToJoin = worldName;
ZoneId zoneId = new ZoneId();
zoneId.name = zoneBySceneName.ZoneName;
Service.Get <INetworkServicesManager>().WorldService.JoinRoomInWorld(new RoomIdentifier(worldName, Service.Get <Localizer>().Language, zoneId, contentIdentifier.ToString()), this);
}
else if (component != null && !string.IsNullOrEmpty(component.World))
{
targetWorldToJoin = component.World;
ZoneId zoneId = new ZoneId();
zoneId.name = zoneBySceneName.ZoneName;
Service.Get <INetworkServicesManager>().WorldService.JoinRoomInWorld(new RoomIdentifier(component.World, Service.Get <Localizer>().Language, zoneId, contentIdentifier.ToString()), this);
}
else
{
targetWorldToJoin = null;
Service.Get <INetworkServicesManager>().WorldService.JoinRoom(zoneBySceneName.ZoneName, contentIdentifier.ToString(), Service.Get <Localizer>().LanguageString, this);
}
PreviousZone = CurrentZone;
CurrentZone = zoneBySceneName;
CurrentInstanceId = "";
return(IsConnecting);
}
private bool onSelfJoinedRoom(WorldServiceEvents.SelfRoomJoinedEvent evt)
{
IsConnecting = false;
dispatcher.RemoveListener <WorldServiceEvents.SelfRoomJoinedEvent>(onSelfJoinedRoom);
ZoneDefinition zone = GetZone(evt.Room.zoneId.name);
if (zone != null && !zone.IsQuestOnly && zone.Type != ZoneDefinition.ZoneType.Igloo)
{
Service.Get <GameSettings>().LastZone.SetValue(evt.Room.zoneId.name);
IsInIgloo = false;
}
else if (zone != null)
{
IsInIgloo = (zone.Type == ZoneDefinition.ZoneType.Igloo);
}
checkIfZoneTransitionComplete();
checkForLocalizationChange(GetWorld(evt.Room.world));
if (targetWorldToJoin != null && targetWorldToJoin != evt.Room.world)
{
onJoinNotificationTag = "GlobalUI.Notification.WorldBump";
}
if (!string.IsNullOrEmpty(onJoinNotificationTag))
{
DNotification dNotification = new DNotification();
dNotification.Message = string.Format(Service.Get <Localizer>().GetTokenTranslation(onJoinNotificationTag), evt.Room.world);
dNotification.PopUpDelayTime = 6f;
dNotification.WaitForLoading = true;
dNotification.PersistBetweenScenes = false;
Service.Get <TrayNotificationManager>().ShowNotification(dNotification);
onJoinNotificationTag = string.Empty;
}
Service.Get <ICPSwrveService>().EndTimer("igloo");
if (zone.Type == ZoneDefinition.ZoneType.Igloo)
{
startBIVisitIglooTimer(evt);
}
return(false);
}
public void LoadIgloo(ZoneId zoneId, Language language, SceneStateData.SceneState sceneState, string transitionScene = null, string onJoinNotificationTag = null)
{
ZoneDefinition zone = GetZone(zoneId.name);
if (isSceneTransitionValid(zone.SceneName))
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add(SceneTransitionService.SceneArgs.LoadingScreenOverride.ToString(), IglooSplashScreen.Key);
sceneTransition(zone.SceneName, transitionScene, dictionary);
connectToIgloo(zoneId, zone, language, onJoinNotificationTag);
}
DataEntityHandle dataEntityHandle = dataEntityCollection.FindEntityByName("ActiveSceneData");
if (dataEntityHandle.IsNull)
{
dataEntityHandle = dataEntityCollection.AddEntity("ActiveSceneData");
}
if (!dataEntityCollection.TryGetComponent(dataEntityHandle, out SceneStateData component))
{
component = dataEntityCollection.AddComponent <SceneStateData>(dataEntityHandle);
}
component.State = sceneState;
}
private static List <ZoneDefinition> readZoneDefCSV(string fp, Library Lib)
{
var records = new List <ZoneDefinition>();
using (var sr = new StreamReader(fp))
{
var csv = new CsvReader(sr);
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
try
{
ZoneDefinition record = new ZoneDefinition();
record.Name = csv.GetField <string>("Name");
string loads = csv.GetField <string>("Loads");
string cond = csv.GetField <string>("Conditioning");
string vent = csv.GetField <string>("Ventilation");
string hotwater = csv.GetField <string>("HotWater");
string constructions = csv.GetField <string>("Constructions");
record.Loads = Lib.ZoneLoads.First(x => x.Name == loads);
record.Conditioning = Lib.ZoneConditionings.First(x => x.Name == cond);
record.Ventilation = Lib.ZoneVentilations.First(x => x.Name == vent);
record.DomHotWater = Lib.DomHotWaters.First(x => x.Name == hotwater);
record.Materials = Lib.ZoneConstructions.First(x => x.Name == constructions);
records.Add(record);
}
catch (Exception ex) { Debug.WriteLine(ex.Message); }
}
}
return(records);
}
public void SetInfo(ZoneDefinition info)
{
this.info = info;
GetComponent<UnityEngine.Transform>().position = info.Location.GetPosition();
GetComponent<UnityEngine.SphereCollider>().radius = info.Location.GetRadius();
radiationamount = 0f;
zoneMask = 0;
if(info.undestr != null || info.nodecay != null)
{
zoneMask |= ((int)1) << LayerMask.NameToLayer("Construction");
zoneMask |= ((int)1) << LayerMask.NameToLayer("Deployed");
}
if(info.nogather != null)
{
zoneMask |= ((int)1) << LayerMask.NameToLayer("Resource");
zoneMask |= ((int)1) << LayerMask.NameToLayer("Tree");
}
if (info.nopve != null)
{
zoneMask |= ((int)1) << LayerMask.NameToLayer("AI");
}
if (zoneMask != 0) InvokeRepeating("CheckCollisions", 0f, 10f);
if (info.autolights != null)
{
float currentTime = GetSkyHour();
if (currentTime > AutolightOffTime && currentTime < AutolightOnTime)
{
lightsOn = true;
}
else
{
lightsOn = false;
}
InvokeRepeating("CheckLights", 0f, 10f);
}
if (float.TryParse(info.radiation, out radiationamount))
radiationzone = gameObject.AddComponent<RadiationZone>();
}
void NewZone(ZoneDefinition zonedef)
{
if (zonedef == null) return;
var newgameObject = new UnityEngine.GameObject();
var newZone = newgameObject.AddComponent<Zone>();
newZone.SetInfo(zonedef);
}
/////////////////////////////////////////
// External calls to this plugin
/////////////////////////////////////////
/////////////////////////////////////////
// CreateOrUpdateZone(string ZoneID, object[] args)
// Create or Update a zone from an external plugin
// ZoneID should be a name, like Arena (for an arena plugin) (even if it's called an ID :p)
// args are the same a the /zone command
// args[0] = "radius" args[1] = "50" args[2] = "eject" args[3] = "true", etc
// Third parameter is obviously need if you create a NEW zone (or want to update the position)
/////////////////////////////////////////
bool CreateOrUpdateZone(string ZoneID, string[] args, Vector3 position = default(Vector3))
{
var zonedef = zonedefinitions[ZoneID];
if (zonedefinitions[ZoneID] != null) storedData.ZoneDefinitions.Remove(zonedefinitions[ZoneID]);
if (zonedef == null)
{
zonedef = new ZoneDefinition();
zonedef.ID = ZoneID;
}
string editvalue;
for (int i = 0; i < args.Length; i = i + 2)
{
cachedField = GetZoneField(args[i]);
if (cachedField == null) continue;
switch (args[i + 1])
{
case "true":
case "1":
editvalue = "true";
break;
case "null":
case "0":
case "false":
case "reset":
editvalue = null;
break;
default:
editvalue = (string)args[i + 1];
break;
}
cachedField.SetValue(zonedef, editvalue);
if (args[i].ToLower() == "radius") { if (zonedef.Location != null) zonedef.Location = new ZoneLocation(zonedef.Location.GetPosition(), editvalue); }
}
if (position != default(Vector3)) { zonedef.Location = new ZoneLocation((Vector3)position, (zonedef.radius != null) ? zonedef.radius : "20"); }
zonedefinitions[ZoneID] = zonedef;
storedData.ZoneDefinitions.Add(zonedefinitions[ZoneID]);
SaveData();
if (zonedef.Location == null) return false;
RefreshZone(ZoneID);
return true;
}
void cmdChatZoneAdd(BasePlayer player, string command, string[] args)
{
if (!hasPermission(player, "zone")) { SendMessage(player, "You don't have access to this command"); return; }
var newzoneinfo = new ZoneDefinition(player.transform.position);
newzoneinfo.ID = GetRandom(1, 99999999).ToString();
NewZone(newzoneinfo);
if (zonedefinitions[newzoneinfo.ID] != null) storedData.ZoneDefinitions.Remove(zonedefinitions[newzoneinfo.ID]);
zonedefinitions[newzoneinfo.ID] = newzoneinfo;
LastZone[player] = newzoneinfo.ID;
storedData.ZoneDefinitions.Add(zonedefinitions[newzoneinfo.ID]);
SaveData();
ShowZone(player, LastZone[player]);
SendMessage(player, "New Zone created, you may now edit it: " + newzoneinfo.Location.String());
}
private void NewZone(ZoneDefinition zonedef)
{
if (zonedef == null) return;
var newZone = new GameObject().AddComponent<Zone>();
newZone.ZoneManagerPlugin = this;
newZone.SetInfo(zonedef);
zoneObjects = Resources.FindObjectsOfTypeAll<Zone>();
}
private void cmdChatZoneAdd(BasePlayer player, string command, string[] args)
{
if (!hasPermission(player, PermZone)) { SendMessage(player, "You don't have access to this command"); return; }
var newzoneinfo = new ZoneDefinition(player.transform.position) { ID = UnityEngine.Random.Range(1, 99999999).ToString() };
NewZone(newzoneinfo);
if (ZoneDefinitions.ContainsKey(newzoneinfo.ID)) storedData.ZoneDefinitions.Remove(ZoneDefinitions[newzoneinfo.ID]);
ZoneDefinitions[newzoneinfo.ID] = newzoneinfo;
LastZone[player.userID] = newzoneinfo.ID;
storedData.ZoneDefinitions.Add(newzoneinfo);
SaveData();
ShowZone(player, newzoneinfo.ID);
SendMessage(player, "New Zone created, you may now edit it: " + newzoneinfo.Location);
}
/////////////////////////////////////////
// External calls to this plugin
/////////////////////////////////////////
/////////////////////////////////////////
// CreateOrUpdateZone(string ZoneID, object[] args)
// Create or Update a zone from an external plugin
// ZoneID should be a name, like Arena (for an arena plugin) (even if it's called an ID :p)
// args are the same a the /zone command
// args[0] = "radius" args[1] = "50" args[2] = "Eject" args[3] = "true", etc
// Third parameter is obviously need if you create a NEW zone (or want to update the position)
/////////////////////////////////////////
private bool CreateOrUpdateZone(string zoneId, string[] args, Vector3 position = default(Vector3))
{
ZoneDefinition zonedef;
if (!ZoneDefinitions.TryGetValue(zoneId, out zonedef))
zonedef = new ZoneDefinition { ID = zoneId, radius = 20 };
else
storedData.ZoneDefinitions.Remove(zonedef);
UpdateZoneDefinition(zonedef, args);
if (position != default(Vector3))
zonedef.Location = position;
ZoneDefinitions[zoneId] = zonedef;
storedData.ZoneDefinitions.Add(zonedef);
SaveData();
if (zonedef.Location == null) return false;
RefreshZone(zoneId);
return true;
}
public void SetInfo(ZoneDefinition info)
{
this.info = info;
GetComponent<UnityEngine.Transform>().position = info.Location.GetPosition();
GetComponent<UnityEngine.SphereCollider>().radius = info.Location.GetRadius();
radiationamount = 0f;
this.rigidbody.position = GetComponent<UnityEngine.Transform>().position;
this.rigidbody.constraints = UnityEngine.RigidbodyConstraints.FreezeAll;
if (float.TryParse(info.radiation, out radiationamount))
radiationzone = gameObject.AddComponent<RadiateZone>();
}
private void NewZone(ZoneDefinition zonedef)
{
if (zonedef == null) return;
var newgameObject = new GameObject();
var newZone = newgameObject.AddComponent<Zone>();
newZone.ZoneManagerPlugin = this;
newZone.SetInfo(zonedef);
zoneObjects = UnityEngine.Object.FindObjectsOfType<Zone>();
}
private static void AddZoneFlag(ZoneDefinition zone, ZoneFlags flag)
{
zone.flags |= flag;
}
private static void RemoveZoneFlag(ZoneDefinition zone, ZoneFlags flag)
{
zone.flags &= ~flag;
}
public void SetInfo(ZoneDefinition info)
{
Info = info;
if (Info == null) return;
gameObject.name = $"Zone Manager({Info.ID})";
transform.position = Info.Location;
transform.rotation = Quaternion.Euler(Info.Rotation);
UpdateCollider();
gameObject.SetActive(Info.enabled);
enabled = Info.enabled;
if (ZoneManagerPlugin.HasZoneFlag(this, ZoneFlags.AutoLights))
{
var currentTime = GetSkyHour();
if (currentTime > ZoneManagerPlugin.AutolightOffTime && currentTime < ZoneManagerPlugin.AutolightOnTime)
lightsOn = true;
else
lightsOn = false;
if (IsInvoking("CheckLights")) CancelInvoke("CheckLights");
InvokeRepeating("CheckLights", 5f, 30f);
}
var radiation = gameObject.GetComponent<TriggerRadiation>();
if (Info.radiation > 0)
{
radiation = radiation ?? gameObject.AddComponent<TriggerRadiation>();
radiation.RadiationAmount = Info.radiation;
radiation.radiationSize = Info.radius;
radiation.interestLayers = playersMask;
radiation.enabled = Info.enabled;
}
else if (radiation != null)
{
radiation.RadiationAmount = 0;
radiation.radiationSize = 0;
radiation.interestLayers = playersMask;
radiation.enabled = false;
//Destroy(radiation);
}
if (IsInvoking("CheckEntites")) CancelInvoke("CheckEntites");
InvokeRepeating("CheckEntites", 10f, 10f);
/*if (HasAnyFlag(info.flags, ZoneFlags.Eject | ZoneFlags.EjectSleepers
| ZoneFlags.KillSleepers | ZoneFlags.NoBleed | ZoneFlags.NoBoxLoot | ZoneFlags.NoBuild
| ZoneFlags.NoChat | ZoneFlags.NoDeploy | ZoneFlags.NoDrown | ZoneFlags.NoKits
| ZoneFlags.NoPlayerLoot | ZoneFlags.NoRemove | ZoneFlags.NoSuicide | ZoneFlags.NoTp
| ZoneFlags.NoUpgrade | ZoneFlags.NoWounded | ZoneFlags.PveGod | ZoneFlags.PvpGod
| ZoneFlags.SleepGod | ZoneFlags.AutoLights))
{
Interface.Oxide.LogInfo("Mask: Player (Server)");
}*/
}
private void UpdateZoneDefinition(ZoneDefinition zone, string[] args, BasePlayer player = null)
{
for (var i = 0; i < args.Length; i = i + 2)
{
object editvalue;
switch (args[i].ToLower())
{
case "name":
editvalue = zone.name = args[i + 1];
break;
case "id":
editvalue = zone.ID = args[i + 1];
break;
case "radiation":
editvalue = zone.radiation = float.Parse(args[i + 1]);
break;
case "radius":
editvalue = zone.radius = float.Parse(args[i + 1]);
break;
case "rotation":
zone.Rotation = player?.GetNetworkRotation() ?? Vector3.zero;/* + Quaternion.AngleAxis(90, Vector3.up).eulerAngles*/
zone.Rotation.x = 0;
editvalue = zone.Rotation;
break;
case "size":
var size = args[i + 1].Trim().Split(' ');
if (size.Length == 3)
editvalue = zone.Size = new Vector3(float.Parse(size[0]), float.Parse(size[1]), float.Parse(size[2]));
else
{
if (player != null) SendMessage(player, "Invalid size format, use: \"x y z\"");
continue;
}
break;
case "enter_message":
editvalue = zone.enter_message = args[i + 1];
break;
case "leave_message":
editvalue = zone.leave_message = args[i + 1];
break;
case "enabled":
case "enable":
editvalue = zone.enabled = GetBoolValue(args[i + 1]);
break;
default:
try
{
var flag = (ZoneFlags)Enum.Parse(typeof(ZoneFlags), args[i], true);
var boolValue = GetBoolValue(args[i + 1]);
editvalue = boolValue;
if (boolValue) AddZoneFlag(zone, flag);
else RemoveZoneFlag(zone, flag);
}
catch
{
if (player != null) SendMessage(player, $"Unknown zone flag: {args[i]}");
continue;
}
break;
}
if (player != null) SendMessage(player, $"{args[i]} set to {editvalue}");
}
}
public void SetInfo(ZoneDefinition info)
{
Info = info;
if (Info == null) return;
gameObject.name = $"Zone Manager({Info.ID})";
transform.position = Info.Location;
transform.rotation = Quaternion.Euler(Info.Rotation);
UpdateCollider();
gameObject.SetActive(Info.enabled);
enabled = Info.enabled;
if (ZoneManagerPlugin.HasZoneFlag(this, ZoneFlags.AutoLights))
{
var currentTime = GetSkyHour();
if (currentTime > ZoneManagerPlugin.AutolightOffTime && currentTime < ZoneManagerPlugin.AutolightOnTime)
lightsOn = true;
else
lightsOn = false;
InvokeRepeating("CheckLights", 5f, 10f);
}
var radiation = gameObject.GetComponent<TriggerRadiation>();
if (Info.radiation > 0)
{
radiation = radiation ?? gameObject.AddComponent<TriggerRadiation>();
radiation.RadiationAmount = Info.radiation;
radiation.radiationSize = Info.radius;
radiation.interestLayers = playersMask;
radiation.enabled = Info.enabled;
} else if (radiation != null)
{
radiation.RadiationAmount = 0;
radiation.radiationSize = 0;
radiation.interestLayers = playersMask;
radiation.enabled = false;
//Destroy(radiation);
}
}
