示例#1
0
    void Interact()
    {
        Collider2D hitComponent = Physics2D.OverlapCircle(transform.position, interactRadius, shipComponentsMasks);

        if (hitComponent == null)
        {
            return;
        }

        ShipComponent shipComponent = hitComponent.GetComponent <ShipComponent>();

        if (shipComponent == null)
        {
            Debug.LogWarning($"Player interacted with object {hitComponent.name} but it did not have a ShipComponent attached to it.");
            return;
        }

        shipComponent.Interact();
        BreakableComponent breakable = shipComponent.GetComponent <BreakableComponent>();

        if (breakable)
        {
            progressBar.gameObject.SetActive(true);
        }
        focus = shipComponent;
    }
示例#2
0
        private static void InspectBreakableComponent(BreakableComponent component)
        {
            InspectReportComponentBase(component);

            Console.WriteLine($"CanBreak: {component.CanBreak}");
            Console.WriteLine($"BreakTo: {component.BreakTo}");
        }
        public void Interact()
        {
            _previousState = _currentState;
            _currentState  = Mouse.GetState();
            if (_focus != null)
            {
                float distance = Vector2.Distance(_position, _focus.GetPosition());
                if (distance > interactRad)
                {
                    // If player is too far from the Interactable Object (ie. ShipComponent)
                    // then cancel current action and reset focus to a null value to prevent it from being interacted again from a distance
                    _focus.Cancel();
                    _focus = null;
                    _fixProgress.SetActive(false);
                    return;
                }

                BreakableComponent b = _focus as BreakableComponent;

                if (_currentState.LeftButton == ButtonState.Released && _previousState.LeftButton == ButtonState.Pressed)
                {
                    if (b != null)
                    {
                        if (b.IsBroken())
                        {
                            Item item = _inventory.items.Find(i => i.itemType == b.GetRequiredItem());
                            if (item == null)
                            {
                                return;
                            }
                            _fixProgress.SetActive(true);
                        }
                    }
                    _focus.Interact();
                }

                if (b != null)
                {
                    _fixProgress.UpdateProgress(b.GetFixProgress());
                }
            }
        }
示例#4
0
    void UpdatePlayer()
    {
        if (Input.GetButtonDown("Fire1"))
        {
            Interact();
        }

        // If Player is interacting with a ShipComponent object
        if (focus)
        {
            BreakableComponent breakable = focus.GetComponent <BreakableComponent>();
            if (breakable)
            {
                float progress = breakable.GetProgress();
                progressBar.SetProgress(progress);
            }

            // Check if it's too far away and cancel current progress
            if (Vector2.Distance(focus.transform.position, transform.position) > 1f)
            {
                if (breakable)
                {
                    progressBar.SetProgress(0f);
                    progressBar.gameObject.SetActive(false);
                }
                focus.Cancel();
                focus = null;
            }
        }

        if (!o2Active)
        {
            o2Current -= o2Multiplier * Time.deltaTime;
        }
        o2Bar.SetProgress(o2Current / o2TotalCapacity);
    }
示例#5
0
        private void GenerateShipObjects()
        {
            TiledMapObject[] objects = _tiledMap.GetLayer <TiledMapObjectLayer>("Breakables").Objects;

            // Loops through Objects created in Tiled
            foreach (TiledMapObject obj in objects)
            {
                // Default asset for this object. Defined by Custom Property called 'sprite' in Tiled
                if (!obj.Properties.TryGetValue("sprite", out string assetName))
                {
                    continue;
                }
                // Load sprite with given asset path/name
                Sprite sprite = new Sprite(_game.Content.Load <Texture2D>(assetName));

                // Some sprites have a broken representation of them (ie Hull and O2 Vent).
                // So we should attempt to load a broken representation of this asset if at specified in Tiled Custom Property 'broken_sprite'
                // The BreakableComponent class should also cater for and skip 'null' BrokenSprites where applicable
                Sprite brokenSprite = null;
                if (obj.Properties.TryGetValue("broken_sprite", out string brokenAssetName))
                {
                    brokenSprite = new Sprite(_game.Content.Load <Texture2D>(brokenAssetName));
                }

                string type = string.Empty;
                // If no valid Custom Property called 'item' is set for the required item, default it to screwdriver.
                // This is to ensure that the gameplay can flow as expected.
                if (!obj.Properties.TryGetValue("item", out type))
                {
                    type = "screwdriver";
                }

                // Parse 'type' to Enum of 'ItemType'. Assumes a valid entry.
                ItemType item = (ItemType)Enum.Parse(typeof(ItemType), type, true);

                Vector2 pos = Vector2.Zero;
                pos.X = obj.Position.X + sprite.Origin.X;
                pos.Y = obj.Position.Y + sprite.Origin.Y;

                BreakableComponent b = new BreakableComponent(sprite, pos, item, obj.Name, brokenSprite);
                switch (obj.Type)
                {
                case "O2Component":
                    b.OnComponentActivated += TurnOffO2;
                    b.OnComponentFixed     += TurnOnO2;
                    break;

                case "Medbay":
                    Medbay m = new Medbay(sprite, pos, item, obj.Name, brokenSprite);
                    m.OnComponentInteracted += HealPlayer;
                    b = m;
                    break;

                case "Shield":
                    b.OnComponentActivated += TurnOffShield;
                    b.OnComponentFixed     += TurnOnShield;
                    break;

                case "GravityGenerator":
                    b.OnComponentActivated += TurnOffGravity;
                    b.OnComponentFixed     += TurnOnGravity;
                    break;

                case "Hull":
                    Hull h = new Hull(sprite, pos, item, obj.Name, brokenSprite);
                    b = h;
                    break;
                }
                if (b != null)
                {
                    _entities.Add(b);
                }
            }
        }
