private IEnumerator GetItemsContainer(string slotName)
        {
            //BZLogger.Log($"[SeamothArms] GetItemsContainer coroutine started for this SeaTruck: {helper.GetInstanceID()}");

            while (container == null)
            {
                container = TruckHelper.GetSeamothStorageInSlot(TruckHelper.GetSlotIndex(slotName), SeaTruckTorpedoArm_Prefab.TechTypeID);

                //BZLogger.Log($"[SeamothArms] ItemsContainer is not ready for this SeaTruck: {helper.GetInstanceID()}");
                yield return(null);
            }

            //BZLogger.Log($"[SeamothArms] ItemsContainer is ready for this SeaTruck: {helper.GetInstanceID()}");
            //BZLogger.Log($"[SeamothArms] GetItemsContainer coroutine stopped for this SeaTruck: {helper.GetInstanceID()}");

            if (container != null)
            {
                container.SetAllowedTechTypes(GetTorpedoTypes());
                container.onAddItem    += OnAddItem;
                container.onRemoveItem += OnRemoveItem;
                UpdateVisuals();
            }

            yield break;
        }
Beispiel #2
0
        public void Should_Return_Package_With_One_Cargo()
        {
            var truck = TruckHelper.GetTestTruck();

            _managerMock.Setup(x => x.GetPrioritisedCargos(truck.Volume, truck.Payload))
            .Returns(CargoHelper.GetBigWeightList);
            _configurationMock.Setup(c => c.FillThreshold).Returns(10);
            _configurationMock.Setup(c => c.Strategy).Returns(OptimizationStrategy.Weight);

            var pack = _service.LoadTruck(truck);

            Assert.AreEqual(1, pack.Cargos.Count);
        }
        public void Should_Return_Pack_With_Warnings(int fillThreshold, int warningCount)
        {
            var truck = TruckHelper.GetTestTruck();

            _managerMock.Setup(x => x.GetPrioritisedCargos(truck.Volume, truck.Payload))
            .Returns(CargoHelper.GetBigVolumeList);
            _managerMock.Setup(x => x.GetNonPrioritisedCargos(truck.Volume, truck.Payload))
            .Returns(CargoHelper.GetBigVolumeList);
            _configurationMock.Setup(c => c.FillThreshold).Returns(fillThreshold);

            var pack = _packager.PackTruck(truck);

            Assert.AreEqual(warningCount, pack.Warnings.Count);
        }
        public void Should_Return_Pack_With_Three_Cargo()
        {
            var truck = TruckHelper.GetTestTruck();

            _managerMock.Setup(x => x.GetPrioritisedCargos(truck.Volume, truck.Payload))
            .Returns(CargoHelper.GetPrioritisedCargoes);
            _managerMock.Setup(x => x.GetNonPrioritisedCargos(truck.Volume, truck.Payload))
            .Returns(CargoHelper.GetBigVolumeList);
            _configurationMock.Setup(c => c.FillThreshold).Returns(10);

            var pack = _packager.PackTruck(truck);

            Assert.AreEqual(3, pack.Cargos.Count);
        }
        private bool TryUse(out float cooldownDuration)
        {
            if (Time.time - timeUsed >= cooldownTime)
            {
                Pickupable pickupable = null;
                PickPrefab x          = null;

                GameObject activeTarget = ArmServices.main.GetActiveTarget(TruckHelper.MainCab);

                if (activeTarget)
                {
                    pickupable = activeTarget.GetComponent <Pickupable>();
                    x          = activeTarget.GetComponent <PickPrefab>();
                }

                if (pickupable != null && pickupable.isPickupable)
                {
                    if (TruckHelper.HasRoomForItem(pickupable))
                    {
                        animator.SetTrigger("use_tool");
                        cooldownTime            = (cooldownDuration = cooldownPickup);
                        shownNoRoomNotification = false;
                        return(true);
                    }
                    if (!shownNoRoomNotification)
                    {
                        ErrorMessage.AddDebug(Language.main.Get("ContainerCantFit"));
                        shownNoRoomNotification = true;
                    }
                }
                else
                {
                    if (x != null)
                    {
                        animator.SetTrigger("use_tool");
                        cooldownTime = (cooldownDuration = cooldownPickup);
                        return(true);
                    }

                    animator.SetTrigger("bash");
                    cooldownTime = (cooldownDuration = cooldownPunch);
                    fxControl.Play(0);
                    return(true);
                }
            }

            cooldownDuration = 0f;
            return(false);
        }
        public void OnHit()
        {
            if (TruckHelper.IsPiloted())
            {
                Vector3    position     = default(Vector3);
                GameObject targetObject = null;

                UWE.Utils.TraceFPSTargetPosition(TruckHelper.MainCab, 6.5f, ref targetObject, ref position, out Vector3 normal, true);

                if (targetObject == null)
                {
                    InteractionVolumeUser component = Player.main.gameObject.GetComponent <InteractionVolumeUser>();

                    if (component != null && component.GetMostRecent() != null)
                    {
                        targetObject = component.GetMostRecent().gameObject;
                    }
                }
                if (targetObject)
                {
                    LiveMixin liveMixin = targetObject.FindAncestor <LiveMixin>();

                    if (liveMixin)
                    {
                        bool flag = liveMixin.IsAlive();
                        liveMixin.TakeDamage(50f, position, DamageType.Normal, null);
                        Utils.PlayFMODAsset(hitFishSound, front, 50f);
                    }
                    else
                    {
                        Utils.PlayFMODAsset(hitTerrainSound, front, 50f);
                    }

                    VFXSurface component2 = targetObject.GetComponent <VFXSurface>();

                    Vector3 euler = MainCameraControl.main.transform.eulerAngles + new Vector3(300f, 90f, 0f);

                    VFXSurfaceTypeManager.main.Play(component2, vfxEventType, position, Quaternion.Euler(euler), TruckHelper.MainCab.transform);

                    targetObject.SendMessage("BashHit", this, SendMessageOptions.DontRequireReceiver);
                }
            }
        }
        private IEnumerator OnPickupAsync(Pickupable pickupable, PickPrefab pickPrefab)
        {
            ItemsContainer container = TruckHelper.GetRoomForItem(pickupable);

            if (pickupable != null && pickupable.isPickupable && container != null)
            {
                pickupable.Initialize();
                InventoryItem item = new InventoryItem(pickupable);
                container.UnsafeAdd(item);
                Utils.PlayFMODAsset(pickupSound, front, 5f);
            }
            else if (pickPrefab != null)
            {
                TaskResult <bool> result = new TaskResult <bool>();
                yield return(pickPrefab.AddToContainerAsync(container, result));

                if (result.Get())
                {
                    pickPrefab.SetPickedUp();
                }
                result = null;
            }
            yield break;
        }
