public void Init(SelectableTarget target)
    {
        // Set up a singleton
        radialInstace = this;

        // Cache target
        this.target = target;

        mainCam            = GameController.Instance.mainCamera;
        transform.position = mainCam.WorldToScreenPoint(target.transform.position);

        // Init the buttons
        int buttonCount = buttonPrefabs.Length;

        buttonInstances = new RectTransform[buttonCount];

        float counterOffset = ((buttonCount - 1) * angle) / 2;

        // Spawn, set sprite and begin tracking buttons, lay out in radial menu by angle and count
        for (int i = 0; i < buttonCount; ++i)
        {
            Vector3 v = new Vector3(0, -pixelOffset, 0);
            v = Quaternion.Euler(0, 0, i * angle - counterOffset) * v;

            GameObject newButton = Instantiate(buttonPrefabs[i], transform);
            newButton.transform.localPosition = v;

            buttonInstances[i] = newButton.GetComponent <RectTransform>();
        }
    }
Esempio n. 2
0
        protected override void UpdateTargets(string tag, float range2)  //modules, selectableTargets must be at z=0;
        {
            GameObject[] targets = GameObject.FindGameObjectsWithTag(tag);
            int          count   = targets.Length;

            SelectableTarget[] selectables = new SelectableTarget[count];

            for (int i = 0; i < count; i++)
            {
                selectables[i] = targets[i].GetComponent <SelectableTarget>();
            }
            for (int i = 0; i < count; i++)
            {
                if (selectables[i] == null)
                {
                    targets[i]     = targets[i].transform.parent.gameObject;
                    selectables[i] = targets[i].GetComponent <SelectableTarget>();
                }
            }
            if (combining)
            {
                count = 0;
                for (int i = 0; i < targets.Length; i++)
                {
                    if (targets[i].GetComponent <CombineAction>().Combinable(part, up, down))
                    {
                        selectables[count] = selectables[i];
                        targets[count++]   = targets[i];
                    }
                }
            }

            for (int i = 0; i < count; i++)
            {
                if ((transform.position - targets[i].transform.position).sqrMagnitude <= range2)
                {
                    if (!Targets.Contains(targets[i])) //add targets that newly came into range
                    {
                        if (!selectables[i].IsSelectable(PlayerInside, tag))
                        {
                            continue;
                        }
                        Targets.Add(targets[i]);
                        selectables[i].SetGlow(PlayerInside, true);
                    }
                    else if (!selectables[i].IsSelectable(PlayerInside, tag))
                    {
                        Targets.Remove(targets[i]);
                    }
                }
                else //out of range
                {
                    if (Targets.Remove(targets[i])) //remove targets that went out of range
                    {
                        targets[i].GetComponent <SelectableTarget>().SetGlow(PlayerInside, false);
                    }
                }
            }
        }
    public void SetTarget(SelectableTarget currentTarget)
    {
        // Disable character target line renderer
        if (this.currentTarget != null)
        {
            // Destroy the old selection world radial menu
            if (WorldUIRadial.Instance != null)
            {
                Destroy(WorldUIRadial.Instance.gameObject);
            }

            switch (this.currentTarget.TargetSelectionProfile.selectionType)
            {
            case SelectionType.Character:
            {
                SelectableCharacter character = (SelectableCharacter)(this.currentTarget);
                character.pathTracer.SetNavPathTrace(false);
                character.inventory.SetOpen(false);
            }
            break;

            case SelectionType.Container:
            {
                SelectableContainer container = (SelectableContainer)(this.currentTarget);
                container.container.SetOpen(false);
            }
            break;
            }

            GameController.Instance.crewTargetDirection.ForceCleanupMenu();
            GameController.Instance.crewTargetDirection.ForceCleanUpInventories();
        }

        // Set the new target
        this.currentTarget = currentTarget;

        // If character, turn on line renderer
        // Disable character target line renderer
        if (this.currentTarget != null)
        {
            WorldUIRadial radialMenu = Instantiate(worldUIMenuPrefab, GameController.Instance.selectionDisplay.transform).GetComponent <WorldUIRadial>();
            radialMenu.Init(currentTarget);

            switch (this.currentTarget.TargetSelectionProfile.selectionType)
            {
            case SelectionType.Character:
            {
                ((SelectableCharacter)(this.currentTarget)).pathTracer.SetNavPathTrace(true);
            }
            break;
            }
        }
    }
    public bool DoTargetSearch(Vector3 WSMousePos, SelectableCharacter selectedDirecting)
    {
        ForceCleanupMenu();

        this.selectedDirecting = selectedDirecting;

        Vector2 mousePos2D = new Vector2(WSMousePos.x, WSMousePos.y);

        RaycastHit2D[] hits = Physics2D.RaycastAll(mousePos2D, Vector2.zero);

        targets = new List <SelectableTarget>();

        bool clicked = false;

        if (hits.Length > 0)
        {
            foreach (RaycastHit2D hit in hits)
            {
                // Check hit targets for selectables
                SelectableTarget targetCandidate = hit.collider.GetComponent <SelectableTarget>();

                if (targetCandidate != GameController.Instance.targetSelection.CurrentTarget)
                {
                    if (targetCandidate != null)
                    {
                        // Add candidate to new track list
                        if (targetCandidate.TargetSelectionProfile.selectionType == SelectionType.Character || targetCandidate.TargetSelectionProfile.selectionType == SelectionType.Container)
                        {
                            clicked = true;

                            targets.Add(targetCandidate);
                        }
                    }
                }
            }

            // Found containers and characters to add as direction options
            if (targets.Count > 0)
            {
                // Open details options menu
                directionOptionsPanel = GameController.Instance.panelController.AddPanel(PanelType.DirectionOptions, "Interact with");

                directionOptionsPanel.transform.position = Input.mousePosition;

                Vector3 screenPos = GameController.Instance.mainCamera.WorldToScreenPoint(targets[0].transform.position);

                ((DirectionOptionsMenu)directionOptionsPanel).InitMenu(targets);
            }
        }

        return(clicked);
    }