示例#6
0
        /// <inheritdoc/>
        public override bool Break(BreakableComponent breakTo)
        {
            if (Rows.Count == 0)
            {
                return(true);
            }
            if (Height < Rows[0].Height && !Rows[0].CanBreak)
            {
                return(false);
            }
            TableBase tableTo = breakTo as TableBase;

            if (tableTo == null)
            {
                return(true);
            }

            // find the break row index
            int   breakRowIndex    = 0;
            int   breakRowIndexAdd = 0;
            bool  rowBroken        = false;
            float rowsHeight       = 0;

            while (breakRowIndex < Rows.Count)
            {
                rowsHeight += Rows[breakRowIndex].Height;
                if (rowsHeight > Height)
                {
                    float breakRowHeight = Rows[breakRowIndex].Height - (rowsHeight - Height);
                    if (CanBreakRow(breakRowIndex, breakRowHeight))
                    {
                        BreakRow(tableTo, breakRowIndex, breakRowHeight, rowsHeight - Height);
                        breakRowIndexAdd = 1;
                        rowBroken        = true;
                    }
                    break;
                }

                breakRowIndex++;
            }

            // get the span list
            List <Rectangle> spans = GetSpanList();

            // break the spans
            foreach (Rectangle span in spans)
            {
                if (span.Top < breakRowIndex + breakRowIndexAdd && span.Bottom > breakRowIndex)
                {
                    TableCell cell   = this[span.Left, span.Top];
                    TableCell cellTo = tableTo[span.Left, span.Top];

                    // update cell spans
                    cell.RowSpan   = breakRowIndex + breakRowIndexAdd - span.Top;
                    cellTo.RowSpan = span.Bottom - breakRowIndex;

                    // break the cell
                    if (!rowBroken && !cell.Break(cellTo))
                    {
                        cell.Text = "";
                    }

                    // set the top span cell to the correct place
                    tableTo[span.Left, span.Top]      = new TableCell();
                    tableTo[span.Left, breakRowIndex] = cellTo;
                }
            }

            // remove unused rows from source (this table)
            while (breakRowIndex + breakRowIndexAdd < Rows.Count)
            {
                this.Rows.RemoveAt(Rows.Count - 1);
            }

            // remove unused rows from copy (tableTo)
            for (int i = 0; i < breakRowIndex; i++)
            {
                tableTo.Rows.RemoveAt(0);
            }

            return(true);
        }
示例#7
0
        /// <inheritdoc/>
        public override bool Break(BreakableComponent breakTo)
        {
            if (Rows.Count == 0)
            {
                return(true);
            }
            if (Height < Rows[0].Height)
            {
                return(false);
            }
            TableBase tableTo = breakTo as TableBase;

            if (tableTo == null)
            {
                return(true);
            }

            // get the span list
            List <Rectangle> spans = GetSpanList();

            // find the break row index
            int   breakRowIndex = 0;
            float rowsHeight    = 0;

            while (breakRowIndex < Rows.Count && rowsHeight + Rows[breakRowIndex].Height < Height)
            {
                rowsHeight += Rows[breakRowIndex].Height;
                breakRowIndex++;
            }

            // break the spans
            foreach (Rectangle span in spans)
            {
                if (span.Top < breakRowIndex && span.Bottom > breakRowIndex)
                {
                    TableCell cell   = this[span.Left, span.Top];
                    TableCell cellTo = tableTo[span.Left, span.Top];

                    // update cell spans
                    cell.RowSpan   = breakRowIndex - span.Top;
                    cellTo.RowSpan = span.Bottom - breakRowIndex;

                    // break the cell
                    if (!cell.Break(cellTo))
                    {
                        cell.Text = "";
                    }
                    tableTo[span.Left, span.Top]      = new TableCell();
                    tableTo[span.Left, breakRowIndex] = cellTo;
                }
            }

            // delete last rows until all rows fit
            while (breakRowIndex < Rows.Count)
            {
                Rows.RemoveAt(Rows.Count - 1);
            }

            // delete first rows of the breakTo
            for (int i = 0; i < breakRowIndex; i++)
            {
                tableTo.Rows.RemoveAt(0);
            }

            return(true);
        }