2077 lines
99 KiB
C#
2077 lines
99 KiB
C#
using DG.Tweening;
|
|
using Lidgren.Network;
|
|
using MonomiPark.SlimeRancher.DataModel;
|
|
using MonomiPark.SlimeRancher.Regions;
|
|
using SRMultiplayer.Packets;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace SRMultiplayer.Networking
|
|
{
|
|
public static class NetworkHandlerClient
|
|
{
|
|
public static void HandlePacket(PacketType type, NetIncomingMessage im)
|
|
{
|
|
if (!Globals.PacketSize.ContainsKey(type))
|
|
Globals.PacketSize.Add(type, 0);
|
|
Globals.PacketSize[type] += im.LengthBytes;
|
|
switch (type)
|
|
{
|
|
//Player amimations
|
|
case PacketType.PlayerAnimation: OnPlayerAnimation(new PacketPlayerAnimation(im)); break;
|
|
|
|
//Players
|
|
case PacketType.PlayerJoined: OnPlayerJoined(new PacketPlayerJoined(im)); break;
|
|
case PacketType.PlayerLeft: OnPlayerLeft(new PacketPlayerLeft(im)); break;
|
|
case PacketType.PlayerLoaded: OnPlayerLoaded(new PacketPlayerLoaded(im)); break;
|
|
case PacketType.PlayerPosition: OnPlayerPosition(new PacketPlayerPosition(im)); break;
|
|
case PacketType.PlayerFX: OnPlayerFX(new PacketPlayerFX(im)); break;
|
|
case PacketType.PlayerCurrency: OnPlayerCurrency(new PacketPlayerCurrency(im)); break;
|
|
case PacketType.PlayerCurrencyDisplay: OnPlayerCurrencyDisplay(new PacketPlayerCurrencyDisplay(im)); break;
|
|
case PacketType.PlayerUpgrade: OnPlayerUpgrade(new PacketPlayerUpgrade(im)); break;
|
|
case PacketType.PlayerUpgradeUnlock: OnPlayerUpgradeUnlock(new PacketPlayerUpgradeUnlock(im)); break;
|
|
case PacketType.PlayerChat: OnPlayerChat(new PacketPlayerChat(im)); break;
|
|
|
|
// Region
|
|
case PacketType.RegionOwner: OnRegionOwner(new PacketRegionOwner(im)); break;
|
|
|
|
//Actors
|
|
case PacketType.Actors: OnActors(new PacketActors(im)); break;
|
|
case PacketType.ActorSpawn: OnActorSpawn(new PacketActorSpawn(im)); break;
|
|
case PacketType.ActorDestroy: OnActorDestroy(new PacketActorDestroy(im)); break;
|
|
case PacketType.ActorOwner: OnActorOwner(new PacketActorOwner(im)); break;
|
|
case PacketType.ActorPosition: OnActorPosition(new PacketActorPosition(im)); break;
|
|
case PacketType.ActorResourceAttach: OnActorResourceAttach(new PacketActorResourceAttach(im)); break;
|
|
case PacketType.ActorResourceState: OnActorResourceState(new PacketActorResourceState(im)); break;
|
|
case PacketType.ActorReproduceTime: OnActorReproduceTime(new PacketActorReproduceTime(im)); break;
|
|
case PacketType.ActorEmotions: OnActorEmotions(new PacketActorEmotions(im)); break;
|
|
case PacketType.ActorFeral: OnActorFeral(new PacketActorFeral(im)); break;
|
|
case PacketType.ActorFX: OnActorFX(new PacketActorFX(im)); break;
|
|
//LandPlots
|
|
case PacketType.LandPlots: OnLandPlots(new PacketLandplots(im)); break;
|
|
case PacketType.LandPlotSiloInsert: OnLandPlotSiloInsert(new PacketLandPlotSiloInsert(im)); break;
|
|
case PacketType.LandPlotSiloRemove: OnLandPlotSiloRemove(new PacketLandPlotSiloRemove(im)); break;
|
|
case PacketType.LandPlotAsh: OnLandPlotAsh(new PacketLandPlotAsh(im)); break;
|
|
case PacketType.LandPlotSiloSlot: OnLandPlotSiloSlot(new PacketLandPlotSiloSlot(im)); break;
|
|
case PacketType.LandPlotFeederSpeed: OnLandPlotFeederSpeed(new PacketLandPlotFeederSpeed(im)); break;
|
|
case PacketType.LandPlotCollect: OnLandPlotCollect(new PacketLandPlotCollect(im)); break;
|
|
case PacketType.LandPlotReplace: OnLandPlotReplace(new PacketLandPlotReplace(im)); break;
|
|
case PacketType.LandPlotUpgrade: OnLandPlotUpgrade(new PacketLandPlotUpgrade(im)); break;
|
|
case PacketType.LandPlotPlantGarden: OnLandPlotPlantGarden(new PacketLandPlotPlantGarden(im)); break;
|
|
case PacketType.LandPlotStartCollection: OnLandPlotStartCollection(new PacketLandPlotStartCollection(im)); break;
|
|
case PacketType.LandPlotSiloAmmoAdd: OnLandPlotSiloAmmoAdd(new PacketLandPlotSiloAmmoAdd(im)); break;
|
|
case PacketType.LandPlotSiloAmmoRemove: OnLandPlotSiloAmmoRemove(new PacketLandPlotSiloAmmoRemove(im)); break;
|
|
case PacketType.LandPlotSiloAmmoClear: OnLandPlotSiloAmmoClear(new PacketLandPlotSiloAmmoClear(im)); break;
|
|
//World
|
|
case PacketType.WorldData: OnWorldData(new PacketWorldData(im)); break;
|
|
case PacketType.WorldTime: OnWorldTime(new PacketWorldTime(im)); break;
|
|
case PacketType.WorldFastForward: OnWorldFastForward(new PacketWorldFastForward(im)); break;
|
|
case PacketType.WorldProgress: OnWorldProgress(new PacketWorldProgress(im)); break;
|
|
case PacketType.WorldKey: OnWorldKey(new PacketWorldKey(im)); break;
|
|
case PacketType.WorldMapUnlock: OnWorldMapUnlock(new PacketWorldMapUnlock(im)); break;
|
|
case PacketType.WorldSwitchActivate: OnWorldSwitchActivate(new PacketWorldSwitchActivate(im)); break;
|
|
case PacketType.WorldSelectPalette: OnWorldSelectPalette(new PacketWorldSelectPalette(im)); break;
|
|
case PacketType.WorldSwitches: OnWorldSwitches(new PacketWorldSwitches(im)); break;
|
|
case PacketType.WorldDecorizer: OnWorldDecorizer(new PacketWorldDecorizer(im)); break;
|
|
case PacketType.WorldDecorizerSetting: OnWorldDecorizerSetting(new PacketWorldDecorizerSetting(im)); break;
|
|
case PacketType.WorldMarketPrices: OnWorldMarketPrices(new PacketWorldMarketPrices(im)); break;
|
|
case PacketType.WorldCredits: OnWorldCredits(new PacketWorldCredits(im)); break;
|
|
case PacketType.WorldMailSend: OnWorldMailSend(new PacketWorldMailSend(im)); break;
|
|
case PacketType.WorldMailRead: OnWorldMailRead(new PacketWorldMailRead(im)); break;
|
|
//FX
|
|
case PacketType.GlobalFX: OnGlobalFX(new PacketGlobalFX(im)); break;
|
|
case PacketType.IncinerateFX: OnIncinerateFX(new PacketIncinerateFX(im)); break;
|
|
case PacketType.PlayAudio: OnPlayAudio(new PacketPlayAudio(im)); break;
|
|
//AccessDoors
|
|
case PacketType.AccessDoors: OnAccessDoors(new PacketAccessDoors(im)); break;
|
|
case PacketType.AccessDoorOpen: OnAccessDoorOpen(new PacketAccessDoorOpen(im)); break;
|
|
//Gordos
|
|
case PacketType.Gordos: OnGordos(new PacketGordos(im)); break;
|
|
case PacketType.GordoEat: OnGordoEat(new PacketGordoEat(im)); break;
|
|
//PuzzleSlots
|
|
case PacketType.PuzzleSlots: OnPuzzleSlots(new PacketPuzzleSlots(im)); break;
|
|
case PacketType.PuzzleSlotFilled: OnPuzzleSlotFilled(new PacketPuzzleSlotFilled(im)); break;
|
|
case PacketType.PuzzleGateActivate: OnPuzzleGateActivate(new PacketPuzzleGateActivate(im)); break;
|
|
//Pedia
|
|
case PacketType.PediaShowPopup: OnPediaShowPopup(new PacketPediaShowPopup(im)); break;
|
|
case PacketType.PediaUnlock: OnPediaUnlock(new PacketPediaUnlock(im)); break;
|
|
//gadgets
|
|
case PacketType.Gadgets: OnGadgets(new PacketGadgets(im)); break;
|
|
case PacketType.GadgetRemove: OnGadgetRemove(new PacketGadgetRemove(im)); break;
|
|
case PacketType.GadgetRotation: OnGadgetRotation(new PacketGadgetRotation(im)); break;
|
|
case PacketType.GadgetRefinerySpend: OnGadgetRefinerySpend(new PacketGadgetRefinerySpend(im)); break;
|
|
case PacketType.GadgetAdd: OnGadgetAdd(new PacketGadgetAdd(im)); break;
|
|
case PacketType.GadgetAddBlueprint: OnGadgetAddBlueprint(new PacketGadgetAddBlueprint(im)); break;
|
|
case PacketType.GadgetSpend: OnGadgetSpend(new PacketGadgetSpend(im)); break;
|
|
case PacketType.GadgetSpawn: OnGadgetSpawn(new PacketGadgetSpawn(im)); break;
|
|
case PacketType.GadgetExtractorUpdate: OnGadgetExtractorUpdate(new PacketGadgetExtractorUpdate(im)); break;
|
|
case PacketType.GadgetTurrets: OnGadgetTurrets(new PacketGadgetTurrets(im)); break;
|
|
case PacketType.GadgetSnareAttach: OnGadgetSnareAttach(new PacketGadgetSnareAttach(im)); break;
|
|
case PacketType.GadgetSnareGordo: OnGadgetSnareGordo(new PacketGadgetSnareGordo(im)); break;
|
|
case PacketType.GadgetEchoNetTime: OnGadgetEchoNetTime(new PacketGadgetEchoNetTime(im)); break;
|
|
//Fashion
|
|
case PacketType.FashionAttach: OnFashionAttach(new PacketFashionAttach(im)); break;
|
|
case PacketType.FashionDetachAll: OnFashionDetachAll(new PacketFashionDetachAll(im)); break;
|
|
//Drone
|
|
case PacketType.DroneAmmoAdd: OnDroneAmmoAdd(new PacketDroneAmmoAdd(im)); break;
|
|
case PacketType.DroneAmmoClear: OnDroneAmmoClear(new PacketDroneAmmoClear(im)); break;
|
|
case PacketType.DroneAmmoRemove: OnDroneAmmoRemove(new PacketDroneAmmoRemove(im)); break;
|
|
case PacketType.DroneAnimation: OnDroneAnimation(new PacketDroneAnimation(im)); break;
|
|
case PacketType.DronePrograms: OnDronePrograms(new PacketDronePrograms(im)); break;
|
|
case PacketType.DroneLiquid: OnDroneLiquid(new PacketDroneLiquid(im)); break;
|
|
case PacketType.DroneStationEnabled: OnDroneStationEnabled(new PacketDroneStationEnabled(im)); break;
|
|
case PacketType.DronePosition: OnDronePosition(new PacketDronePosition(im)); break;
|
|
case PacketType.DroneActive: OnDroneActive(new PacketDroneActive(im)); break;
|
|
//TreasurePod
|
|
case PacketType.TreasurePods: OnTreasurePods(new PacketTreasurePods(im)); break;
|
|
case PacketType.TreasurePodOpen: OnTreasurePodOpen(new PacketTreasurePodOpen(im)); break;
|
|
//Exchanges
|
|
case PacketType.ExchangeOffers: OnExchangeOffers(new PacketExchangeOffers(im)); break;
|
|
case PacketType.ExchangeOffer: OnExchangeOffer(new PacketExchangeOffer(im)); break;
|
|
case PacketType.ExchangeClear: OnExchangeClear(new PacketExchangeClear(im)); break;
|
|
case PacketType.ExchangePrepareDaily: OnExchangePrepareDaily(new PacketExchangePrepareDaily(im)); break;
|
|
case PacketType.ExchangeTryAccept: OnExchangeTryAccept(new PacketExchangeTryAccept(im)); break;
|
|
//Oasis
|
|
case PacketType.Oasis: OnOasis(new PacketOasis(im)); break;
|
|
case PacketType.OasisLive: OnOasisLive(new PacketOasisLive(im)); break;
|
|
//FireColumns
|
|
case PacketType.FireColumnActivate: OnFireColumnActivate(new PacketFireColumnActivate(im)); break;
|
|
case PacketType.FireStormMode: OnFireStormMode(new PacketFireStormMode(im)); break;
|
|
//Others
|
|
case PacketType.GingerAction: OnGingerAction(new PacketGingerAction(im)); break;
|
|
case PacketType.KookadobaAction: OnKookadobaAction(new PacketKookadobaAction(im)); break;
|
|
case PacketType.GingerAttach: OnGingerAttach(new PacketGingerAttach(im)); break;
|
|
case PacketType.KookadobaAttach: OnKookadobaAttach(new PacketKookadobaAttach(im)); break;
|
|
// Race
|
|
case PacketType.RaceActivate: OnRaceActivate(new PacketRaceActivate(im)); break;
|
|
case PacketType.RaceEnd: OnRaceEnd(new PacketRaceEnd(im)); break;
|
|
case PacketType.RaceTime: OnRaceTime(new PacketRaceTime(im)); break;
|
|
case PacketType.RaceTrigger: OnRaceTrigger(new PacketRaceTrigger(im)); break;
|
|
default:
|
|
SRMP.Log($"Got unhandled packet: {type} " + Enum.GetName(typeof(PacketType), type));
|
|
break;
|
|
}
|
|
}
|
|
|
|
#region Race
|
|
private static void OnRaceTrigger(PacketRaceTrigger packet)
|
|
{
|
|
if (Globals.RaceTriggers.TryGetValue(packet.ID, out NetworkRaceTrigger trigger))
|
|
{
|
|
trigger.Activate();
|
|
}
|
|
}
|
|
|
|
private static void OnRaceTime(PacketRaceTime packet)
|
|
{
|
|
var generator = QuicksilverEnergyGenerator.allGenerators.FirstOrDefault(g => g.id == packet.ID);
|
|
if (generator)
|
|
{
|
|
generator.ExtendActiveDuration(packet.Time);
|
|
}
|
|
}
|
|
|
|
private static void OnRaceEnd(PacketRaceEnd packet)
|
|
{
|
|
var generator = QuicksilverEnergyGenerator.allGenerators.FirstOrDefault(g => g.id == packet.ID);
|
|
if (generator)
|
|
{
|
|
generator.SetState(QuicksilverEnergyGenerator.State.COOLDOWN, Globals.LocalPlayer.CurrentGenerator != null && Globals.LocalPlayer.CurrentGenerator.id == generator.id);
|
|
}
|
|
}
|
|
|
|
private static void OnRaceActivate(PacketRaceActivate packet)
|
|
{
|
|
var generator = QuicksilverEnergyGenerator.allGenerators.FirstOrDefault(g => g.id == packet.ID);
|
|
if (generator)
|
|
{
|
|
if (Globals.LocalPlayer.CurrentGenerator != null && Globals.LocalPlayer.CurrentGenerator.id == generator.id)
|
|
{
|
|
generator.Activate();
|
|
}
|
|
else
|
|
{
|
|
generator.model.state = QuicksilverEnergyGenerator.State.COUNTDOWN;
|
|
generator.model.timer = new double?(generator.timeDirector.HoursFromNow(generator.countdownMinutes * 0.0166666675f));
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Others
|
|
private static void OnKookadobaAction(PacketKookadobaAction packet)
|
|
{
|
|
if (Globals.Kookadobas.TryGetValue(packet.ID, out NetworkKookadobaPatchNode node))
|
|
{
|
|
if (packet.Grow)
|
|
{
|
|
node.Node.bed.SetActive(true);
|
|
node.Node.spawnJoint.gameObject.SetActive(true);
|
|
SRMP.Log($"Kookadoba Grow {packet.ID}", "CLIENT");
|
|
}
|
|
else if (packet.Harvest)
|
|
{
|
|
node.Node.Harvested();
|
|
SRMP.Log($"Kokadoba Harvested {packet.ID}", "CLIENT");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGingerAction(PacketGingerAction packet)
|
|
{
|
|
var node = GingerPatchNode.allGingerPatches.FirstOrDefault(g => g.id == packet.ID);
|
|
if (node != null)
|
|
{
|
|
if (packet.Grow)
|
|
{
|
|
node.bed.SetActive(true);
|
|
node.spawnJoint.gameObject.SetActive(true);
|
|
SRMP.Log($"Ginger Grow {packet.ID}", "CLIENT");
|
|
}
|
|
else if (packet.Harvest)
|
|
{
|
|
node.Harvested();
|
|
SRMP.Log($"Ginger Harvested {packet.ID}", "CLIENT");
|
|
}
|
|
else
|
|
{
|
|
node.HidePatchAndReset();
|
|
SRMP.Log($"Ginger HidePatchAndReset {packet.ID}", "CLIENT");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGingerAttach(PacketGingerAttach packet)
|
|
{
|
|
var node = GingerPatchNode.allGingerPatches.FirstOrDefault(g => g.id == packet.ID);
|
|
if (node != null && Globals.Actors.TryGetValue(packet.ActorID, out NetworkActor actor))
|
|
{
|
|
actor.GetComponent<ResourceCycle>().Attach(node.spawnJoint, null, new ResourceCycle.DetachmentEvent(node.Harvested));
|
|
SRMP.Log($"Ginger {packet.ActorID} attached to {packet.ID}", "CLIENT");
|
|
}
|
|
}
|
|
|
|
private static void OnKookadobaAttach(PacketKookadobaAttach packet)
|
|
{
|
|
if (Globals.Kookadobas.TryGetValue(packet.ID, out NetworkKookadobaPatchNode node) && Globals.Actors.TryGetValue(packet.ActorID, out NetworkActor actor))
|
|
{
|
|
actor.GetComponent<ResourceCycle>().Attach(node.Node.spawnJoint, null, new ResourceCycle.DetachmentEvent(node.Node.Harvested));
|
|
SRMP.Log($"Kookadoba {packet.ActorID} attached to {packet.ID}", "CLIENT");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region FireColumns
|
|
private static void OnFireStormMode(PacketFireStormMode packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.world.currFirestormMode = (FirestormActivator.Mode)packet.Mode;
|
|
}
|
|
|
|
private static void OnFireColumnActivate(PacketFireColumnActivate packet)
|
|
{
|
|
if (Globals.FireColumns.TryGetValue(packet.ID, out NetworkFireColumn netColumn))
|
|
{
|
|
netColumn.Column.ActivateFire();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Oasis
|
|
private static void OnOasisLive(PacketOasisLive packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllOases().TryGetValue(packet.ID, out OasisModel model))
|
|
{
|
|
if (model.gameObj != null)
|
|
{
|
|
var oasis = model.gameObj.GetComponent<Oasis>();
|
|
oasis.SetLive(!model.gameObj.activeInHierarchy);
|
|
|
|
var oasisTriggers = GameObject.FindObjectsOfType<OasisWaterTrigger>();
|
|
foreach (var trigger in oasisTriggers)
|
|
{
|
|
if (trigger.oasisToScale == oasis && !trigger.hasAlreadyActivated)
|
|
{
|
|
if (trigger.scaleCue != null)
|
|
{
|
|
SECTR_AudioSystem.Play(trigger.scaleCue, trigger.transform.position, false);
|
|
}
|
|
if (trigger.scaleFX != null)
|
|
{
|
|
SRBehaviour.InstantiateDynamic(trigger.scaleFX, trigger.transform.position, trigger.transform.rotation, false);
|
|
}
|
|
if (trigger.indicatorObj != null)
|
|
{
|
|
trigger.indicatorObj.SetActive(true);
|
|
}
|
|
if (trigger.indicatorReplacesObj != null)
|
|
{
|
|
trigger.indicatorReplacesObj.SetActive(false);
|
|
}
|
|
trigger.hasAlreadyActivated = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnOasis(PacketOasis packet)
|
|
{
|
|
foreach (var oasisData in packet.Oasis)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllOases().TryGetValue(oasisData.ID, out OasisModel model))
|
|
{
|
|
model.isLive = oasisData.Model.isLive;
|
|
|
|
model.Init();
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Exchanges
|
|
private static void OnExchangeTryAccept(PacketExchangeTryAccept packet)
|
|
{
|
|
//get the exchange type
|
|
var type = (ExchangeDirector.OfferType)packet.Type;
|
|
//check if current scene (view) contains the item in question
|
|
if (SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.currOffers.ContainsKey(type))
|
|
{
|
|
//handle the scene changes for the given offer
|
|
var offer = SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.currOffers[type];
|
|
//cycle through requested items
|
|
foreach (ExchangeDirector.RequestedItemEntry requestedItemEntry in offer.requests)
|
|
{
|
|
//check if the item can be accespted
|
|
//is on the board and not already completed
|
|
if (requestedItemEntry.id == (Identifiable.Id)packet.ID && !requestedItemEntry.IsComplete())
|
|
{
|
|
//mark submit to log
|
|
SRMP.Log($"Exchange TryAccept for {(Identifiable.Id)packet.ID} ({(ExchangeDirector.OfferType)packet.Type}", "SERVER");
|
|
//mark progress
|
|
requestedItemEntry.progress++;
|
|
|
|
//if the given item completes the necesary quantity
|
|
if (offer.IsComplete())
|
|
{
|
|
foreach (var rewarder in Resources.FindObjectsOfTypeAll<RancherProgressAwarder>())
|
|
{
|
|
rewarder.AwardIfType(type);
|
|
}
|
|
|
|
//trigger fireworks
|
|
//get ExchangeEjector
|
|
foreach (var eject in Resources.FindObjectsOfTypeAll<ExchangeEjector>())
|
|
{
|
|
//send off fireworks
|
|
SRBehaviour.InstantiateDynamic(eject.awardFX, eject.awardAt.position, eject.awardAt.rotation);
|
|
}
|
|
|
|
//dont clear out the offer yet, we arent done with it
|
|
//SRSingleton<SceneContext>.Instance.ExchangeDirector.ClearOffer(type);
|
|
}
|
|
|
|
//trigger offer status changed
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private static void OnExchangePrepareDaily(PacketExchangePrepareDaily packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.pendingOfferRancherIds = packet.pendingOfferRancherIds;
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
|
|
SRMP.Log($"ExchangePrepareDaily", "CLIENT");
|
|
}
|
|
|
|
private static void OnExchangeClear(PacketExchangeClear packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.currOffers.Remove((ExchangeDirector.OfferType)packet.Type);
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
|
|
SRMP.Log($"ExchangeClear", "CLIENT");
|
|
}
|
|
|
|
private static void OnExchangeOffer(PacketExchangeOffer packet)
|
|
{
|
|
if ((ExchangeDirector.OfferType)packet.Type == ExchangeDirector.OfferType.GENERAL)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.pendingOfferRancherIds.Clear();
|
|
}
|
|
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.currOffers[(ExchangeDirector.OfferType)packet.Type] = packet.Offer;
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
|
|
SRMP.Log($"ExchangeOffer for {(ExchangeDirector.OfferType)packet.Type}", "CLIENT");
|
|
}
|
|
|
|
private static void OnExchangeOffers(PacketExchangeOffers packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.pendingOfferRancherIds = packet.pendingOfferRancherIds;
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
foreach (var offerData in packet.Offers)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.worldModel.currOffers[(ExchangeDirector.OfferType)offerData.Type] = offerData.Offer;
|
|
SRSingleton<SceneContext>.Instance.ExchangeDirector.OfferDidChange();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region TreasurePods
|
|
private static void OnTreasurePodOpen(PacketTreasurePodOpen packet)
|
|
{
|
|
if (Globals.TreasurePods.TryGetValue(packet.ID, out NetworkTreasurePod netTreasurePod))
|
|
{
|
|
netTreasurePod.Activate();
|
|
SRMP.Log($"TreasurePot {packet.ID} activated", "CLIENT");
|
|
}
|
|
}
|
|
|
|
private static void OnTreasurePods(PacketTreasurePods packet)
|
|
{
|
|
foreach (var pod in packet.TreasurePods)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllPods().TryGetValue(pod.ID, out TreasurePodModel model))
|
|
{
|
|
model.state = pod.Model.state;
|
|
|
|
model.Init();
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Drones
|
|
private static void OnDroneActive(PacketDroneActive packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().drone.onActiveCue.enabled = packet.Enabled;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDronePosition(PacketDronePosition packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
var netDrone = model.attached.transform.GetComponentInChildren<NetworkDrone>(true);
|
|
if (netDrone != null)
|
|
{
|
|
netDrone.PositionRotationUpdate(packet.Position, packet.Rotation, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneStationEnabled(PacketDroneStationEnabled packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().station.animator.SetEnabled(packet.Enabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneLiquid(PacketDroneLiquid packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
if (model.attached.transform.gameObject.activeInHierarchy)
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().station.battery.AddLiquid(Identifiable.Id.NONE, 0);
|
|
}
|
|
else
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().station.battery.Reset(model.attached.transform.GetComponent<DroneGadget>().droneModel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDronePrograms(PacketDronePrograms packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
var drone = model.attached.transform.GetComponent<DroneGadget>();
|
|
drone.SetPrograms(drone.ProgramsFromData(packet.Programs));
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneAnimation(PacketDroneAnimation packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().drone.animator.SetAnimation((DroneAnimator.Id)packet.Anim);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneAmmoRemove(PacketDroneAmmoRemove packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().drone.ammo.Decrement(0, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneAmmoClear(PacketDroneAmmoClear packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().drone.ammo.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnDroneAmmoAdd(PacketDroneAmmoAdd packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<DroneGadget>().drone.ammo.MaybeAddToSpecificSlot((Identifiable.Id)packet.Ident, null, 0, 1);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Fashions
|
|
private static void OnFashionDetachAll(PacketFashionDetachAll packet)
|
|
{
|
|
AttachFashions attachFashions = null;
|
|
if (packet.Type == 1)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.IDInt, out NetworkActor netActor))
|
|
{
|
|
attachFashions = netActor.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
else if (packet.Type == 3)
|
|
{
|
|
if (Globals.Gordos.TryGetValue(packet.IDString, out NetworkGordo netGordo))
|
|
{
|
|
attachFashions = netGordo.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
else if (packet.Type == 4)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.IDString, out NetworkGadgetSite netGadgetSite))
|
|
{
|
|
attachFashions = netGadgetSite.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
|
|
if (attachFashions != null)
|
|
{
|
|
var fashionRemover = Resources.FindObjectsOfTypeAll<FashionRemover>()[0];
|
|
fashionRemover.transform.position = packet.Position;
|
|
fashionRemover.transform.rotation = packet.Rotation;
|
|
attachFashions.DetachAll(fashionRemover);
|
|
}
|
|
}
|
|
|
|
private static void OnFashionAttach(PacketFashionAttach packet)
|
|
{
|
|
AttachFashions attachFashions = null;
|
|
if (packet.Type == 1)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.IDInt, out NetworkActor netActor))
|
|
{
|
|
attachFashions = netActor.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
else if (packet.Type == 3)
|
|
{
|
|
if (Globals.Gordos.TryGetValue(packet.IDString, out NetworkGordo netGordo))
|
|
{
|
|
attachFashions = netGordo.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
else if (packet.Type == 4)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.IDString, out NetworkGadgetSite netGadgetSite))
|
|
{
|
|
attachFashions = netGadgetSite.GetComponentInChildren<AttachFashions>(true);
|
|
}
|
|
}
|
|
|
|
if (attachFashions != null)
|
|
{
|
|
var component = SRSingleton<GameContext>.Instance.LookupDirector.GetPrefab((Identifiable.Id)packet.Fashion)?.GetComponent<Fashion>();
|
|
if (component != null)
|
|
{
|
|
attachFashions.Attach(component, !attachFashions.gameObject.activeInHierarchy);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Gadgets
|
|
private static void OnGadgetEchoNetTime(PacketGadgetEchoNetTime packet)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
var echoNet = netSite.Site.GetComponentInChildren<EchoNet>(true);
|
|
if (echoNet != null)
|
|
{
|
|
echoNet.ResetSpawnTime(echoNet.model);
|
|
}
|
|
}
|
|
}
|
|
private static void OnGadgetSnareGordo(PacketGadgetSnareGordo packet)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
var snare = netSite.Site.GetComponentInChildren<GordoSnare>(true);
|
|
if (snare != null)
|
|
{
|
|
if (!snare.IsBaited() || snare.HasSnaredGordo())
|
|
{
|
|
return;
|
|
}
|
|
snare.SnareGordo((Identifiable.Id)packet.Ident);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetSnareAttach(PacketGadgetSnareAttach packet)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
var snare = netSite.Site.GetComponentInChildren<GordoSnare>(true);
|
|
if (snare != null)
|
|
{
|
|
snare.AttachBait((Identifiable.Id)packet.Ident);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetTurrets(PacketGadgetTurrets packet)
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
foreach (var data in packet.Turrets)
|
|
{
|
|
netSite.UpdateTurretRotation(data.Index, data.Rotation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetExtractorUpdate(PacketGadgetExtractorUpdate packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model != null && model.attached != null && model.attached is ExtractorModel)
|
|
{
|
|
var extractor = (ExtractorModel)model.attached;
|
|
|
|
extractor.cycleEndTime = packet.cycleEndTime;
|
|
extractor.cyclesRemaining = packet.cyclesRemaining;
|
|
extractor.nextProduceTime = packet.nextProduceTime;
|
|
extractor.queuedToProduce = packet.queuedToProduce;
|
|
|
|
if (extractor.cyclesRemaining <= 0)
|
|
{
|
|
var extractorScript = extractor.transform.GetComponent<Extractor>();
|
|
if (extractorScript != null && extractorScript.gameObject.activeInHierarchy)
|
|
{
|
|
extractorScript.StartCoroutine(extractorScript.AnimAndDestroy());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetSpawn(PacketGadgetSpawn packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite);
|
|
bool didUnproxy = false;
|
|
if (netSite != null)
|
|
{
|
|
if (!netSite.Region.Region.root.activeSelf)
|
|
{
|
|
netSite.Region.Region.Unproxy();
|
|
didUnproxy = true;
|
|
}
|
|
}
|
|
GameObject prefab = SRSingleton<GameContext>.Instance.LookupDirector.GetGadgetDefinition((Gadget.Id)packet.Ident).prefab;
|
|
var gadgetObj = SRSingleton<SceneContext>.Instance.GameModel.InstantiateGadget(prefab, model);
|
|
gadgetObj.transform.eulerAngles = new Vector3(0, packet.Rotation, 0);
|
|
|
|
GameObject.FindObjectOfType<PlaceGadgetUI>()?.RebuildUI();
|
|
|
|
if (didUnproxy)
|
|
{
|
|
netSite.Region.Region.Proxy();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetSpend(PacketGadgetSpend packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.SpendGadget((Gadget.Id)packet.ID);
|
|
GameObject.FindObjectOfType<PlaceGadgetUI>()?.RebuildUI();
|
|
}
|
|
|
|
private static void OnGadgetAddBlueprint(PacketGadgetAddBlueprint packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.AddBlueprint((Gadget.Id)packet.ID);
|
|
}
|
|
|
|
private static void OnGadgetAdd(PacketGadgetAdd packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.AddGadget((Gadget.Id)packet.ID);
|
|
GameObject.FindObjectOfType<PlaceGadgetUI>()?.RebuildUI();
|
|
}
|
|
|
|
private static void OnGadgetRefinerySpend(PacketGadgetRefinerySpend packet)
|
|
{
|
|
foreach (var data in packet.Amounts)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.GetGadgetsModel().craftMatCounts[(Identifiable.Id)data.Key] -= data.Value;
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.GetGadgetsModel().craftMatCounts[(Identifiable.Id)data.Key] < 0)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.GetGadgetsModel().craftMatCounts[(Identifiable.Id)data.Key] = 0;
|
|
}
|
|
}
|
|
GameObject.FindObjectOfType<RefineryUI>()?.Rebuild();
|
|
}
|
|
|
|
private static void OnGadgetRotation(PacketGadgetRotation packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.attached.transform.GetComponent<Gadget>().SetRotation(packet.Rotation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgetRemove(PacketGadgetRemove packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel model))
|
|
{
|
|
if (model.HasAttached())
|
|
{
|
|
model.transform.GetComponent<GadgetSite>().DestroyAttached();
|
|
GameObject.FindObjectOfType<PlaceGadgetUI>()?.RebuildUI();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGadgets(PacketGadgets packet)
|
|
{
|
|
List<int> regions = new List<int>();
|
|
foreach (var gadgetData in packet.Gadgets)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(gadgetData.ID, out GadgetSiteModel model))
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(gadgetData.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
if (!netSite.Region.Region.root.activeSelf && !regions.Contains(netSite.Region.ID))
|
|
{
|
|
netSite.Region.Region.Unproxy();
|
|
regions.Add(netSite.Region.ID);
|
|
}
|
|
}
|
|
|
|
GameObject gameObj = SRSingleton<GameContext>.Instance.AutoSaveDirector.SavedGame.prefabInstantiator.InstantiateGadget(gadgetData.gadgetId, model, SRSingleton<SceneContext>.Instance.GameModel);
|
|
GadgetModel attached = model.attached;
|
|
attached.PushBase(gadgetData.waitForChargeupTime, gadgetData.yRotation);
|
|
if (attached is ExtractorModel)
|
|
{
|
|
((ExtractorModel)attached).cyclesRemaining = ((ExtractorModel)gadgetData.Model).cyclesRemaining;
|
|
((ExtractorModel)attached).queuedToProduce = ((ExtractorModel)gadgetData.Model).queuedToProduce;
|
|
((ExtractorModel)attached).cycleEndTime = ((ExtractorModel)gadgetData.Model).cycleEndTime;
|
|
((ExtractorModel)attached).cyclesRemaining = ((ExtractorModel)gadgetData.Model).cyclesRemaining;
|
|
}
|
|
else if (attached is WarpDepotModel)
|
|
{
|
|
((WarpDepotModel)attached).Push(((WarpDepotModel)gadgetData.Model).isPrimary, ((WarpDepotModel)gadgetData.Model).ammo.slots);
|
|
}
|
|
else if (attached is SnareModel)
|
|
{
|
|
((SnareModel)attached).Push(((SnareModel)gadgetData.Model).baitTypeId, ((SnareModel)gadgetData.Model).gordoTypeId, ((SnareModel)gadgetData.Model).gordoEatenCount, ((SnareModel)gadgetData.Model).fashions);
|
|
}
|
|
else if (attached is EchoNetModel)
|
|
{
|
|
((EchoNetModel)attached).Push(((EchoNetModel)gadgetData.Model).lastSpawnTime);
|
|
}
|
|
else if (attached is DroneModel)
|
|
{
|
|
((DroneModel)attached).position = ((DroneModel)gadgetData.Model).position;
|
|
((DroneModel)attached).rotation = ((DroneModel)gadgetData.Model).rotation;
|
|
((DroneModel)attached).ammo.Push(((DroneModel)gadgetData.Model).ammo.slots);
|
|
((DroneModel)attached).fashions = ((DroneModel)gadgetData.Model).fashions;
|
|
((DroneModel)attached).noClip = ((DroneModel)gadgetData.Model).noClip;
|
|
((DroneModel)attached).batteryDepleteTime = ((DroneModel)gadgetData.Model).batteryDepleteTime;
|
|
((DroneModel)attached).programs = ((DroneModel)gadgetData.Model).programs;
|
|
}
|
|
else
|
|
{
|
|
BasicGadgetModel basicGadgetModel = attached as BasicGadgetModel;
|
|
}
|
|
attached.NotifyParticipants(gameObj);
|
|
}
|
|
}
|
|
|
|
foreach (var region in regions)
|
|
{
|
|
if (Globals.Regions.TryGetValue(region, out NetworkRegion netRegion))
|
|
{
|
|
netRegion.Region.Proxy();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Pedia
|
|
private static void OnPediaUnlock(PacketPediaUnlock packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PediaDirector.Unlock(packet.IDs.Select(i => (PediaDirector.Id)i).ToArray());
|
|
}
|
|
|
|
private static void OnPediaShowPopup(PacketPediaShowPopup packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PediaDirector.MaybeShowPopup((PediaDirector.Id)packet.ID);
|
|
}
|
|
#endregion
|
|
|
|
#region PuzzleSlots
|
|
private static void OnPuzzleGateActivate(PacketPuzzleGateActivate packet)
|
|
{
|
|
var puzzleGateActivator = GameObject.FindObjectOfType<PuzzleGateActivator>();
|
|
if (puzzleGateActivator != null && puzzleGateActivator.gameObject.activeInHierarchy)
|
|
{
|
|
puzzleGateActivator.StartCoroutine(puzzleGateActivator.DoDeactivateSequence());
|
|
}
|
|
}
|
|
|
|
private static void OnPuzzleSlotFilled(PacketPuzzleSlotFilled packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllSlots().TryGetValue(packet.ID, out PuzzleSlotModel model))
|
|
{
|
|
if (!model.filled)
|
|
{
|
|
model.filled = true;
|
|
var slot = model.gameObj.GetComponent<PuzzleSlot>();
|
|
SRBehaviour.SpawnAndPlayFX(slot.changeFX, slot.transform.position, slot.transform.rotation);
|
|
slot.ActivateOnFill();
|
|
if (slot.puzLockable != null)
|
|
{
|
|
slot.puzLockable.NotifySlotChanged(!slot.puzLockable.gameObject.activeInHierarchy);
|
|
SECTR_AudioCue cueForLastSlot = slot.puzLockable.GetCueForLastSlot();
|
|
SECTR_AudioSystem.Play(slot.localFillCue, slot.transform.position, false);
|
|
if (slot.gameObject.activeInHierarchy)
|
|
{
|
|
slot.StartCoroutine(slot.DelayedPlayLockCue(cueForLastSlot));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnPuzzleSlots(PacketPuzzleSlots packet)
|
|
{
|
|
foreach (var puzzleSlotData in packet.PuzzleSlots)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllSlots().TryGetValue(puzzleSlotData.ID, out PuzzleSlotModel model))
|
|
{
|
|
model.filled = puzzleSlotData.Model.filled;
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Gordos
|
|
private static void OnGordoEat(PacketGordoEat packet)
|
|
{
|
|
if (!Globals.Gordos.TryGetValue(packet.ID, out NetworkGordo netGordo))
|
|
{
|
|
if (Globals.GadgetSites.TryGetValue(packet.ID, out NetworkGadgetSite netSite))
|
|
{
|
|
netGordo = netSite.GetComponentInChildren<NetworkGordo>(true);
|
|
}
|
|
}
|
|
if (netGordo != null)
|
|
{
|
|
netGordo.Eat(packet.Position, packet.Rotation);
|
|
netGordo.Gordo.SetEatenCount(netGordo.Gordo.GetEatenCount() + packet.Count);
|
|
if (packet.Favorite)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(netGordo.Gordo.EatFavoriteFX, packet.Position, packet.Rotation);
|
|
}
|
|
if (netGordo.Gordo.GetEatenCount() >= netGordo.Gordo.GetTargetCount())
|
|
{
|
|
netGordo.Burst();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGordos(PacketGordos packet)
|
|
{
|
|
foreach (var gordoData in packet.Gordos)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllGordos().TryGetValue(gordoData.ID, out GordoModel model))
|
|
{
|
|
model.fashions = gordoData.Model.fashions;
|
|
model.gordoEatenCount = gordoData.Model.gordoEatenCount;
|
|
|
|
model.Init();
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region AccessDoors
|
|
private static void OnAccessDoorOpen(PacketAccessDoorOpen packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllDoors().TryGetValue(packet.ID, out AccessDoorModel model))
|
|
{
|
|
GameObject doorObj = model.gameObj;
|
|
if (doorObj != null && doorObj.GetComponent<AccessDoor>() != null)
|
|
{
|
|
AccessDoor door = doorObj.GetComponent<AccessDoor>();
|
|
door.CurrState = (AccessDoor.State)packet.State;
|
|
if (door.linkedDoors != null)
|
|
{
|
|
foreach (AccessDoor accessDoor in door.linkedDoors)
|
|
{
|
|
if (accessDoor.CurrState == AccessDoor.State.LOCKED)
|
|
{
|
|
accessDoor.CurrState = AccessDoor.State.CLOSED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnAccessDoors(PacketAccessDoors packet)
|
|
{
|
|
foreach (var doorData in packet.Doors)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllDoors().TryGetValue(doorData.ID, out AccessDoorModel model))
|
|
{
|
|
if (model.gameObj != null)
|
|
{
|
|
model.state = doorData.Model.state;
|
|
model.Init();
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region FX
|
|
private static void OnPlayAudio(PacketPlayAudio packet)
|
|
{
|
|
if (Globals.Audios.TryGetValue(packet.CueName, out SECTR_AudioCue cue))
|
|
{
|
|
var before = cue.Spatialization;
|
|
cue.Spatialization = SECTR_AudioCue.Spatializations.Local3D;
|
|
SECTR_AudioSystem.Play(cue, packet.Position, packet.Loop);
|
|
cue.Spatialization = before;
|
|
}
|
|
}
|
|
|
|
private static void OnIncinerateFX(PacketIncinerateFX packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
var incinerate = model.gameObj.GetComponentInChildren<Incinerate>();
|
|
if (incinerate != null)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(incinerate.ExplosionFX, packet.Position, packet.Rotation);
|
|
if (packet.Small)
|
|
{
|
|
incinerate.incinerateAudio.Cue = incinerate.smallCue;
|
|
incinerate.incinerateAudio.Play();
|
|
}
|
|
else
|
|
{
|
|
incinerate.incinerateAudio.Cue = incinerate.largeCue;
|
|
incinerate.incinerateAudio.Play();
|
|
}
|
|
if (packet.Ash)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(incinerate.ashFX, packet.Position, packet.Rotation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnGlobalFX(PacketGlobalFX packet)
|
|
{
|
|
if (Globals.FXPrefabs.TryGetValue(packet.Name, out GameObject prefabFX))
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(prefabFX, packet.Position, Quaternion.identity);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region World
|
|
private static void OnWorldMailRead(PacketWorldMailRead packet)
|
|
{
|
|
var mail = SRSingleton<SceneContext>.Instance.MailDirector.model.allMail.FirstOrDefault(m => m.Equals(new MailDirector.Mail((MailDirector.Type)packet.Type, packet.Key)));
|
|
|
|
if (mail != null)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.MailDirector.MarkRead(mail);
|
|
}
|
|
}
|
|
|
|
private static void OnWorldMailSend(PacketWorldMailSend packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.MailDirector.SendMail((MailDirector.Type)packet.Type, packet.Key);
|
|
}
|
|
|
|
private static void OnWorldCredits(PacketWorldCredits packet)
|
|
{
|
|
SRSingleton<GameContext>.Instance.UITemplates.CreateCreditsPrefab(false);
|
|
}
|
|
|
|
private static void OnWorldMarketPrices(PacketWorldMarketPrices packet)
|
|
{
|
|
foreach (var data in packet.Prices)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.currValueMap[(Identifiable.Id)data.Key].currValue = data.Value.currValue;
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.currValueMap[(Identifiable.Id)data.Key].prevValue = data.Value.prevValue;
|
|
}
|
|
foreach (var data in packet.Saturation)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.worldModel.marketSaturation[(Identifiable.Id)data.Key] = data.Value;
|
|
}
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.didUpdateDelegate?.Invoke();
|
|
}
|
|
|
|
private static void OnWorldDecorizerSetting(PacketWorldDecorizerSetting packet)
|
|
{
|
|
var storage = SRSingleton<SceneContext>.Instance.GameModel.decorizer.participants.FirstOrDefault(c => ((DecorizerStorage)c).id == packet.ID);
|
|
if (storage != null)
|
|
{
|
|
((DecorizerStorage)storage).selected = (Identifiable.Id)packet.Selected;
|
|
}
|
|
}
|
|
|
|
private static void OnWorldDecorizer(PacketWorldDecorizer packet)
|
|
{
|
|
foreach (var c in packet.Contents)
|
|
{
|
|
for (int i = 0; i < c.Value; i++)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.decorizer.contents.Increment(c.Key);
|
|
}
|
|
}
|
|
foreach (var setting in packet.Settings)
|
|
{
|
|
var storage = SRSingleton<SceneContext>.Instance.GameModel.decorizer.participants.FirstOrDefault(c => ((DecorizerStorage)c).id == setting.Key);
|
|
if (storage != null)
|
|
{
|
|
((DecorizerStorage)storage).selected = (Identifiable.Id)setting.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnWorldSwitches(PacketWorldSwitches packet)
|
|
{
|
|
foreach (var switchData in packet.Switches)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllSwitches().TryGetValue(switchData.ID, out MasterSwitchModel model))
|
|
{
|
|
model.state = switchData.Model.state;
|
|
model.NotifyParticipants();
|
|
model.gameObj.GetComponent<WorldStateMasterSwitch>().firstUpdate = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnWorldSelectPalette(PacketWorldSelectPalette packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.GetRanchModel().SelectPalette((RanchDirector.PaletteType)packet.Type, (RanchDirector.Palette)packet.Pal);
|
|
}
|
|
|
|
private static void OnWorldSwitchActivate(PacketWorldSwitchActivate packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllSwitches().TryGetValue(packet.ID, out MasterSwitchModel model))
|
|
{
|
|
var master = model.gameObj.GetComponent<WorldStateMasterSwitch>();
|
|
master.SetStateForAll((SwitchHandler.State)packet.State, !model.gameObj.activeInHierarchy);
|
|
master.blockSwitchActivationUntil = Time.time + 2f;
|
|
}
|
|
}
|
|
|
|
private static void OnWorldMapUnlock(PacketWorldMapUnlock packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.UnlockMap((ZoneDirector.Zone)packet.Zone);
|
|
if (SRSingleton<Map>.Instance.mapUI.gameObject.activeInHierarchy)
|
|
{
|
|
SRSingleton<Map>.Instance.mapUI.AddZoneToReveal((ZoneDirector.Zone)packet.Zone);
|
|
SRSingleton<Map>.Instance.mapUI.UpdateZoneFog();
|
|
}
|
|
foreach (var map in Resources.FindObjectsOfTypeAll<MapDataEntry>())
|
|
{
|
|
if (map.zone == (ZoneDirector.Zone)packet.Zone)
|
|
{
|
|
map.UpdateHologramState();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnWorldKey(PacketWorldKey packet)
|
|
{
|
|
if (packet.Added)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.AddKey();
|
|
}
|
|
else
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.SpendKey();
|
|
}
|
|
}
|
|
|
|
private static void OnWorldProgress(PacketWorldProgress packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ProgressDirector.SetProgress((ProgressDirector.ProgressType)packet.Type, packet.Amount);
|
|
}
|
|
|
|
private static void OnWorldFastForward(PacketWorldFastForward packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.TimeDirector.FastForwardTo(packet.FastForwardTill);
|
|
}
|
|
|
|
private static void OnWorldTime(PacketWorldTime packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.TimeDirector.worldModel.worldTime = packet.Time;
|
|
}
|
|
|
|
private static void OnWorldData(PacketWorldData packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.player.SetKeys(packet.Keys);
|
|
SRSingleton<SceneContext>.Instance.GameModel.player.SetCurrency(packet.Currency);
|
|
SRSingleton<SceneContext>.Instance.TimeDirector.worldModel.worldTime = packet.WorldTime;
|
|
SRSingleton<SceneContext>.Instance.GameModel.player.SetUnlockedZoneMaps(packet.MapUnlocks.Select(m => (ZoneDirector.Zone)m).ToList());
|
|
foreach (var progress in packet.Progress)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.ProgressDirector.SetProgress((ProgressDirector.ProgressType)progress.Key, progress.Value);
|
|
}
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.blueprints = packet.GadgetsModel.blueprints;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.blueprintLockData = packet.GadgetsModel.blueprintLockData;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.availBlueprints = packet.GadgetsModel.availBlueprints;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.registeredBlueprints = packet.GadgetsModel.registeredBlueprints;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.gadgets = packet.GadgetsModel.gadgets;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.craftMatCounts = packet.GadgetsModel.craftMatCounts;
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.model.placedGadgetCounts = packet.GadgetsModel.placedGadgetCounts;
|
|
foreach (var pal in packet.Palette)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.GameModel.GetRanchModel().SelectPalette((RanchDirector.PaletteType)pal.Key, (RanchDirector.Palette)pal.Value);
|
|
}
|
|
foreach (var upgrade in packet.AvailUpgrades.Select(u => (PlayerState.Upgrade)u))
|
|
{
|
|
if (!SRSingleton<SceneContext>.Instance.PlayerState.model.availUpgrades.Contains(upgrade))
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.availUpgrades.Add(upgrade);
|
|
}
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.upgradeLocks.Remove(upgrade);
|
|
}
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.SetUpgrades(packet.Upgrades.Select(u => (PlayerState.Upgrade)u).ToList());
|
|
SRSingleton<SceneContext>.Instance.PediaDirector.Unlock(packet.PediaUnlocks.Select(u => (PediaDirector.Id)u).ToArray());
|
|
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.worldModel.econSeed = packet.Seed;
|
|
foreach (var data in packet.Prices)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.currValueMap[(Identifiable.Id)data.Key].currValue = data.Value.currValue;
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.currValueMap[(Identifiable.Id)data.Key].prevValue = data.Value.prevValue;
|
|
}
|
|
foreach (var data in packet.Saturation)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.worldModel.marketSaturation[(Identifiable.Id)data.Key] = data.Value;
|
|
}
|
|
SRSingleton<SceneContext>.Instance.EconomyDirector.didUpdateDelegate?.Invoke();
|
|
|
|
SRSingleton<SceneContext>.Instance.MailDirector.model.Reset();
|
|
foreach (var mail in packet.Mails)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.MailDirector.model.AddMail(mail);
|
|
}
|
|
SRSingleton<SceneContext>.Instance.MailDirector.model.MailListChanged();
|
|
|
|
foreach (var mapDataEntry in Resources.FindObjectsOfTypeAll<MapDataEntry>())
|
|
{
|
|
if (mapDataEntry != null && mapDataEntry.hologram != null && mapDataEntry.collider != null && mapDataEntry.activeFx != null)
|
|
{
|
|
mapDataEntry.UpdateHologramState();
|
|
}
|
|
}
|
|
|
|
var phaseSiteDirector = GameObject.FindObjectOfType<PhaseSiteDirector>();
|
|
if (phaseSiteDirector != null)
|
|
{
|
|
phaseSiteDirector.ResetAllSites();
|
|
foreach (PhaseSite phaseSite in new List<PhaseSite>(phaseSiteDirector.availablePhaseSites))
|
|
{
|
|
if (packet.LemonTrees.Contains(phaseSite.id))
|
|
{
|
|
phaseSiteDirector.PlacePhaseObject(phaseSite);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log("Could not find PhaseSiteDirector", "CLIENT");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region LandPlots
|
|
private static void OnLandPlotSiloAmmoClear(PacketLandPlotSiloAmmoClear packet)
|
|
{
|
|
//if (packet.ID.Contains("site"))
|
|
//{
|
|
// if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel site) && site.HasAttached())
|
|
// {
|
|
// var silocatcher = site.transform.GetComponentInChildren<SiloCatcher>();
|
|
// if (silocatcher != null)
|
|
// {
|
|
// silocatcher.storageSilo.ammo.Clear(packet.Slot);
|
|
// }
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// var storage = SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots()[packet.ID].gameObj.GetComponentsInChildren<SiloCatcher>().First(c => c.type == (SiloCatcher.Type)packet.Type).storageSilo;
|
|
// storage.ammo.Clear(packet.Slot);
|
|
//}
|
|
if (NetworkAmmo.All.TryGetValue(packet.ID, out NetworkAmmo ammo))
|
|
{
|
|
ammo.Clear(packet.Slot);
|
|
SRMP.Log($"NetworkAmmo clear slot {packet.Slot} for {packet.ID}", "CLIENT");
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log("NetworkAmmo not found for clear: " + packet.ID);
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotSiloAmmoRemove(PacketLandPlotSiloAmmoRemove packet)
|
|
{
|
|
if (NetworkAmmo.All.TryGetValue(packet.ID, out NetworkAmmo ammo))
|
|
{
|
|
ammo.Decrement(packet.Slot, packet.Count);
|
|
SRMP.Log($"NetworkAmmo remove slot {packet.Slot} (Amount: {packet.Count}) for {packet.ID}", "CLIENT");
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log("NetworkAmmo not found for remove: " + packet.ID);
|
|
}
|
|
//if (packet.ID.Contains("site"))
|
|
//{
|
|
// if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel site) && site.HasAttached())
|
|
// {
|
|
// var silocatcher = site.transform.GetComponentInChildren<SiloCatcher>();
|
|
// if (silocatcher != null)
|
|
// {
|
|
// silocatcher.storageSilo.ammo.Decrement(packet.Slot, packet.Count);
|
|
// }
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// var storage = SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots()[packet.ID].gameObj.GetComponentsInChildren<SiloCatcher>().First(c => c.type == (SiloCatcher.Type)packet.Type).storageSilo;
|
|
// storage.ammo.Decrement(packet.Slot, packet.Count);
|
|
//}
|
|
}
|
|
|
|
private static void OnLandPlotSiloAmmoAdd(PacketLandPlotSiloAmmoAdd packet)
|
|
{
|
|
if (NetworkAmmo.All.TryGetValue(packet.ID, out NetworkAmmo ammo))
|
|
{
|
|
ammo.MaybeAddToSpecificSlot((Identifiable.Id)packet.Ident, null, packet.Slot, packet.Count, packet.Overflow);
|
|
SRMP.Log($"NetworkAmmo add slot {packet.Slot} (Type: {(Identifiable.Id)packet.Ident} - Count: {packet.Count}) for {packet.ID}", "CLIENT");
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log("NetworkAmmo not found for add: " + packet.ID);
|
|
}
|
|
//if (packet.ID.Contains("site"))
|
|
//{
|
|
// if (SRSingleton<SceneContext>.Instance.GameModel.AllGadgetSites().TryGetValue(packet.ID, out GadgetSiteModel site) && site.HasAttached())
|
|
// {
|
|
// var silocatcher = site.transform.GetComponentInChildren<SiloCatcher>();
|
|
// if (silocatcher != null)
|
|
// {
|
|
// silocatcher.storageSilo.ammo.MaybeAddToSpecificSlot((Identifiable.Id)packet.Ident, null, packet.Slot, packet.Count, packet.Overflow);
|
|
// }
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// var storage = SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots()[packet.ID].gameObj.GetComponentsInChildren<SiloCatcher>().First(c => c.type == (SiloCatcher.Type)packet.Type).storageSilo;
|
|
// storage.ammo.MaybeAddToSpecificSlot((Identifiable.Id)packet.Ident, null, packet.Slot, packet.Count, packet.Overflow);
|
|
//}
|
|
}
|
|
|
|
private static void OnLandPlotStartCollection(PacketLandPlotStartCollection packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
var collector = model.gameObj.GetComponentInChildren<PlortCollector>();
|
|
if (collector != null)
|
|
{
|
|
collector.StartCollection();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotPlantGarden(PacketLandPlotPlantGarden packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
var ident = (Identifiable.Id)packet.Type;
|
|
GardenCatcher garden = model.gameObj.GetComponentInChildren<GardenCatcher>(true);
|
|
if (garden != null)
|
|
{
|
|
if (ident != Identifiable.Id.NONE && garden.CanAccept(ident))
|
|
{
|
|
if (model.gameObj.activeInHierarchy)
|
|
{
|
|
garden.Plant(ident, false);
|
|
}
|
|
else
|
|
{
|
|
GameObject gameObject = GameObject.Instantiate<GameObject>(garden.activator.HasUpgrade(LandPlot.Upgrade.DELUXE_GARDEN) ? garden.deluxeDict[ident] : garden.plantableDict[ident], garden.activator.transform.position, garden.activator.transform.rotation);
|
|
garden.activator.Attach(gameObject, true, false, null);
|
|
}
|
|
}
|
|
else if (ident == Identifiable.Id.NONE)
|
|
{
|
|
Destroyer.Destroy(garden.activator.attached, "LandPlot.DestroyAttached");
|
|
garden.activator.attached = null;
|
|
garden.activator.model.attachedId = SpawnResource.Id.NONE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotUpgrade(PacketLandPlotUpgrade packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel landPlot))
|
|
{
|
|
var upgrade = (LandPlot.Upgrade)packet.Upgrade;
|
|
GameObject plotObj = landPlot.gameObj;
|
|
//SRMP.Log($"Upgrade {plotObj.name} with {upgrade}", "CLIENT");
|
|
if (plotObj != null && !landPlot.HasUpgrade(upgrade))
|
|
{
|
|
if (plotObj.activeInHierarchy)
|
|
{
|
|
plotObj.GetComponentInChildren<LandPlot>(true).AddUpgrade(upgrade);
|
|
GameObject.FindObjectOfType<LandPlotUI>()?.RebuildUI();
|
|
}
|
|
else
|
|
{
|
|
landPlot.upgrades.Add(upgrade);
|
|
foreach (PlotUpgrader plotUpgrader in plotObj.GetComponentsInChildren<PlotUpgrader>(true))
|
|
{
|
|
plotUpgrader.Apply(upgrade);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotReplace(PacketLandPlotReplace packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
if (model.gameObj != null)
|
|
{
|
|
model.InstantiatePlot(SRSingleton<GameContext>.Instance.LookupDirector.GetPlotPrefab((LandPlot.Id)packet.Type), false);
|
|
model.Init();
|
|
|
|
model.gameObj.GetComponentInChildren<LandPlot>(true)?.Awake();
|
|
model.gameObj.GetComponentInChildren<GardenCatcher>(true)?.Awake();
|
|
model.gameObj.GetComponentInChildren<SiloStorage>(true)?.Awake();
|
|
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotCollect(PacketLandPlotCollect packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
var collector = model.gameObj.GetComponentInChildren<PlortCollector>();
|
|
model.collectorNextTime = packet.collectorNextTime;
|
|
if (collector != null)
|
|
{
|
|
collector.endCollectAt = packet.endCollectAt;
|
|
collector.forceCollectUntil = packet.forceCollectUntil;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotFeederSpeed(PacketLandPlotFeederSpeed packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
model.gameObj.GetComponentInChildren<SlimeFeeder>().SetFeederSpeed((SlimeFeeder.FeedSpeed)packet.Speed);
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotSiloSlot(PacketLandPlotSiloSlot packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
model.siloStorageIndices[packet.ActivatorID] = packet.Slot;
|
|
var activator = model.gameObj.GetComponentsInChildren<SiloStorageActivator>().FirstOrDefault(a => a.activatorIdx == packet.ActivatorID);
|
|
if (activator != null)
|
|
{
|
|
activator.OnActiveSlotChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotAsh(PacketLandPlotAsh packet)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.ID, out LandPlotModel model))
|
|
{
|
|
model.ashUnits = packet.Amount;
|
|
model.gameObj.GetComponentInChildren<FillableAshSource>().UpdateAshPosition();
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotSiloRemove(PacketLandPlotSiloRemove packet)
|
|
{
|
|
var type = (SiloCatcher.Type)packet.CatcherType;
|
|
var id = (Identifiable.Id)packet.Ident;
|
|
switch (type)
|
|
{
|
|
case SiloCatcher.Type.DECORIZER:
|
|
SRSingleton<SceneContext>.Instance.GameModel.decorizer.Remove(id);
|
|
break;
|
|
case SiloCatcher.Type.VIKTOR_STORAGE:
|
|
((GlitchStorage)SRSingleton<SceneContext>.Instance.GameModel.Glitch.storage[packet.ID].participant).Remove(out id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlotSiloInsert(PacketLandPlotSiloInsert packet)
|
|
{
|
|
var type = (SiloCatcher.Type)packet.CatcherType;
|
|
var id = (Identifiable.Id)packet.Ident;
|
|
switch (type)
|
|
{
|
|
case SiloCatcher.Type.REFINERY:
|
|
SRSingleton<SceneContext>.Instance.GadgetDirector.AddToRefinery(id);
|
|
GameObject.FindObjectOfType<RefineryUI>()?.Rebuild();
|
|
break;
|
|
case SiloCatcher.Type.DECORIZER:
|
|
SRSingleton<SceneContext>.Instance.GameModel.decorizer.Add(id);
|
|
break;
|
|
case SiloCatcher.Type.VIKTOR_STORAGE:
|
|
((GlitchStorage)SRSingleton<SceneContext>.Instance.GameModel.Glitch.storage[packet.ID].participant).Add(id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void OnLandPlots(PacketLandplots packet)
|
|
{
|
|
foreach (var plotData in packet.LandPlots)
|
|
{
|
|
if (SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(plotData.ID, out LandPlotModel model))
|
|
{
|
|
if (model.gameObj != null)
|
|
{
|
|
model.InstantiatePlot(SRSingleton<GameContext>.Instance.LookupDirector.GetPlotPrefab(plotData.Model.typeId), false);
|
|
model.gameObj.GetComponentInChildren<LandPlot>(true)?.Awake();
|
|
model.Init();
|
|
|
|
model.ashUnits = plotData.Model.ashUnits;
|
|
model.attachedDeathTime = plotData.Model.attachedDeathTime;
|
|
model.attachedId = plotData.Model.attachedId;
|
|
model.attachedResourceId = plotData.Model.attachedResourceId;
|
|
model.collectorNextTime = plotData.Model.collectorNextTime;
|
|
model.feederCycleSpeed = plotData.Model.feederCycleSpeed;
|
|
model.nextFeedingTime = plotData.Model.nextFeedingTime;
|
|
model.remainingFeedOperations = plotData.Model.remainingFeedOperations;
|
|
model.siloStorageIndices = plotData.Model.siloStorageIndices;
|
|
model.typeId = plotData.Model.typeId;
|
|
model.upgrades = plotData.Model.upgrades.ToHashSet();
|
|
foreach (var ammo in plotData.Model.siloAmmo)
|
|
{
|
|
if (model.siloAmmo.TryGetValue(ammo.Key, out AmmoModel ammoModel))
|
|
{
|
|
ammoModel.usableSlots = ammo.Value.usableSlots;
|
|
ammoModel.slots = ammo.Value.slots;
|
|
}
|
|
else
|
|
{
|
|
ammoModel = new AmmoModel();
|
|
ammoModel.usableSlots = ammo.Value.usableSlots;
|
|
ammoModel.slots = ammo.Value.slots;
|
|
model.siloAmmo.Add(ammo.Key, ammoModel);
|
|
}
|
|
}
|
|
model.NotifyParticipants();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Actors
|
|
private static void OnActorFX(PacketActorFX packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
var type = (PacketActorFX.FXType)packet.Type;
|
|
var slimeEat = netActor.GetComponentInChildren<SlimeEat>();
|
|
if (slimeEat != null)
|
|
{
|
|
if (type == PacketActorFX.FXType.SlimeEatFavoriteFX)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(slimeEat.EatFavoriteFX, slimeEat.transform.position, slimeEat.transform.rotation);
|
|
}
|
|
else if (type == PacketActorFX.FXType.SlimeEatFX)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(slimeEat.EatFX, slimeEat.transform.position, slimeEat.transform.rotation);
|
|
}
|
|
else if (type == PacketActorFX.FXType.SlimeTransformFX)
|
|
{
|
|
SRBehaviour.SpawnAndPlayFX(slimeEat.TransformFX, slimeEat.transform.position, slimeEat.transform.rotation);
|
|
}
|
|
else if (type == PacketActorFX.FXType.SlimeProduceFX)
|
|
{
|
|
if (slimeEat.ProduceFX != null)
|
|
{
|
|
RecolorSlimeMaterial[] componentsInChildren = SRBehaviour.SpawnAndPlayFX(slimeEat.ProduceFX, slimeEat.transform.TransformPoint(SlimeEat.LOCAL_PRODUCE_LOC), slimeEat.transform.rotation).GetComponentsInChildren<RecolorSlimeMaterial>();
|
|
if (componentsInChildren != null && componentsInChildren.Length != 0)
|
|
{
|
|
SlimeAppearance.Palette appearancePalette = slimeEat.appearanceApplicator.GetAppearancePalette();
|
|
RecolorSlimeMaterial[] array = componentsInChildren;
|
|
for (int j = 0; j < array.Length; j++)
|
|
{
|
|
array[j].SetColors(appearancePalette.Top, appearancePalette.Middle, appearancePalette.Bottom);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorFeral(PacketActorFeral packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
var slimeFeral = netActor.GetComponentInChildren<SlimeFeral>(true);
|
|
if (slimeFeral != null)
|
|
{
|
|
if (packet.Feral)
|
|
{
|
|
slimeFeral.MakeFeral();
|
|
}
|
|
else
|
|
{
|
|
slimeFeral.MakeNotFeral(packet.Deagitate);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorEmotions(PacketActorEmotions packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
var emotions = netActor.GetComponentInChildren<SlimeEmotions>(true);
|
|
if (emotions != null)
|
|
{
|
|
emotions.model.emotionAgitation.currVal = packet.Agitation;
|
|
emotions.model.emotionFear.currVal = packet.Fear;
|
|
emotions.model.emotionHunger.currVal = packet.Hunger;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorReproduceTime(PacketActorReproduceTime packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
var reproduce = netActor.GetComponentInChildren<Reproduce>(true);
|
|
if (reproduce != null)
|
|
{
|
|
reproduce.model.nextReproduceTime = packet.Time;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorResourceState(PacketActorResourceState packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
var cycle = netActor.GetComponentInChildren<ResourceCycle>(true);
|
|
if (cycle != null)
|
|
{
|
|
var state = (ResourceCycle.State)packet.State;
|
|
//SRMP.Log($"Resource state for {netActor.name} ({netActor.ID}): {state}", "CLIENT");
|
|
if (state == ResourceCycle.State.RIPE)
|
|
{
|
|
cycle.Ripen();
|
|
if (cycle.vacuumableWhenRipe)
|
|
{
|
|
cycle.vacuumable.enabled = true;
|
|
}
|
|
if (cycle.gameObject.transform.localScale.x < cycle.defaultScale.x * 0.33f)
|
|
{
|
|
cycle.gameObject.transform.localScale = cycle.defaultScale * 0.33f;
|
|
}
|
|
TweenUtil.ScaleTo(cycle.gameObject, cycle.defaultScale, 4f, Ease.InOutQuad);
|
|
}
|
|
else if (state == ResourceCycle.State.EDIBLE)
|
|
{
|
|
cycle.MakeEdible();
|
|
cycle.additionalRipenessDelegate = null;
|
|
var rigid = cycle.GetComponent<Rigidbody>();
|
|
rigid.isKinematic = false;
|
|
if (packet.PreparingToRelease)
|
|
{
|
|
cycle.preparingToRelease = false;
|
|
cycle.releaseAt = 0f;
|
|
cycle.toShake.localPosition = cycle.toShakeDefaultPos;
|
|
if (cycle.releaseCue != null)
|
|
{
|
|
SECTR_PointSource component = cycle.GetComponent<SECTR_PointSource>();
|
|
component.Cue = cycle.releaseCue;
|
|
component.Play();
|
|
}
|
|
}
|
|
rigid.WakeUp();
|
|
cycle.Eject(rigid);
|
|
cycle.DetachFromJoint();
|
|
if (cycle.hasVacuumable)
|
|
{
|
|
cycle.vacuumable.Pending = false;
|
|
}
|
|
}
|
|
else if (state == ResourceCycle.State.ROTTEN)
|
|
{
|
|
cycle.Rot();
|
|
cycle.SetRotten(!cycle.gameObject.activeInHierarchy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorResourceAttach(PacketActorResourceAttach packet)
|
|
{
|
|
if (packet.PlotID.Length < 1)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor) && Globals.SpawnResources.TryGetValue(packet.ResourceID, out NetworkSpawnResource netSpawnResource))
|
|
{
|
|
var cycle = netActor.GetComponentInChildren<ResourceCycle>(true);
|
|
var joint = netSpawnResource.SpawnResource.SpawnJoints[packet.JointIndex];
|
|
//SRMP.Log($"Adding {cycle.name} to {joint.gameObject.GetGameObjectPath()}", "CLIENT");
|
|
cycle?.Attach(joint, new ResourceCycle.AdditionalRipeness(netSpawnResource.SpawnResource.AdditionalRipenessPerSecond), null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor) && SRSingleton<SceneContext>.Instance.GameModel.AllLandPlots().TryGetValue(packet.PlotID, out LandPlotModel model))
|
|
{
|
|
var cycle = netActor.GetComponentInChildren<ResourceCycle>(true);
|
|
var spawner = model.gameObj.GetComponentInChildren<SpawnResource>(true);
|
|
var joint = spawner.SpawnJoints[packet.JointIndex];
|
|
//SRMP.Log($"Adding {cycle.name} to {joint.gameObject.GetGameObjectPath()}", "CLIENT");
|
|
cycle?.Attach(joint, new ResourceCycle.AdditionalRipeness(spawner.AdditionalRipenessPerSecond), null);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnActorPosition(PacketActorPosition packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
netActor.PositionRotationUpdate(packet.Position, packet.Rotation, false);
|
|
}
|
|
}
|
|
|
|
private static void OnActorOwner(PacketActorOwner packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
netActor.SetOwnership(packet.Owner);
|
|
}
|
|
}
|
|
|
|
private static void OnActorDestroy(PacketActorDestroy packet)
|
|
{
|
|
if (Globals.Actors.TryGetValue(packet.ID, out NetworkActor netActor))
|
|
{
|
|
netActor.OnDestroyEffect();
|
|
Destroyer.DestroyActor(netActor.gameObject, "NetworkHandlerServer.OnActorDestroy");
|
|
Globals.Actors.Remove(netActor.ID);
|
|
}
|
|
}
|
|
|
|
private static void OnActorSpawn(PacketActorSpawn packet)
|
|
{
|
|
if (!Globals.Actors.ContainsKey(packet.ID))
|
|
{
|
|
var prefab = SRSingleton<GameContext>.Instance.LookupDirector.GetPrefab((Identifiable.Id)packet.Ident);
|
|
var actorObj = SRBehaviour.InstantiateActor(prefab, (RegionRegistry.RegionSetId)packet.RegionSet, packet.Position, packet.Rotation, false);
|
|
var netActor = actorObj.AddComponent<NetworkActor>();
|
|
netActor.ID = packet.ID;
|
|
netActor.Owner = packet.Owner;
|
|
netActor.Ident = packet.Ident;
|
|
netActor.RegionSet = packet.RegionSet;
|
|
netActor.PositionRotationUpdate(packet.Position, packet.Rotation, true);
|
|
|
|
Globals.Actors.Add(netActor.ID, netActor);
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log($"Dublicate Actor ID: {packet.ID}");
|
|
}
|
|
}
|
|
|
|
private static void OnActors(PacketActors packet)
|
|
{
|
|
foreach (var actorData in packet.Actors)
|
|
{
|
|
if (!Globals.Actors.ContainsKey(actorData.ID))
|
|
{
|
|
try
|
|
{
|
|
var prefab = SRSingleton<GameContext>.Instance.LookupDirector.GetPrefab((Identifiable.Id)actorData.Ident);
|
|
var actorObj = SRBehaviour.InstantiateActor(prefab, (RegionRegistry.RegionSetId)actorData.RegionSet, actorData.Position, actorData.Rotation, false);
|
|
var netActor = actorObj.AddComponent<NetworkActor>();
|
|
netActor.ID = actorData.ID;
|
|
netActor.Owner = actorData.Owner;
|
|
netActor.Ident = actorData.Ident;
|
|
netActor.RegionSet = actorData.RegionSet;
|
|
netActor.PositionRotationUpdate(actorData.Position, actorData.Rotation, true);
|
|
|
|
if (actorData.ProduceModel != null)
|
|
{
|
|
var resourceCycle = actorObj.GetComponentInChildren<ResourceCycle>(true);
|
|
if (resourceCycle != null)
|
|
{
|
|
resourceCycle.SetInitState(actorData.ProduceModel.state, actorData.ProduceModel.progressTime);
|
|
}
|
|
}
|
|
if (actorData.PlortModel != null)
|
|
{
|
|
var plortDestroy = actorObj.GetComponentInChildren<DestroyPlortAfterTime>(true);
|
|
if (plortDestroy != null)
|
|
{
|
|
plortDestroy.plortModel.destroyTime = actorData.PlortModel.destroyTime;
|
|
}
|
|
}
|
|
if (actorData.AnimalModel != null)
|
|
{
|
|
var reproduce = actorObj.GetComponentInChildren<Reproduce>(true);
|
|
if (reproduce != null)
|
|
{
|
|
reproduce.model.fashions = actorData.AnimalModel.fashions;
|
|
reproduce.model.nextReproduceTime = actorData.AnimalModel.nextReproduceTime;
|
|
reproduce.model.transformTime = actorData.AnimalModel.transformTime;
|
|
|
|
reproduce.model.NotifyParticipants(actorObj);
|
|
}
|
|
}
|
|
if (actorData.SlimeModel != null)
|
|
{
|
|
var slimeEat = actorObj.GetComponentInChildren<SlimeEat>(true);
|
|
if (slimeEat != null)
|
|
{
|
|
slimeEat.slimeModel.emotionAgitation.currVal = actorData.SlimeModel.emotionAgitation.currVal;
|
|
slimeEat.slimeModel.emotionFear.currVal = actorData.SlimeModel.emotionFear.currVal;
|
|
slimeEat.slimeModel.emotionHunger.currVal = actorData.SlimeModel.emotionHunger.currVal;
|
|
slimeEat.slimeModel.isFeral = actorData.SlimeModel.isFeral;
|
|
slimeEat.slimeModel.isGlitch = actorData.SlimeModel.isGlitch;
|
|
slimeEat.slimeModel.fashions = actorData.SlimeModel.fashions;
|
|
|
|
slimeEat.slimeModel.NotifyParticipants(actorObj);
|
|
}
|
|
}
|
|
|
|
Globals.Actors.Add(netActor.ID, netActor);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SRMP.Log($"Could not create actor {actorData.ID}: {ex}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log($"Dublicate Actor ID: {actorData.ID}");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Regions
|
|
private static void OnRegionOwner(PacketRegionOwner packet)
|
|
{
|
|
if (Globals.Regions.TryGetValue(packet.ID, out NetworkRegion netRegion))
|
|
{
|
|
netRegion.SetOwnership(packet.Owner);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Players
|
|
private static void OnPlayerChat(PacketPlayerChat packet)
|
|
{
|
|
ChatUI.Instance.AddChatMessage(packet.message);
|
|
}
|
|
|
|
private static void OnPlayerUpgradeUnlock(PacketPlayerUpgradeUnlock packet)
|
|
{
|
|
if (!SRSingleton<SceneContext>.Instance.PlayerState.HasUpgrade((PlayerState.Upgrade)packet.Upgrade) &&
|
|
!SRSingleton<SceneContext>.Instance.PlayerState.model.availUpgrades.Contains((PlayerState.Upgrade)packet.Upgrade))
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.availUpgrades.Add((PlayerState.Upgrade)packet.Upgrade);
|
|
SRSingleton<SceneContext>.Instance.PlayerState.popupDir.QueueForPopup(new PlayerState.AvailUpgradePopupCreator((PlayerState.Upgrade)packet.Upgrade));
|
|
SRSingleton<SceneContext>.Instance.PlayerState.popupDir.MaybePopupNext();
|
|
}
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.upgradeLocks.Remove((PlayerState.Upgrade)packet.Upgrade);
|
|
}
|
|
|
|
private static void OnPlayerUpgrade(PacketPlayerUpgrade packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.AddUpgrade((PlayerState.Upgrade)packet.Upgrade);
|
|
}
|
|
|
|
private static void OnPlayerCurrencyDisplay(PacketPlayerCurrencyDisplay packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.SetCurrencyDisplay(packet.IsNull ? null : new int?(packet.Currency));
|
|
if (packet.IsNull)
|
|
{
|
|
SRSingleton<PopupElementsUI>.Instance.CreateCoinsPopup(packet.Currency, PlayerState.CoinsType.DRONE);
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerCurrency(PacketPlayerCurrency packet)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.currency = packet.Total;
|
|
SRSingleton<PopupElementsUI>.Instance.CreateCoinsPopup(packet.Adjust, (PlayerState.CoinsType)packet.Type);
|
|
}
|
|
|
|
private static void OnPlayerFX(PacketPlayerFX packet)
|
|
{
|
|
if (Globals.Players.TryGetValue(packet.ID, out NetworkPlayer player))
|
|
{
|
|
var type = (PacketPlayerFX.FXType)packet.Type;
|
|
|
|
switch (type)
|
|
{
|
|
case PacketPlayerFX.FXType.Capture:
|
|
SRBehaviour.SpawnAndPlayFX(player.CaptureFX, player.VacTransform.gameObject, Vector3.zero, Quaternion.identity);
|
|
break;
|
|
case PacketPlayerFX.FXType.CaptureFailed:
|
|
SRBehaviour.SpawnAndPlayFX(player.CaptureFailedFX, player.VacTransform.gameObject, Vector3.zero, Quaternion.identity);
|
|
break;
|
|
case PacketPlayerFX.FXType.Shoot:
|
|
SRBehaviour.SpawnAndPlayFX(player.ShootFX, player.VacTransform.gameObject, Vector3.zero, Quaternion.identity);
|
|
break;
|
|
case PacketPlayerFX.FXType.VacAudio:
|
|
player.SetVacAudio(packet.Enable);
|
|
break;
|
|
case PacketPlayerFX.FXType.Vac:
|
|
player.VacFX.SetActive(packet.Enable);
|
|
break;
|
|
case PacketPlayerFX.FXType.Airburst:
|
|
player.Airburst();
|
|
break;
|
|
case PacketPlayerFX.FXType.DestroyOnVac:
|
|
|
|
break;
|
|
case PacketPlayerFX.FXType.JetpackAudio:
|
|
player.SetJetpackAudio(packet.Enable);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerAnimation(PacketPlayerAnimation packet)
|
|
{
|
|
//handle character animation triggers
|
|
PacketPlayerAnimation.AnimationType type = (PacketPlayerAnimation.AnimationType)packet.Type;
|
|
|
|
|
|
|
|
if (Globals.Players.TryGetValue(packet.ID, out NetworkPlayer player) && player.HasLoaded)
|
|
{
|
|
if(type == PacketPlayerAnimation.AnimationType.Speed)
|
|
player.ReadAnimatorSpeed(packet.internalData);
|
|
else if (type == PacketPlayerAnimation.AnimationType.Parameters)
|
|
{
|
|
player.ReadParameters(packet.internalData);
|
|
}
|
|
else
|
|
player.ReadAnimatorLayer(packet.internalData);
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerPosition(PacketPlayerPosition packet)
|
|
{
|
|
if (Globals.Players.TryGetValue(packet.ID, out NetworkPlayer player))
|
|
{
|
|
if (player.HasLoaded && Globals.GameLoaded)
|
|
{
|
|
if (player.IsLocal)
|
|
{
|
|
if (packet.OnLoad)
|
|
{
|
|
|
|
var euler = SRSingleton<SceneContext>.Instance.player.GetComponentInChildren<WeaponVacuum>().transform.eulerAngles;
|
|
euler.x = packet.WeaponY;
|
|
SRSingleton<SceneContext>.Instance.player.GetComponentInChildren<WeaponVacuum>().transform.eulerAngles = euler;
|
|
SRSingleton<SceneContext>.Instance.player.transform.position = packet.Position;
|
|
SRSingleton<SceneContext>.Instance.player.transform.eulerAngles = new Vector3(0, packet.Rotation, 0);
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.SetCurrRegionSet((RegionRegistry.RegionSetId)packet.RegionSet);
|
|
|
|
|
|
//only reload inventory if this is a load up packet and NOT a tp packet
|
|
if (!Globals.IsServer)
|
|
{
|
|
try
|
|
{
|
|
using (FileStream file = new FileStream(Path.Combine(SRMP.ModDataPath, Globals.CurrentGameName + ".player"), FileMode.Open))
|
|
{
|
|
using (BinaryReader reader = new BinaryReader(file))
|
|
{
|
|
Debug.Log($"Loading {Path.Combine(SRMP.ModDataPath, Globals.CurrentGameName + ".player")}");
|
|
var ammoCount = reader.ReadInt32();
|
|
for (int i = 0; i < ammoCount; i++)
|
|
{
|
|
var state = (PlayerState.AmmoMode)reader.ReadByte();
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].usableSlots = reader.ReadInt32();
|
|
var slotCount = reader.ReadInt32();
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].slots = new Ammo.Slot[slotCount];
|
|
for (int j = 0; j < slotCount; j++)
|
|
{
|
|
if (reader.ReadBoolean())
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].slots[j] = new Ammo.Slot((Identifiable.Id)reader.ReadUInt16(), reader.ReadInt32());
|
|
if (reader.ReadBoolean())
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].slots[j].emotions = new SlimeEmotionData();
|
|
var emotionCount = reader.ReadInt32();
|
|
for (int k = 0; k < emotionCount; k++)
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].slots[j].emotions.Add((SlimeEmotions.Emotion)reader.ReadUInt16(), reader.ReadSingle());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.ammoDict[state].slots[j] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.Log($"No savefile for {Globals.CurrentGameName}: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SRMP.Log("Player is being teleported", "CLIENT");
|
|
|
|
SRSingleton<SceneContext>.Instance.player.transform.position = packet.Position;
|
|
SRSingleton<SceneContext>.Instance.player.transform.eulerAngles = new Vector3(0, packet.Rotation, 0);
|
|
SRSingleton<SceneContext>.Instance.PlayerState.model.SetCurrRegionSet((RegionRegistry.RegionSetId)packet.RegionSet);
|
|
|
|
SRSingleton<Overlay>.Instance.PlayTeleport();
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
player.PositionRotationUpdate(packet.Position, packet.Rotation, false);
|
|
player.UpdateWeaponRotation(packet.WeaponY);
|
|
player.CurrentRegionSet = (RegionRegistry.RegionSetId)packet.RegionSet;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerLoaded(PacketPlayerLoaded packet)
|
|
{
|
|
if (Globals.Players.TryGetValue(packet.ID, out NetworkPlayer player))
|
|
{
|
|
if (player.IsLocal)
|
|
{
|
|
Globals.ClientLoaded = true;
|
|
SRMP.Log("Received all data, multiplayer fully loaded!", "CLIENT");
|
|
}
|
|
else
|
|
{
|
|
player.HasLoaded = true;
|
|
|
|
if (Globals.GameLoaded)
|
|
{
|
|
player.Spawn();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerLeft(PacketPlayerLeft packet)
|
|
{
|
|
if (Globals.Players.TryGetValue(packet.ID, out NetworkPlayer player))
|
|
{
|
|
GameObject.Destroy(player.gameObject);
|
|
Globals.Players.Remove(packet.ID);
|
|
}
|
|
}
|
|
|
|
private static void OnPlayerJoined(PacketPlayerJoined packet)
|
|
{
|
|
var playerObj = new GameObject($"{packet.Username} ({packet.ID})");
|
|
var player = playerObj.AddComponent<NetworkPlayer>();
|
|
player.ID = packet.ID;
|
|
player.Username = packet.Username;
|
|
|
|
Globals.Players.Add(packet.ID, player);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|