Esempio n. 5
0
    public void InitOption(SelectableTarget target, int index)
    {
        this.target = target;
        this.index  = index;

        SelectionProfile profile = target.TargetSelectionProfile;

        optionText.text    = profile.selectionName;
        optionImage.sprite = profile.selectionPortraitSprite;

        Rect rect = profile.selectionPortraitSprite.rect;

        optionImage.GetComponent <RectTransform>().sizeDelta = new Vector2(rect.width, rect.height);
    }
Esempio n. 6
0
 /// <summary>
 /// Creates the target resolver. This should handle turning a selected target into a resolved target
 /// </summary>
 /// <returns>The target resolver.</returns>
 /// <param name="target">Target.</param>
 /// <param name="manager">Manager.</param>
 public static ITargetResolver CreateTargetResolver(SelectableTarget target, BattleEntityManagerComponent manager)
 {
     switch(target.resolvedTargetType) {
     case ResolvedTargetEnum.SINGLE:
         return new TargetResolverSingle(target.entities[0]);
     case ResolvedTargetEnum.SELF_ROW:
         PCBattleEntity entity = (PCBattleEntity) target.entities[0];
         return new TargetResolverRow(entity.pcCharacter.rowPosition, manager);
     case ResolvedTargetEnum.SELF:
         return new TargetResolverSingle(target.entities[0]);
     case ResolvedTargetEnum.ENEMY_ALL:
         return new TargetResolverAll(true, manager);
     case ResolvedTargetEnum.ALLY_ROW_MIDDLE:
         return new TargetResolverRow(PCCharacter.RowPosition.MIDDLE, manager);
     case ResolvedTargetEnum.ALLY_ROW_FRONT:
         return new TargetResolverRow(PCCharacter.RowPosition.FRONT, manager);
     case ResolvedTargetEnum.ALLY_ROW_BACK:
         return new TargetResolverRow(PCCharacter.RowPosition.BACK, manager);
     case ResolvedTargetEnum.ALLY_ALL:
         return new TargetResolverAll(false, manager);
     }
     return null; // TODO turn into target classes
 }
Esempio n. 7
0
    public void TryOpenSelection()
    {
        SelectableTarget currentTarget = GameController.Instance.targetSelection.CurrentTarget;

        if (currentTarget != null)
        {
            switch (currentTarget.TargetSelectionProfile.selectionType)
            {
            case SelectionType.Character:
            {
                SelectableCharacter character = (SelectableCharacter)currentTarget;
                character.inventory.SetOpen(true);
            }
            break;

            case SelectionType.Container:
            {
                SelectableContainer container = (SelectableContainer)currentTarget;
                container.container.SetOpen(true);
            }
            break;
            }
        }
    }
