Ejemplo n.º 1
0
        public NWPlaceable SpawnStructure(NWArea area, Guid pcBaseStructureID)
        {
            PCBaseStructure pcStructure   = _data.Get <PCBaseStructure>(pcBaseStructureID);
            PCBase          pcBase        = _data.Get <PCBase>(pcStructure.PCBaseID);
            BaseStructure   baseStructure = _data.Get <BaseStructure>(pcStructure.BaseStructureID);
            var             exteriorStyle = _data.Get <BuildingStyle>(pcStructure.ExteriorStyleID);

            NWLocation location = _.Location(area.Object,
                                             _.Vector((float)pcStructure.LocationX, (float)pcStructure.LocationY, (float)pcStructure.LocationZ),
                                             (float)pcStructure.LocationOrientation);

            BaseStructureType structureType = (BaseStructureType)baseStructure.BaseStructureTypeID;
            string            resref        = baseStructure.PlaceableResref;

            List <AreaStructure> areaStructures = area.Data["BASE_SERVICE_STRUCTURES"];

            if (string.IsNullOrWhiteSpace(resref) &&
                structureType == BaseStructureType.Building)
            {
                resref = exteriorStyle.Resref;
            }

            NWPlaceable plc = (_.CreateObject(OBJECT_TYPE_PLACEABLE, resref, location));

            plc.SetLocalString("PC_BASE_STRUCTURE_ID", pcStructure.ID.ToString());
            plc.SetLocalInt("REQUIRES_BASE_POWER", baseStructure.RequiresBasePower ? 1 : 0);
            plc.SetLocalString("ORIGINAL_SCRIPT_CLOSED", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_CLOSED));
            plc.SetLocalString("ORIGINAL_SCRIPT_DAMAGED", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_DAMAGED));
            plc.SetLocalString("ORIGINAL_SCRIPT_DEATH", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_DEATH));
            plc.SetLocalString("ORIGINAL_SCRIPT_HEARTBEAT", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_HEARTBEAT));
            plc.SetLocalString("ORIGINAL_SCRIPT_INVENTORYDISTURBED", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_INVENTORYDISTURBED));
            plc.SetLocalString("ORIGINAL_SCRIPT_LOCK", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_LOCK));
            plc.SetLocalString("ORIGINAL_SCRIPT_MELEEATTACKED", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_MELEEATTACKED));
            plc.SetLocalString("ORIGINAL_SCRIPT_OPEN", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_OPEN));
            plc.SetLocalString("ORIGINAL_SCRIPT_SPELLCASTAT", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_SPELLCASTAT));
            plc.SetLocalString("ORIGINAL_SCRIPT_UNLOCK", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_UNLOCK));
            plc.SetLocalString("ORIGINAL_SCRIPT_USED", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_USED));
            plc.SetLocalString("ORIGINAL_SCRIPT_USER_DEFINED_EVENT", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_USER_DEFINED_EVENT));
            plc.SetLocalString("ORIGINAL_SCRIPT_LEFT_CLICK", _.GetEventScript(plc.Object, EVENT_SCRIPT_PLACEABLE_ON_LEFT_CLICK));
            plc.SetLocalString("ORIGINAL_JAVA_SCRIPT_1", _.GetLocalString(plc.Object, "JAVA_SCRIPT_1"));

            NWPlaceable door = null;

            if (structureType == BaseStructureType.Building)
            {
                door = SpawnBuildingDoor(exteriorStyle.DoorRule, plc);
                areaStructures.Add(new AreaStructure(pcStructure.PCBaseID, pcStructure.ID, door, false, null));
            }
            areaStructures.Add(new AreaStructure(pcStructure.PCBaseID, pcStructure.ID, plc, true, door));

            if (area.IsInstance && area.GetLocalInt("PC_BASE_STRUCTURE_ID") > 0)
            {
                if (DateTime.UtcNow > pcBase.DateFuelEnds && pcBase.Fuel <= 0)
                {
                    ToggleInstanceObjectPower(area, false);
                }
            }

            return(plc);
        }
