public override void ProcessEntity(AbstractEntity entity)
        {
            JonesTheCatComponent cat = (JonesTheCatComponent)entity.GetComponent(nameof(JonesTheCatComponent));

            if (cat == null)   // Are we a cat?
            {
                return;
            }
            CarryableComponent cc = (CarryableComponent)entity.GetComponent(nameof(CarryableComponent));

            if (cc.carrier != null)   // Don't move if we're bring carried
            {
                return;
            }
            MobDataComponent us = (MobDataComponent)entity.GetComponent(nameof(MobDataComponent));

            if (us.actionPoints <= 0)   // Only do stuff if we've got any APs
            {
                return;
            }

            MovementDataComponent mdc = (MovementDataComponent)entity.GetComponent(nameof(MovementDataComponent));

            if (mdc.route == null || mdc.route.Count == 0)
            {
                MovementSystem    ms  = (MovementSystem)this.ecs.GetSystem(nameof(MovementSystem));
                PositionComponent pos = (PositionComponent)entity.GetComponent(nameof(PositionComponent));
                Point             p   = ms.GetRandomAccessibleSquare();
                mdc.route = ms.GetAStarRoute(pos.x, pos.y, p.X, p.Y);
            }
        }
        public void PickupItem(AbstractEntity unit, AbstractEntity item, List <AbstractEntity> mapSquare)
        {
            MobDataComponent mdc = (MobDataComponent)unit.GetComponent(nameof(MobDataComponent));

            if (mdc == null || mdc.actionPoints > 0)
            {
                mdc.actionPoints -= 40;
                CanCarryComponent  ccc = (CanCarryComponent)unit.GetComponent(nameof(CanCarryComponent));
                CarryableComponent cc  = (CarryableComponent)item.GetComponent(nameof(CarryableComponent));
                // todo - check weight etc...
                ccc.AddItem(item);
                cc.carrier = unit;
                mapSquare.Remove(item);
            }
        }
        private void ListItemsInInv()
        {
            this.menuItemList.Clear();
            int idx = 1;
            CanCarryComponent ccc = (CanCarryComponent)this.currentUnit.GetComponent(nameof(CanCarryComponent));

            foreach (var e in ccc.GetItems())
            {
                CarryableComponent cc = (CarryableComponent)e.GetComponent(nameof(CarryableComponent));
                if (cc != null)
                {
                    this.menuItemList.Add(idx, e);
                    idx++;
                }
            }
        }
        private void ListItemsOnFloor()
        {
            this.menuItemList.Clear();
            int idx = 1;
            PositionComponent     pos   = (PositionComponent)this.currentUnit.GetComponent(nameof(PositionComponent));
            List <AbstractEntity> items = this.mapData.map[pos.x, pos.y];

            foreach (var e in items)
            {
                CarryableComponent cc = (CarryableComponent)e.GetComponent(nameof(CarryableComponent));
                if (cc != null)
                {
                    this.menuItemList.Add(idx, e);
                    idx++;
                }
            }
        }
        public static PositionComponent GetPosition(AbstractEntity entity)
        {
            // Check if it is being carried
            CarryableComponent cc = (CarryableComponent)entity.GetComponent(nameof(CarryableComponent));

            if (cc != null)
            {
                if (cc.carrier != null)
                {
                    PositionComponent pos = (PositionComponent)cc.carrier.GetComponent(nameof(PositionComponent));
                    return(pos);
                }
            }

            // Get our own position
            PositionComponent sqpos = (PositionComponent)entity.GetComponent(nameof(PositionComponent));

            return(sqpos);
        }
        public void DropItem(AbstractEntity unit, AbstractEntity item, List <AbstractEntity> mapSquare)
        {
            MobDataComponent mdc = (MobDataComponent)unit.GetComponent(nameof(MobDataComponent));

            if (mdc == null || mdc.actionPoints > 0)
            {
                mdc.actionPoints -= 20;
                CanCarryComponent  ccc     = (CanCarryComponent)unit.GetComponent(nameof(CanCarryComponent));
                PositionComponent  unitpos = (PositionComponent)item.GetComponent(nameof(PositionComponent));
                PositionComponent  itempos = (PositionComponent)item.GetComponent(nameof(PositionComponent));
                CarryableComponent cc      = (CarryableComponent)item.GetComponent(nameof(CarryableComponent));
                if (ccc.GetItems().Contains(item))
                {
                    ccc.RemoveItem(item);
                    cc.carrier = null;
                    mapSquare.Add(item);
                    itempos.x = unitpos.x;
                    itempos.y = unitpos.y;
                }
            }
        }