Esempio n. 8
0
 public JobOpenTransferInventoriesDirection(string name, params object[] requiredObjects) : base(name, requiredObjects)
 {
     character        = requiredObjects[0] as SelectableCharacter;
     directedToTarget = requiredObjects[1] as SelectableTarget;
 }
    //
    public void SelectTarget(SelectableTarget target)
    {
        if( mTurnQueue.Count == 0) {
            // do nothing bad state
            Debug.LogError("Bad state, PCTurnManager.SelectSkill when no PC available");
            return;
        }

        PCBattleEntity sourceEntity = mTurnQueue.Dequeue();
        ITargetResolver targetResolver = TargetResolverFactory.CreateTargetResolver(target, mEntityManager);
        IBattleAction action = BattleActionFactory.CreateBattleAction(currentSelectedSkill, sourceEntity, targetResolver);
        OnCompleteDelegate.Invoke (sourceEntity, action);
        //        (sourceEntity, action);
        currentSelectedSkill = null;
        decisionState = (mTurnQueue.Count > 0? DecisionState.SKILL : DecisionState.IDLE);
    }
    public void DoTargetSearch(Vector3 WSMousePos)
    {
        Vector2 mousePos2D = new Vector2(WSMousePos.x, WSMousePos.y);

        RaycastHit2D[] hits = Physics2D.RaycastAll(mousePos2D, Vector2.zero);

        if (hits.Length > 0)
        {
            bool clicked = false;

            // No current target, prime a new List to recieve future targets
            oldCandidates = new List <SelectableTarget>();

            // Get all candidates and keep record of the best candidate for the new selection
            SelectableTarget bestCandidate = null;

            int index = 0;
            foreach (RaycastHit2D hit in hits)
            {
                SelectableTarget targetCandidate = hit.collider.GetComponent <SelectableTarget>();

                // Found a target
                if (targetCandidate != null)
                {
                    clicked = true;

                    // Add to list of targets we clicked
                    bool inserted = false;
                    for (int i = 0; i < oldCandidates.Count; ++i)
                    {
                        if (targetCandidate.TargetSelectionProfile.selectionType < oldCandidates[i].TargetSelectionProfile.selectionType)
                        {
                            oldCandidates.Insert(i, targetCandidate);
                            inserted = true;
                            break;
                        }
                    }
                    if (!inserted)
                    {
                        oldCandidates.Add(targetCandidate);
                    }

                    if (currentTarget == null)
                    {
                        // Track best
                        if (bestCandidate == null || targetCandidate.TargetSelectionProfile.selectionType >= bestCandidate.TargetSelectionProfile.selectionType)
                        {
                            bestCandidate         = targetCandidate;
                            currentSelectionIndex = index;
                        }
                    }
                }

                index++;
            }

            if (!clicked)
            {
                SetTarget(null);
                GameController.Instance.selectionDisplay.SetSelection(null);
            }
            else
            {
                if (currentTarget != null)
                {
                    currentSelectionIndex++;

                    if (currentSelectionIndex >= oldCandidates.Count)
                    {
                        currentSelectionIndex = 0;
                    }

                    SetTarget(oldCandidates[currentSelectionIndex]);
                }
                else
                {
                    SetTarget(bestCandidate);
                }

                GameController.Instance.selectionDisplay.SetSelection(currentTarget.TargetSelectionProfile);
            }
        }
        else
        {
            SetTarget(null);
            GameController.Instance.selectionDisplay.SetSelection(null);

            GameController.Instance.crewTargetDirection.ForceCleanupMenu();
            GameController.Instance.crewTargetDirection.ForceCleanUpInventories();
        }
    }
Esempio n. 11
0
    private static void PopulateSelfRowTargets(List<SelectableTarget> entityList, 
	                                                  HashSet<BattleEntity> entitySet,
	                                                  PCBattleEntity sourceEntity)
    {
        SelectableTarget rowTarget = new SelectableTarget(ROW_CURRENT_NAME, new List<BattleEntity>(), ResolvedTargetEnum.SELF_ROW);
        PCCharacter.RowPosition rowPos = sourceEntity.pcCharacter.rowPosition;
        foreach(BattleEntity entity in entitySet) {
            if(entity.isPC && ((PCBattleEntity)entity).pcCharacter.rowPosition == rowPos) {
                rowTarget.entities.Add(entity);
            }
        }

        if(rowTarget.entities.Count > 0) {
            entityList.Add(rowTarget);
        }
    }