Beispiel #8
0
        public void OnHit()
        {
#if DEBUG
            if (true)
#else
            if (TruckHelper.IsPiloted())
#endif
            {
                Vector3    pos       = Vector3.zero;
                GameObject hitObject = null;
                drillTarget = null;

                UWE.Utils.TraceFPSTargetPosition(TruckHelper.MainCab, attackDist, ref hitObject, ref pos, out Vector3 normal, true);

                if (hitObject == null)
                {
                    InteractionVolumeUser component = Player.main.gameObject.GetComponent <InteractionVolumeUser>();

                    if (component != null && component.GetMostRecent() != null)
                    {
                        hitObject = component.GetMostRecent().gameObject;
                    }
                }
                if (hitObject && drilling)
                {
                    var drillable = hitObject.FindAncestor <SeaTruckDrillable>();

                    loopHit.Play();

                    if (drillable)
                    {
                        drillable.OnDrill(fxSpawnPoint.position, TruckHelper, out GameObject gameObject2);

                        if (!gameObject2)
                        {
                            StopEffects();
                        }

                        drillTarget = gameObject2;

                        if (fxControl.emitters[0].fxPS != null && !fxControl.emitters[0].fxPS.emission.enabled)
                        {
                            fxControl.Play(0);
                        }
                    }
                    else
                    {
                        LiveMixin liveMixin = hitObject.FindAncestor <LiveMixin>();

                        if (liveMixin)
                        {
                            bool flag = liveMixin.IsAlive();
                            liveMixin.TakeDamage(4f, pos, DamageType.Drill, null);
                            drillTarget = hitObject;
                        }

                        VFXSurface component2 = hitObject.GetComponent <VFXSurface>();

                        if (drillFXinstance == null)
                        {
                            drillFXinstance = VFXSurfaceTypeManager.main.Play(component2, vfxEventType, fxSpawnPoint.position, fxSpawnPoint.rotation, fxSpawnPoint);
                        }
                        else if (component2 != null && prevSurfaceType != component2.surfaceType)
                        {
                            VFXLateTimeParticles component3 = drillFXinstance.GetComponent <VFXLateTimeParticles>();
                            component3.Stop();
                            Destroy(drillFXinstance.gameObject, 1.6f);
                            drillFXinstance = VFXSurfaceTypeManager.main.Play(component2, vfxEventType, fxSpawnPoint.position, fxSpawnPoint.rotation, fxSpawnPoint);
                            prevSurfaceType = component2.surfaceType;
                        }

                        hitObject.SendMessage("BashHit", this, SendMessageOptions.DontRequireReceiver);
                    }
                }
                else
                {
                    StopEffects();
                }
            }
        }