Beispiel #7
0
    void Update()
    {
        if (cam == null)
        {
            cam = Camera.main; // sometimes null for a few cycles
            if (cam != null && cam.tag == "DeathCamera")
            {
                cam = null;
            }
        }
        if (cam == null)
        {
            return; // sometimes null for a few cycles
        }
        RaycastHit hit;
        bool       setAxes = false;

        for (int i = 0; i < Input.touchCount; i++)
        {
            Touch touch = Input.GetTouch(i);
            if (touch.phase == TouchPhase.Began &&
                !EventSystem.current.IsPointerOverGameObject(touch.fingerId) &&
                GUIPanel.PanelContainingPoint(touch.position) == null)
            {
                if (touchedTapComponent != null)
                {
                    touchedTapComponent.TapEnd();
                    touchedTapComponent = null;
                }
                lookTouchId    = touch.fingerId;
                lookTouchStart = touch.position;

                if (TapRaycast(touch.position, out hit))
                {
                    TapComponent hitTapComponent = hit.transform.GetComponent <TapComponent>();
                    if (hitTapComponent != null && hit.distance <= hitTapComponent.maxDistance)
                    {
                        touchedTapComponent = hitTapComponent;
                        touchedTapComponent.TapStart(PlayerComponent.instance);
                    }
                }
            }
            // don't move joystick and camera with same touch
            if (lookTouchId == joystick.dragTouchId)
            {
                lookTouchId = -1;
                if (touchedTapComponent != null)
                {
                    touchedTapComponent.TapEnd();
                    touchedTapComponent = null;
                }
            }
            if (touch.fingerId == lookTouchId)
            {
                setAxes = true;
                hAxis.Update(touch.deltaPosition.x * 150f / cam.pixelHeight);
                vAxis.Update(touch.deltaPosition.y * 150f / cam.pixelHeight);
                if ((touch.phase == TouchPhase.Moved || touch.phase == TouchPhase.Stationary) &&
                    touchedTapComponent != null)
                {
                    // check for early cancel (tap left component)
                    if (TapRaycast(touch.position, out hit))
                    {
                        TapComponent hitTapComponent = hit.transform.GetComponent <TapComponent>();
                        if (hitTapComponent != touchedTapComponent || hit.distance > touchedTapComponent.maxDistance)
                        {
                            touchedTapComponent.TapEnd();
                            touchedTapComponent = null;
                        }
                    }
                    else
                    {
                        touchedTapComponent.TapEnd();
                        touchedTapComponent = null;
                    }
                }
                if (touch.phase == TouchPhase.Ended && touchedTapComponent != null)
                {
                    touchedTapComponent.TapEnd();
                    touchedTapComponent = null;
                }
                if (touch.phase == TouchPhase.Ended &&
                    (touch.position - lookTouchStart).magnitude / GUIPanel.scaleFactor < DRAG_THRESHOLD)
                {
                    if (TapRaycast(touch.position, out hit))
                    {
                        CarryableComponent hitCarryable = hit.transform.GetComponent <CarryableComponent>();
                        if (hitCarryable != null && hitCarryable.enabled)
                        {
                            if (hitCarryable.IsCarried())
                            {
                                hitCarryable.Throw(PlayerComponent.instance);
                            }
                            else if (hit.distance <= CARRY_DISTANCE)
                            {
                                if (carriedComponent != null && carriedComponent.IsCarried())
                                {
                                    carriedComponent.Drop();
                                }
                                hitCarryable.Carry(PlayerComponent.instance);
                                carriedComponent = hitCarryable;
                            }
                        }
                    }
                }
            }  // end if touch.fingerId == lookTouchId
        }
        if (!setAxes)
        {
            lookTouchId = -1;
            hAxis.Update(0);
            vAxis.Update(0);
        }
    }