Esempio n. 12
0
    /// <summary>
    /// Populates the row targets.
    /// </summary>
    /// <param name="entityList">Entity list.</param>
    /// <param name="entitySet">Entity set.</param>
    private static void PopulateRowTargets(List<SelectableTarget> entityList, HashSet<BattleEntity> entitySet)
    {
        // create the bins for when we find the values
        SelectableTarget frontRowTarget = new SelectableTarget(ROW_FRONT_NAME, new List<BattleEntity>(), ResolvedTargetEnum.ALLY_ROW_FRONT);
        SelectableTarget middleRowTarget = new SelectableTarget(ROW_MIDDLE_NAME, new List<BattleEntity>(), ResolvedTargetEnum.ALLY_ROW_MIDDLE);
        SelectableTarget backRowTarget = new SelectableTarget(ROW_BACK_NAME, new List<BattleEntity>(), ResolvedTargetEnum.ALLY_ROW_BACK);

        // populate the bins
        foreach(BattleEntity entity in entitySet) {
            if(entity.isPC) {
                switch(((PCBattleEntity)entity).pcCharacter.rowPosition) {
                case PCCharacter.RowPosition.FRONT:
                    frontRowTarget.entities.Add(entity);
                    break;
                case PCCharacter.RowPosition.MIDDLE:
                    middleRowTarget.entities.Add(entity);
                    break;
                case PCCharacter.RowPosition.BACK:
                    backRowTarget.entities.Add(entity);
                    break;
                }
            }
        }

        // only add bins that have ones
        if(frontRowTarget.entities.Count > 0) {
            entityList.Add(frontRowTarget);
        }
        if(middleRowTarget.entities.Count > 0) {
            entityList.Add(middleRowTarget);
        }
        if(backRowTarget.entities.Count > 0) {
            entityList.Add(backRowTarget);
        }
    }
Esempio n. 13
0
    /// <summary>
    /// Populates selectable targets based on All Enemies or All Allies.
    /// </summary>
    /// <param name="entityList">Entity list.</param>
    /// <param name="entitySet">Entity set.</param>
    private static void PopulateAllTargets(List<SelectableTarget> entityList, 
	                                                 HashSet<BattleEntity> entitySet)
    {
        // create the bins for when we find the values
        SelectableTarget enemyTarget = new SelectableTarget(ALL_ENEMY, new List<BattleEntity>(), ResolvedTargetEnum.ENEMY_ALL);
        SelectableTarget allyTarget = new SelectableTarget(ALL_ALLIES, new List<BattleEntity>(), ResolvedTargetEnum.ALLY_ALL);

        // add each to appropriate list
        foreach(BattleEntity entity in entitySet) {
            if(entity.isPC) {
                allyTarget.entities.Add(entity);
            }
            else {
                enemyTarget.entities.Add(entity);
            }
        }

        // add to main list if we have count > 0
        if(enemyTarget.entities.Count > 0) {
            entityList.Add(enemyTarget);
        }

        if(allyTarget.entities.Count > 0) {
            entityList.Add(allyTarget);
        }
    }
Esempio n. 14
0
    // Update is called once per frame
    void Update()
    {
        bool  overBar;
        Panel panelHover = GameController.Instance.panelController.TestOverPanel(out overBar);

        if (panelHover != null)
        {
            panelHover.OnPanelHover();
        }

        // Left click try and select target
        if (Input.GetMouseButtonDown(0))
        {
            // hoverring main panel and clicked, bring to front
            if (panelHover != null)
            {
                GameController.Instance.panelController.BringToFront(panelHover);

                if (overBar) // Clicked a drag bar of panel
                {
                    GameController.Instance.panelController.StartDrag();
                }
                else // Clicked a window of panel
                {
                    panelHover.OnPanelClick();
                }
            }
            else
            {
                Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);

                if (!GameController.Instance.selectionDisplay.TestSelectionButtons()) // Test if clicked selection buttons
                {
                    // Test if clicked radial menu
                    bool          radialClicked       = false;
                    WorldUIRadial radialMenuCandidate = WorldUIRadial.Instance;
                    if (radialMenuCandidate != null)
                    {
                        radialClicked = radialMenuCandidate.TestWorldClickButtons();
                    }

                    if (!radialClicked)
                    {
                        GameController.Instance.targetSelection.DoTargetSearch(mousePos);
                    }
                }
            }
        }

        if (!Input.GetMouseButton(0))
        {
            GameController.Instance.panelController.ForceStopDrag();
        }

        // Left mouse button UP do release logic on target window
        if (Input.GetMouseButtonUp(0))
        {
            // hoverring main panel and released, bring to front
            if (panelHover != null)
            {
                GameController.Instance.panelController.BringToFront(panelHover);

                if (!overBar) // Released on main window, not bar
                {
                    panelHover.OnPanelReleaseClick();
                }
            }
        }

        // Right click, direct selected character to target location
        if (Input.GetMouseButtonDown(1))
        {
            SelectableTarget currentTarget = GameController.Instance.targetSelection.CurrentTarget;

            if (currentTarget != null)
            {
                switch (currentTarget.TargetSelectionProfile.selectionType)
                {
                case SelectionType.Character:
                {
                    SelectableCharacter character = (SelectableCharacter)currentTarget;

                    Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                    if (!GameController.Instance.crewTargetDirection.DoTargetSearch(mousePos, character))
                    {
                        character.playerCrewAI.NavToMouse();
                    }
                }
                break;
                }
            }
        }
    }