Ejemplo n.º 2
0
        private void DoRetrieveStructure()
        {
            var               data           = _base.GetPlayerTempData(GetPC());
            PCBaseStructure   structure      = _data.Get <PCBaseStructure>(data.ManipulatingStructure.PCBaseStructureID);
            BaseStructure     baseStructure  = _data.Get <BaseStructure>(structure.BaseStructureID);
            PCBase            pcBase         = _data.Get <PCBase>(structure.PCBaseID);
            BaseStructureType structureType  = (BaseStructureType)baseStructure.BaseStructureTypeID;
            var               tempStorage    = _.GetObjectByTag("TEMP_ITEM_STORAGE");
            var               pcStructureID  = structure.ID;
            int               impoundedCount = 0;

            var controlTower = _base.GetBaseControlTower(pcBase.ID);
            int maxShields   = _base.CalculateMaxShieldHP(controlTower);

            if (pcBase.ShieldHP < maxShields && structureType != BaseStructureType.ControlTower)
            {
                GetPC().FloatingText("You cannot retrieve any structures because the control tower has less than 100% shields.");
                return;
            }

            bool canRetrieveStructures;

            if (data.BuildingType == Enumeration.BuildingType.Exterior ||
                data.BuildingType == Enumeration.BuildingType.Apartment)
            {
                canRetrieveStructures = _perm.HasBasePermission(GetPC(), data.ManipulatingStructure.PCBaseID, BasePermission.CanRetrieveStructures);
            }
            else if (data.BuildingType == Enumeration.BuildingType.Interior)
            {
                var structureID = new Guid(data.ManipulatingStructure.Structure.Area.GetLocalString("PC_BASE_STRUCTURE_ID"));
                canRetrieveStructures = _perm.HasStructurePermission(GetPC(), structureID, StructurePermission.CanRetrieveStructures);
            }
            else
            {
                throw new Exception("BaseManagementTool -> DoRetrieveStructure: Cannot handle building type " + data.BuildingType);
            }

            if (!canRetrieveStructures)
            {
                GetPC().FloatingText("You don't have permission to retrieve structures.");
                return;
            }


            if (structureType == BaseStructureType.ControlTower)
            {
                var structureCount = _data.GetAll <PCBaseStructure>().Count(x => x.PCBaseID == structure.PCBaseID);

                if (structureCount > 1)
                {
                    GetPC().FloatingText("You must remove all structures in this sector before picking up the control tower.");
                    return;
                }
            }
            else if (structureType == BaseStructureType.Building)
            {
                var childStructures = _data.Where <PCBaseStructure>(x => x.ParentPCBaseStructureID == structure.ID).ToList();
                for (int x = childStructures.Count - 1; x >= 0; x--)
                {
                    var    furniture     = childStructures.ElementAt(x);
                    NWItem furnitureItem = _base.ConvertStructureToItem(furniture, tempStorage);
                    _impound.Impound(GetPC().GlobalID, furnitureItem);
                    furnitureItem.Destroy();

                    _data.SubmitDataChange(furniture, DatabaseActionType.Delete);
                    impoundedCount++;
                }
            }

            _base.ConvertStructureToItem(structure, GetPC());
            _data.SubmitDataChange(structure, DatabaseActionType.Delete);
            data.ManipulatingStructure.Structure.Destroy();

            // Impound any fuel that's over the limit.
            if (structureType == BaseStructureType.StronidiumSilo || structureType == BaseStructureType.FuelSilo)
            {
                int maxFuel           = _base.CalculateMaxFuel(pcBase.ID);
                int maxReinforcedFuel = _base.CalculateMaxReinforcedFuel(pcBase.ID);

                if (pcBase.Fuel > maxFuel)
                {
                    int    returnAmount = pcBase.Fuel - maxFuel;
                    NWItem refund       = _.CreateItemOnObject("fuel_cell", tempStorage, returnAmount);
                    pcBase.Fuel = maxFuel;
                    _impound.Impound(pcBase.PlayerID, refund);
                    GetPC().SendMessage("Excess fuel cells have been impounded by the planetary government. The owner of the base will need to retrieve it.");
                    refund.Destroy();
                }

                if (pcBase.ReinforcedFuel > maxReinforcedFuel)
                {
                    int    returnAmount = pcBase.ReinforcedFuel - maxReinforcedFuel;
                    NWItem refund       = _.CreateItemOnObject("stronidium", tempStorage, returnAmount);
                    pcBase.ReinforcedFuel = maxReinforcedFuel;
                    _impound.Impound(pcBase.PlayerID, refund);
                    GetPC().SendMessage("Excess stronidium units have been impounded by the planetary government. The owner of the base will need to retrieve it.");
                    refund.Destroy();
                }
            }
            else if (structureType == BaseStructureType.ResourceSilo)
            {
                int maxResources = _base.CalculateResourceCapacity(pcBase.ID);
                var items        = _data.Where <PCBaseStructureItem>(x => x.PCBaseStructureID == controlTower.ID).ToList();

                while (items.Count > maxResources)
                {
                    var item = items.ElementAt(0);

                    var impoundItem = new PCImpoundedItem
                    {
                        PlayerID      = pcBase.PlayerID,
                        ItemResref    = item.ItemResref,
                        ItemObject    = item.ItemObject,
                        DateImpounded = DateTime.UtcNow,
                        ItemName      = item.ItemName,
                        ItemTag       = item.ItemTag
                    };

                    _data.SubmitDataChange(impoundItem, DatabaseActionType.Insert);
                    GetPC().SendMessage(item.ItemName + " has been impounded by the planetary government because your base ran out of space to store resources. The owner of the base will need to retrieve it.");
                    _data.SubmitDataChange(item, DatabaseActionType.Delete);
                }
            }

            // Update the cache
            List <AreaStructure> areaStructures = data.TargetArea.Data["BASE_SERVICE_STRUCTURES"];
            var records = areaStructures.Where(x => x.PCBaseStructureID == pcStructureID).ToList();

            for (int x = records.Count() - 1; x >= 0; x--)
            {
                var record = records[x];
                record.ChildStructure?.Destroy();
                areaStructures.Remove(record);
            }

            EndConversation();

            if (impoundedCount > 0)
            {
                GetPC().FloatingText(impoundedCount + " item(s) were sent to the planetary impound.");
            }
        }