public override void Process(ConstructorBeginCrafting packet) { GameObject gameObject = GuidHelper.RequireObjectFrom(packet.ConstructorGuid); Crafter crafter = gameObject.RequireComponentInChildren <Crafter>(true); vehicles.AddVehicle(VehicleModelFactory.BuildFrom(packet)); MethodInfo onCraftingBegin = typeof(Crafter).GetMethod("OnCraftingBegin", BindingFlags.NonPublic | BindingFlags.Instance); Validate.NotNull(onCraftingBegin); onCraftingBegin.Invoke(crafter, new object[] { packet.TechType.Enum(), packet.Duration }); //TODO: take into account latency for duration Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); constructedObject.AddComponent <NitroxEntity>(); GuidHelper.SetNewGuid(constructedObject, packet.ConstructedItemGuid); VehicleChildObjectIdentifierHelper.SetInteractiveChildrenGuids(constructedObject, packet.InteractiveChildIdentifiers); } else { Log.Error("Could not find constructed object!"); } }
public void ConstructionComplete(GameObject ghost) { NitroxId baseId = null; Optional <object> opConstructedBase = TransientLocalObjectManager.Get(TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); NitroxId id = NitroxEntity.GetId(ghost); if (opConstructedBase.IsPresent()) { GameObject constructedBase = (GameObject)opConstructedBase.Get(); baseId = NitroxEntity.GetId(constructedBase); } // For base pieces, we must switch the id from the ghost to the newly constructed piece. // Furniture just uses the same game object as the ghost for the final product. if (ghost.GetComponent <ConstructableBase>() != null) { Optional <object> opBasePiece = TransientLocalObjectManager.Get(TransientObjectType.LATEST_CONSTRUCTED_BASE_PIECE); GameObject finishedPiece = (GameObject)opBasePiece.Get(); UnityEngine.Object.Destroy(ghost); NitroxEntity.SetNewId(finishedPiece, id); if (baseId == null) { baseId = NitroxEntity.GetId(finishedPiece.GetComponentInParent <Base>().gameObject); } } ConstructionCompleted constructionCompleted = new ConstructionCompleted(id, baseId); packetSender.Send(constructionCompleted); }
public static void Prefix(BaseDeconstructable __instance) { string guid = GuidHelper.GetGuid(__instance.gameObject); Log.Info("Deconstructing " + guid); TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, guid); }
public static bool Prefix(Constructable __instance, bool value) { // check to see if they are trying to update constructed value from true to false. This means that they // are trying to deconstruct an object. if (__instance.constructed && value == false) { Optional <object> opId = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID); NitroxId id; // Check to see if they are trying to deconstruct a base piece. If so, we will need to use the // id in LATEST_DECONSTRUCTED_BASE_PIECE_GUID because base pieces get destroyed and recreated with // a ghost (furniture just uses the same game object). if (opId.IsPresent()) { // base piece, get id before ghost appeared id = (NitroxId)opId.Get(); Log.Info("Deconstructing base piece with id: " + id); } else { // furniture, just use the same object to get the id id = NitroxEntity.GetId(__instance.gameObject); Log.Info("Deconstructing furniture with id: " + id); } NitroxServiceLocator.LocateService <Building>().DeconstructionBegin(id); } return(true); }
public static void Postfix(Constructable __instance) { if (!__instance._constructed && __instance.constructedAmount == 1f) { Optional <object> opId = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID); NitroxId id; // Check to see if they are trying to deconstruct a base piece. If so, we will need to use the // id in LATEST_DECONSTRUCTED_BASE_PIECE_GUID because base pieces get destroyed and recreated with // a ghost (furniture just uses the same game object). if (opId.HasValue) { // base piece, get id before ghost appeared id = (NitroxId)opId.Value; Log.Info("Deconstructing base piece with id: " + id); } else { // furniture, just use the same object to get the id id = NitroxEntity.GetId(__instance.gameObject); Log.Info("Deconstructing furniture with id: " + id); } NitroxServiceLocator.LocateService <Building>().DeconstructionBegin(id); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { NitroxId constructorId = NitroxEntity.GetId(constructor); Log.Debug("Building item from constructor with id: " + constructorId); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.HasValue) { GameObject constructedObject = (GameObject)opConstructedObject.Value; List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractInteractiveChildren(constructedObject); VehicleModel vehicleModel = vehicles.BuildVehicleModelFrom(constructedObject, techType); vehicles.AddVehicle(vehicleModel); packetSender.Send(new ConstructorBeginCrafting(vehicleModel, constructorId, duration)); vehicles.SpawnDefaultBatteries(constructedObject, childIdentifiers); MonoBehaviour monoBehaviour = constructor.GetComponent <MonoBehaviour>(); //We want to store the fallen position of the object to avoid flying object on reload if (monoBehaviour) { monoBehaviour.StartCoroutine(vehicles.UpdateVehiclePositionAfterSpawn(vehicleModel, constructedObject, duration + 10.0f)); } } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
private void ConstructionAmountChanged(ConstructionAmountChangedEvent amountChanged) { Log.Debug($"Processing ConstructionAmountChanged {amountChanged.Id} {amountChanged.Amount}"); GameObject constructing = NitroxEntity.RequireObjectFrom(amountChanged.Id); BaseDeconstructable baseDeconstructable = constructing.GetComponent <BaseDeconstructable>(); // Bases don't send a deconstruct being packet. Instead, we just make sure // that if we are changing the amount that we set it into deconstruction mode // if it still has a BaseDeconstructable object on it. if (baseDeconstructable != null) { baseDeconstructable.Deconstruct(); // After we have begun the deconstructing for a base piece, we need to transfer the id Optional <object> opGhost = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GHOST); if (opGhost.HasValue) { GameObject ghost = (GameObject)opGhost.Value; Destroy(constructing); NitroxEntity.SetNewId(ghost, amountChanged.Id); } else { Log.Error($"Could not find newly created ghost to set deconstructed id {amountChanged.Id}"); } } else { Constructable constructable = constructing.GetComponentInChildren <Constructable>(); constructable.constructedAmount = amountChanged.Amount; constructable.Construct(); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { NitroxId constructorId = NitroxEntity.GetId(constructor); Log.Debug("Building item from constructor with id: " + constructorId); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.HasValue) { GameObject constructedObject = (GameObject)opConstructedObject.Value; List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractInteractiveChildren(constructedObject); VehicleModel vehicleModel = vehicles.BuildVehicleModelFrom(constructedObject, techType); vehicles.AddVehicle(vehicleModel); ConstructorBeginCrafting beginCrafting = VehicleConstructionFactory.BuildFrom(vehicleModel, constructorId, duration); packetSender.Send(beginCrafting); vehicles.SpawnDefaultBatteries(constructedObject, childIdentifiers); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
public void ConstructionComplete(GameObject ghost) { Optional <string> newlyConstructedBaseGuid = Optional <string> .Empty(); Optional <object> opConstructedBase = TransientLocalObjectManager.Get(TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); string guid = GuidHelper.GetGuid(ghost); if (opConstructedBase.IsPresent()) { GameObject constructedBase = (GameObject)opConstructedBase.Get(); newlyConstructedBaseGuid = Optional <string> .Of(GuidHelper.GetGuid(constructedBase)); } // For base pieces, we must switch the guid from the ghost to the newly constructed piece. // Furniture just uses the same game object as the ghost for the final product. if (ghost.GetComponent <ConstructableBase>() != null) { Optional <object> opBasePiece = TransientLocalObjectManager.Get(TransientObjectType.LATEST_CONSTRUCTED_BASE_PIECE); GameObject finishedPiece = (GameObject)opBasePiece.Get(); UnityEngine.Object.Destroy(ghost); GuidHelper.SetNewGuid(finishedPiece, guid); } ConstructionCompleted constructionCompleted = new ConstructionCompleted(guid, newlyConstructedBaseGuid); packetSender.Send(constructionCompleted); }
public override void Process(ConstructorBeginCrafting packet) { GameObject gameObject = GuidHelper.RequireObjectFrom(packet.ConstructorGuid); Crafter crafter = gameObject.RequireComponentInChildren <Crafter>(true); MethodInfo onCraftingBegin = typeof(Crafter).GetMethod("OnCraftingBegin", BindingFlags.NonPublic | BindingFlags.Instance); Validate.NotNull(onCraftingBegin); onCraftingBegin.Invoke(crafter, new object[] { packet.TechType, packet.Duration }); //TODO: take into account latency for duration Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); GuidHelper.SetNewGuid(constructedObject, packet.ConstructedItemGuid); SetInteractiveChildrenGuids(constructedObject, packet.InteractiveChildIdentifiers); if (packet.TechType == TechType.Cyclops) { SubRoot subRoot = constructedObject.GetComponent <SubRoot>(); if (subRoot != null) { GuidHelper.SetNewGuid(subRoot.upgradeConsole.modules.owner, packet.ConstructedModulesEquipmentGuid.Get()); Log.Info("New Modules Guid: " + GuidHelper.GetGuid(subRoot.upgradeConsole.modules.owner)); } } } else { Log.Error("Could not find constructed object!"); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { string constructorGuid = GuidHelper.GetGuid(constructor); Log.Debug("Building item from constructor with uuid: " + constructorGuid); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractGuidsOfInteractiveChildren(constructedObject); Vehicle vehicle = constructedObject.GetComponent <Vehicle>(); string constructedObjectGuid = GuidHelper.GetGuid(constructedObject); //Initialize some default values to serialize. Vector3[] HSB = new Vector3[5]; Vector3[] Colours = new Vector3[5]; Vector4 tmpColour = Color.white; string name = "Cyclops"; // Cant find a way to actually get the Cyclops name. getObjectAttributes(vehicle, name, HSB, Colours, tmpColour, constructedObjectGuid); ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(constructorGuid, constructedObjectGuid, techType, duration, childIdentifiers, constructedObject.transform.position, constructedObject.transform.rotation, name, HSB, Colours); packetSender.Send(beginCrafting); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
public static void Prefix(BaseDeconstructable __instance) { NitroxId id = NitroxIdentifier.GetId(__instance.gameObject); Log.Info("Deconstructing " + id); TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, id); }
private void ConstructionCompleted(ConstructionCompletedEvent constructionCompleted) { Log.Info("Constructed completed " + constructionCompleted.Guid); GameObject constructing = GuidHelper.RequireObjectFrom(constructionCompleted.Guid); ConstructableBase constructableBase = constructing.GetComponent <ConstructableBase>(); // For bases, we need to transfer the GUID off of the ghost and onto the finished piece. // Furniture just re-uses the same piece. if (constructableBase) { constructableBase.constructedAmount = 1f; constructableBase.SetState(true, true); Optional <object> opBasePiece = TransientLocalObjectManager.Get(TransientObjectType.LATEST_CONSTRUCTED_BASE_PIECE); GameObject finishedPiece = (GameObject)opBasePiece.Get(); UnityEngine.Object.Destroy(constructableBase.gameObject); GuidHelper.SetNewGuid(finishedPiece, constructionCompleted.Guid); } else { Constructable constructable = constructing.GetComponent <Constructable>(); constructable.constructedAmount = 1f; constructable.SetState(true, true); } if (constructionCompleted.BaseGuid != null && GuidHelper.GetObjectFrom(constructionCompleted.BaseGuid).IsEmpty()) { Log.Info("Creating base: " + constructionCompleted.BaseGuid); ConfigureNewlyConstructedBase(constructionCompleted.BaseGuid); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { string constructorGuid = GuidHelper.GetGuid(constructor); Log.Debug("Building item from constructor with uuid: " + constructorGuid); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); List <InteractiveChildObjectIdentifier> childIdentifiers = ExtractGuidsOfInteractiveChildren(constructedObject); string constructedObjectGuid = GuidHelper.GetGuid(constructedObject); Optional <string> ModuleGuid = Optional <string> .Empty(); if (techType == TechType.Cyclops) { SubRoot subRoot = constructedObject.GetComponent <SubRoot>(); if (subRoot != null) { Log.Info("New Cyclop Modules Guid: " + GuidHelper.GetGuid(subRoot.upgradeConsole.modules.owner)); ModuleGuid = Optional <string> .Of(GuidHelper.GetGuid(subRoot.upgradeConsole.modules.owner)); } } ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(constructorGuid, constructedObjectGuid, ModuleGuid, techType, duration, childIdentifiers, constructedObject.transform.position, constructedObject.transform.rotation); packetSender.Send(beginCrafting); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
public static void Prefix(BaseDeconstructable __instance) { NitroxId id = NitroxEntity.GetId(__instance.gameObject); Log.Info("Deconstructing " + id); NitroxServiceLocator.LocateService <Building>().DeconstructionBegin(id); TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, id); }
/** * On base pieces we need to have special logic during deconstruction to transfer the id from the main * object to the ghost. This method will see if we have a stored LATEST_DECONSTRUCTED_BASE_PIECE_GUID * (set from deconstructor patch). If we do, then we'll copy the id to the new ghost. This is in * amount changed as we don't currently have a good hook for 'startDeconstruction'; this method will * run its logic on the first amount changed instead - effectively the same thing. */ public static void CheckToCopyIdToGhost(Constructable __instance) { Optional <object> opId = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID); if (opId.IsPresent()) { TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, null); NitroxId id = (NitroxId)opId.Get(); Log.Info("Setting ghost id " + id); NitroxEntity.SetNewId(__instance.gameObject, id); } }
/** * On base pieces we need to have special logic during deconstruction to transfer the guid from the main * object to the ghost. This method will see if we have a stored LATEST_DECONSTRUCTED_BASE_PIECE_GUID * (set from deconstructor patch). If we do, then we'll copy the guid to the new ghost. This is in * amount changed as we don't currently have a good hook for 'startDeconstruction'; this method will * run its logic on the first amount changed instead - effectively the same thing. */ public static void CheckToCopyGuidToGhost(Constructable __instance) { Optional <object> opGuid = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID); if (opGuid.IsPresent()) { TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, null); string guid = (string)opGuid.Get(); Log.Info("Setting ghost guid " + guid); GuidHelper.SetNewGuid(__instance.gameObject, guid); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { NitroxId constructorId = NitroxEntity.GetId(constructor); Log.Debug("Building item from constructor with id: " + constructorId); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.HasValue) { GameObject constructedObject = (GameObject)opConstructedObject.Value; List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractInteractiveChildren(constructedObject); Vehicle vehicle = constructedObject.GetComponent <Vehicle>(); NitroxId constructedObjectId = NitroxEntity.GetId(constructedObject); Vector3[] HSB = new Vector3[5]; Vector3[] Colours = new Vector3[5]; Vector4 tmpColour = Color.white; string name = ""; float health = 1; if (!vehicle) { // Cyclops GameObject target = NitroxEntity.RequireObjectFrom(constructedObjectId); SubNameInput subNameInput = target.RequireComponentInChildren <SubNameInput>(); SubName subNameTarget = (SubName)subNameInput.ReflectionGet("target"); Colours = subNameTarget.GetColors(); HSB = subNameTarget.GetColors(); name = subNameTarget.GetName(); health = target.GetComponent <LiveMixin>().health; } else if (vehicle) { // Seamoth & Prawn Suit health = vehicle.GetComponent <LiveMixin>().health; name = (string)vehicle.ReflectionCall("GetName", true); HSB = vehicle.subName.GetColors(); Colours = vehicle.subName.GetColors(); } ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(constructorId, constructedObjectId, techType.Model(), duration, childIdentifiers, constructedObject.transform.position, constructedObject.transform.rotation, name, HSB, Colours, health); vehicles.AddVehicle(VehicleModelFactory.BuildFrom(beginCrafting)); packetSender.Send(beginCrafting); SpawnDefaultBatteries(constructedObject, childIdentifiers); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
private void ConfigureNewlyConstructedBase(string newBaseGuid) { Optional <object> opNewlyCreatedBase = TransientLocalObjectManager.Get(TransientLocalObjectManager.TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); if (opNewlyCreatedBase.IsPresent()) { GameObject newlyCreatedBase = (GameObject)opNewlyCreatedBase.Get(); GuidHelper.SetNewGuid(newlyCreatedBase, newBaseGuid); } else { Log.Error("Could not assign new base guid as no newly constructed base was found"); } }
public override void Process(DeconstructionBegin packet) { Log.Info("Received deconstruction packet for basePieceId: " + packet.Id); GameObject deconstructing = NitroxEntity.RequireObjectFrom(packet.Id); BaseDeconstructable baseDeconstructable = deconstructing.RequireComponent <BaseDeconstructable>(); TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, packet.Id); using (packetSender.Suppress <DeconstructionBegin>()) { baseDeconstructable.Deconstruct(); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { string constructorGuid = GuidHelper.GetGuid(constructor); Log.Debug("Building item from constructor with uuid: " + constructorGuid); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractGuidsOfInteractiveChildren(constructedObject); Vehicle vehicle = constructedObject.GetComponent <Vehicle>(); string constructedObjectGuid = GuidHelper.GetGuid(constructedObject); Vector3[] HSB = new Vector3[5]; Vector3[] Colours = new Vector3[5]; Vector4 tmpColour = Color.white; string name = ""; if (!vehicle) { // Cylcops GameObject target = GuidHelper.RequireObjectFrom(constructedObjectGuid); SubNameInput subNameInput = target.RequireComponentInChildren <SubNameInput>(); SubName subNameTarget = (SubName)subNameInput.ReflectionGet("target"); Colours = subNameTarget.GetColors(); HSB = subNameTarget.GetColors(); name = subNameTarget.GetName(); } else if (vehicle) { // Seamoth & Prawn Suit name = (string)vehicle.ReflectionCall("GetName", true); HSB = vehicle.subName.GetColors(); Colours = vehicle.subName.GetColors(); } ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(constructorGuid, constructedObjectGuid, techType.Model(), duration, childIdentifiers, constructedObject.transform.position, constructedObject.transform.rotation, name, HSB, Colours); vehicles.AddVehicle(VehicleModelFactory.BuildFrom(beginCrafting)); packetSender.Send(beginCrafting); // Mark vehicle as controlled by nitrox (used for sending add/remove batteries aka storage slots) constructedObject.AddComponent <NitroxEntity>(); SpawnDefaultBatteries(constructedObject, childIdentifiers); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
private void ConfigureNewlyConstructedBase(NitroxId newBaseId) { Optional <object> opNewlyCreatedBase = TransientLocalObjectManager.Get(TransientLocalObjectManager.TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); if (opNewlyCreatedBase.HasValue) { GameObject newlyCreatedBase = (GameObject)opNewlyCreatedBase.Value; NitroxEntity.SetNewId(newlyCreatedBase, newBaseId); } else { Log.Error("Could not assign new base id as no newly constructed base was found"); } }
public override void Process(ConstructorBeginCrafting packet) { Optional <GameObject> opGameObject = GuidHelper.GetObjectFrom(packet.ConstructorGuid); if (opGameObject.IsEmpty()) { Console.WriteLine("Trying to build " + packet.TechType + " with unmanaged constructor - ignoring."); return; } GameObject gameObject = opGameObject.Get(); Crafter crafter = gameObject.GetComponentInChildren <Crafter>(true); if (crafter == null) { Console.WriteLine("Trying to build " + packet.TechType + " but we did not have a corresponding constructorInput - how did that happen?"); return; } Optional <TechType> opTechType = ApiHelper.TechType(packet.TechType); if (opTechType.IsEmpty()) { Console.WriteLine("Trying to build unknown tech type: " + packet.TechType + " - ignoring."); return; } MethodInfo onCraftingBegin = typeof(Crafter).GetMethod("OnCraftingBegin", BindingFlags.NonPublic | BindingFlags.Instance); Validate.NotNull(onCraftingBegin); onCraftingBegin.Invoke(crafter, new object[] { opTechType.Get(), packet.Duration }); //TODO: take into account latency for duration Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); GuidHelper.SetNewGuid(constructedObject, packet.ConstructedItemGuid); SetInteractiveChildrenGuids(constructedObject, packet.InteractiveChildIdentifiers); } else { Console.WriteLine("Could not find constructed object!"); } }
public void ConstructionComplete(GameObject gameObject) { Optional <string> newlyConstructedBaseGuid = Optional <string> .Empty(); Optional <object> opConstructedBase = TransientLocalObjectManager.Get(TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); if (opConstructedBase.IsPresent()) { GameObject constructedBase = (GameObject)opConstructedBase.Get(); newlyConstructedBaseGuid = Optional <string> .Of(GuidHelper.GetGuid(constructedBase)); } string guid = GuidHelper.GetGuid(gameObject); ConstructionCompleted constructionCompleted = new ConstructionCompleted(guid, newlyConstructedBaseGuid); packetSender.Send(constructionCompleted); }
public void ConstructionComplete(GameObject gameObject) { Optional <String> newlyConstructedBaseGuid = Optional <String> .Empty(); Optional <object> opConstructedBase = TransientLocalObjectManager.Get(TransientObjectType.BASE_GHOST_NEWLY_CONSTRUCTED_BASE_GAMEOBJECT); if (opConstructedBase.IsPresent()) { GameObject constructedBase = (GameObject)opConstructedBase.Get(); newlyConstructedBaseGuid = Optional <String> .Of(GuidHelper.GetGuid(constructedBase)); } Vector3 itemPosition = gameObject.transform.position; String guid = GuidHelper.GetGuid(gameObject); ConstructionCompleted constructionCompleted = new ConstructionCompleted(PlayerId, ApiHelper.Vector3(itemPosition), guid, newlyConstructedBaseGuid); Send(constructionCompleted); }
public static void Postfix(Constructable __instance) { /** * On base pieces we need to have special logic during deconstruction to transfer the id from the main * object to the ghost. This method will see if we have a stored LATEST_DECONSTRUCTED_BASE_PIECE_GUID * (set from deconstructor patch or incoming deconstruction packet). If we do, then we'll copy the id * to the new ghost. */ Optional <object> opId = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID); if (opId.IsPresent()) { TransientLocalObjectManager.Add(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE_GUID, null); NitroxId id = (NitroxId)opId.Get(); Log.Info("Setting ghost id via Constructable_SetState_Patch " + id); NitroxEntity.SetNewId(__instance.gameObject, id); } }
public void ConstructorBeginCrafting(GameObject constructor, TechType techType, float duration) { String constructorGuid = GuidHelper.GetGuid(constructor); Console.WriteLine("Building item from constructor with uuid: " + constructorGuid); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); String constructedObjectGuid = GuidHelper.GetGuid(constructedObject); ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(PlayerId, constructorGuid, constructedObjectGuid, ApiHelper.TechType(techType), duration); Send(beginCrafting); } else { Console.WriteLine("Could not send packet because there wasn't a corresponding constructed object!"); } }
public static void Prefix(BaseGhost __instance) { // Null out fields that will be used for storing state TransientLocalObjectManager.Remove(TransientObjectType.LATEST_BASE_WITH_NEW_CONSTRUCTION); TransientLocalObjectManager.Remove(TransientObjectType.LATEST_BASE_CELL_WITH_NEW_CONSTRUCTION); // In this case, our piece is part of an existing, larger base. We'll record the base and offset. // We don't directly record the piece as it will be re-built when the base rebuilds geometry (this // happens each time a piece is built, subnautica destroys all others and replaces them). if (__instance.TargetBase != null) { Log.Debug("Placed BaseGhost is a new piece of an existing base"); TransientLocalObjectManager.Add(TransientObjectType.LATEST_BASE_WITH_NEW_CONSTRUCTION, __instance.TargetBase); TransientLocalObjectManager.Add(TransientObjectType.LATEST_BASE_CELL_WITH_NEW_CONSTRUCTION, __instance.TargetOffset); } else { Log.Debug("Placed BaseGhost is the first piece of a new base."); } }
public void BeginCrafting(GameObject constructor, TechType techType, float duration) { string constructorGuid = GuidHelper.GetGuid(constructor); Log.Debug("Building item from constructor with uuid: " + constructorGuid); Optional <object> opConstructedObject = TransientLocalObjectManager.Get(TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT); if (opConstructedObject.IsPresent()) { GameObject constructedObject = (GameObject)opConstructedObject.Get(); List <InteractiveChildObjectIdentifier> childIdentifiers = VehicleChildObjectIdentifierHelper.ExtractGuidsOfInteractiveChildren(constructedObject); string constructedObjectGuid = GuidHelper.GetGuid(constructedObject); ConstructorBeginCrafting beginCrafting = new ConstructorBeginCrafting(constructorGuid, constructedObjectGuid, techType, duration, childIdentifiers, constructedObject.transform.position, constructedObject.transform.rotation); packetSender.Send(beginCrafting); } else { Log.Error("Could not send packet because there wasn't a corresponding constructed object!"); } }
private void ConstructionAmountChanged(ConstructionAmountChangedEvent amountChanged) { Log.Info("Processing ConstructionAmountChanged " + amountChanged.Guid + " " + amountChanged.Amount); GameObject constructing = GuidHelper.RequireObjectFrom(amountChanged.Guid); BaseDeconstructable baseDeconstructable = constructing.GetComponent <BaseDeconstructable>(); // Bases don't send a deconstruct being packet. Instead, we just make sure // that if we are changing the amount that we set it into deconstruction mode // if it still has a BaseDeconstructable object on it. if (baseDeconstructable != null) { baseDeconstructable.Deconstruct(); // After we have begun the deconstructing for a base piece, we need to transfer the guid Optional <object> opGhost = TransientLocalObjectManager.Get(TransientObjectType.LATEST_DECONSTRUCTED_BASE_PIECE); if (opGhost.IsPresent()) { GameObject ghost = (GameObject)opGhost.Get(); UnityEngine.Object.Destroy(constructing); GuidHelper.SetNewGuid(ghost, amountChanged.Guid); } else { Log.Info("Could not find newly created ghost to set deconstructed guid "); } } else { Constructable constructable = constructing.GetComponentInChildren <Constructable>(); constructable.constructedAmount = amountChanged.Amount; using (packetSender.Suppress <ConstructionAmountChanged>()) { constructable.Construct(); } } }