static public bool Allows(XperItem item, XperAction type, XperRange range)
    {
        bool validAction = (s_singleton.AttributionsOf(item) & type) == type;
        bool validRange  = (s_singleton.RangeModeOf(item) & range) == range;

        return(validAction && validRange);
    }
Beispiel #2
0
 public XperEntry(XperAction type, XperRange range, XperItem item)
 {
     m_type            = type;
     m_item            = item;
     m_range           = range;
     m_timeOfEntry     = Time.time;
     m_introducedFirst = XperManager.FirstInteractionIntroduced(item);
     m_height          = StageManager.stageHeight;
 }
    private bool CheckAtRange(ViveWand wand, XperRange range)
    {
        switch (range)
        {
        case XperRange.Contact:
            return(wand.closestObject == gameObject);

        case XperRange.Ranged:
            return((wand.targetedGameObject == gameObject) && (wand.skin != ViveWand.ViveWandSkins.Beam));

        case (XperRange.Contact | XperRange.Ranged):
            return(CheckAtRange(wand, XperRange.Contact) || CheckAtRange(wand, XperRange.Ranged));
        }

        return(false);
    }
    public XperRange RangeModeOf(XperItem item)
    {
        XperRange res = 0;

        switch (item)
        {
        case XperItem.Erlenmeyer:
            res = m_erlenmeyerRangeMode;
            break;

        case XperItem.Becher:
            res = m_becherRangeMode;
            break;

        case XperItem.WaterTap:
            res = m_waterTapRangeMode;
            break;

        case XperItem.PipetteTap:
            res = m_pipetteTapRangeMode;
            break;

        case XperItem.Tube:
            res = m_tubeRangeMode;
            break;

        case XperItem.CogWheel:
            res = m_cogWheelRangeMode;
            break;

        case XperItem.AgitatorButton:
            res = m_agitatorButtonRangeMode;
            break;

        case XperItem.HodPane:
            res = m_hodPaneRangeMode;
            break;

        case XperItem.Cork:
            res = m_corkRangeMode;
            break;

        case XperItem.Agitator:
            res = m_agitatorRangeMode;
            break;

        case XperItem.Match:
            res = m_matchRangeMode;
            break;

        case XperItem.MatchBox:
            res = m_matchBoxRangeMode;
            break;

        case XperItem.Spatula:
            res = m_spatulaRangeMode;
            break;

        case XperItem.InstructorButton:
            res = m_instructorButtonRangeMode;
            break;

        case XperItem.Pen:
            res = m_markerRangeMode;
            break;

        case XperItem.PenCork:
            res = m_markerCorkRangeMode;
            break;
        }

        return(res);
    }
    public void SetRangeModeOf(XperItem item, XperRange type)
    {
        switch (item)
        {
        case XperItem.Erlenmeyer:
            m_erlenmeyerRangeMode = type;
            break;

        case XperItem.Becher:
            m_becherRangeMode = type;
            break;

        case XperItem.WaterTap:
            m_waterTapRangeMode = type;
            break;

        case XperItem.PipetteTap:
            m_pipetteTapRangeMode = type;
            break;

        case XperItem.Tube:
            m_tubeRangeMode = type;
            break;

        case XperItem.CogWheel:
            m_cogWheelRangeMode = type;
            break;

        case XperItem.AgitatorButton:
            m_agitatorButtonRangeMode = type;
            break;

        case XperItem.HodPane:
            m_hodPaneRangeMode = type;
            break;

        case XperItem.Cork:
            m_corkRangeMode = type;
            break;

        case XperItem.Agitator:
            m_agitatorRangeMode = type;
            break;

        case XperItem.Match:
            m_matchRangeMode = type;
            break;

        case XperItem.MatchBox:
            m_matchBoxRangeMode = type;
            break;

        case XperItem.Spatula:
            m_spatulaRangeMode = type;
            break;

        case XperItem.InstructorButton:
            m_instructorButtonRangeMode = type;
            break;

        case XperItem.Pen:
            m_markerRangeMode = type;
            break;

        case XperItem.PenCork:
            m_markerCorkRangeMode = type;
            break;
        }
    }
 private bool CheckWandAction(ViveWand wand, XperAction action, XperRange range)
 {
     return(wand.IsInteractionPressed(action) && XperManager.Allows(m_itemType, action, range));
 }
    private bool InteractsWithWand(out ViveWand interactionWand, out XperAction mode, out XperRange range)
    {
        int        wandCount       = ViveWand.wandCount;
        XperAction activationMode  = 0;
        XperRange  activationRange = 0;
        ViveWand   gripingWand     = null;

        m_isAtRangeOfWand = false;

        List <ViveWand> wands = new List <ViveWand>();

        for (int i = 0; i < wandCount; i++)
        {
            wands.Add(ViveWand.Wand(i));
        }

        if (m_interactionWand && wands.Contains(m_interactionWand))
        {
            if (wands[0] != m_interactionWand)
            {
                int      indexOfInteractionWand = wands.IndexOf(m_interactionWand);
                ViveWand tmp = wands[0];
                wands[0] = m_interactionWand;
                wands[indexOfInteractionWand] = tmp;
            }
        }

        foreach (ViveWand wand in wands)
        {
            if (!wand || !wand.gameObject.activeSelf)
            {
                continue;
            }

            if (!wand.upToDate)
            {
                wand.ForceUpdate();
            }

            XperAction[] actions = Enum.GetValues(typeof(XperAction)) as XperAction[];
            XperRange[]  ranges  = Enum.GetValues(typeof(XperRange)) as XperRange[];

            foreach (XperRange tmpRange in ranges)
            {
                foreach (XperAction tmpAction in actions)
                {
                    bool isAtRangeOfTestedWand = CheckAtRange(wand, tmpRange);
                    m_isAtRangeOfWand |= isAtRangeOfTestedWand;
                    if ((isAtRangeOfTestedWand || hasFocus) && CheckWandAction(wand, tmpAction, tmpRange))
                    {
                        activationMode  = tmpAction;
                        activationRange = tmpRange;
                        gripingWand     = wand;

                        break;
                    }
                }

                if (gripingWand)
                {
                    break;
                }
            }

            if (gripingWand)
            {
                break;
            }
        }

        range           = activationRange;
        interactionWand = gripingWand;
        mode            = activationMode;

        return(gripingWand != null);
    }