コード例 #1
0
    /// <summary>
    /// Substract magnitude to v's magnitude. return vector.zero if magnitude > v.magnitude
    /// </summary>
    public static Vector3 SubtractMagnitude(Vector3 v, float magnitude, CalculMode mode = CalculMode.ThreeAxis)
    {
        switch (mode)
        {
        case CalculMode.ThreeAxis:
            if (v.magnitude > magnitude)
            {
                return(v.normalized * (v.magnitude - magnitude));
            }
            else
            {
                return(Vector3.zero);
            }

        case CalculMode.NoYAxis:
            float y = v.y;
            v.y = 0f;
            if (v.magnitude > magnitude)
            {
                v = v.normalized * (v.magnitude - magnitude);
                return(new Vector3(v.x, y, v.z));
            }
            else
            {
                return(new Vector3(0f, y, 0f));
            }

        default:
            return(Vector3.zero);
        }
    }
コード例 #2
0
ファイル: Program.cs プロジェクト: NivekAlunya/csharp
 static double computeBaseSalary(double hourlyRate,double workTime, CalculMode mode)
 {
     double baseSalary = 0;
     switch (mode)
     {
         case CalculMode.rule1:
             baseSalary = hourlyRate * workTime;
             break;
         case CalculMode.rule2:
             baseSalary = (hourlyRate * FULLTIME) + ((workTime - FULLTIME) * hourlyRate * 1.5);
             break;
         case CalculMode.rule3:
             baseSalary = (hourlyRate * FULLTIME)
                 + ((OVERTIME - FULLTIME) * hourlyRate * 1.5)
                 + ((workTime - OVERTIME) * hourlyRate * 1.6);
             break;
     }
     return baseSalary;
 }
コード例 #3
0
    /// <summary>
    /// Add add to v. If v's magnitude > upperlimit, it is set to upperlimit.
    /// </summary>
    public static Vector3 AddWithLimit(Vector3 v, Vector3 add, float upperLimit, CalculMode mode = CalculMode.ThreeAxis, LimitMode limitMode = LimitMode.Set, float?smoothLimitSubstract = null)
    {
        switch (mode)
        {
        case CalculMode.ThreeAxis:
            v += add;
            if (v.magnitude < upperLimit)
            {
                return(v);
            }
            else
            {
                switch (limitMode)
                {
                case LimitMode.Set:
                    return(v.normalized * upperLimit);

                case LimitMode.Smooth:
                    if (SubtractMagnitude(v, (smoothLimitSubstract == null ? add.magnitude * 2f : (float)smoothLimitSubstract + add.magnitude)).magnitude < upperLimit)
                    {
                        return(v.normalized * upperLimit);
                    }
                    else
                    {
                        return(SubtractMagnitude(v, (smoothLimitSubstract == null ? add.magnitude * 2f : (float)smoothLimitSubstract + add.magnitude)));
                    }

                default:
                    return(v.normalized * upperLimit);
                }
            }


        case CalculMode.NoYAxis:
            float y = v.y;
            v.y   = 0;
            add.y = 0;
            v    += add;
            if (v.magnitude < upperLimit)
            {
                return(new Vector3(v.x, y, v.z));
            }
            else
            {
                Vector3 temp = v.normalized * upperLimit;

                switch (limitMode)
                {
                case LimitMode.Set:
                    return(new Vector3(temp.x, y, temp.z).normalized *upperLimit);

                case LimitMode.Smooth:
                    if (SubtractMagnitude(v, (smoothLimitSubstract == null ? add.magnitude * 2f : (float)smoothLimitSubstract + add.magnitude)).magnitude < upperLimit)
                    {
                        return(new Vector3(temp.x, y, temp.z));
                    }
                    else
                    {
                        v = SubtractMagnitude(v, (smoothLimitSubstract == null ? add.magnitude * 2f : (float)smoothLimitSubstract + add.magnitude));
                        return(new Vector3(v.x, y, v.z));
                    }

                default:
                    return(new Vector3(v.x, y, v.z).normalized *upperLimit);
                }
            }

        default:
            return(Vector3.zero);
        }
    }