RandomGen.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion
 
/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen, Rami Pasanen.
 */
 
using System;
using System.Collections.Generic;
 
namespace Jypeli
{
    public static class RandomGen
    {
        private static Random rand = new Random();
 
        public static bool NextBool()
        {
            return ( rand.NextDouble() >= 0.5 );
        }
 
        public static int NextInt( int maxValue )
        {
            return rand.Next( maxValue );
        }
 
        public static int NextInt( int min, int max )
        {
            return rand.Next( min, max );
        }        
 
        public static double NextDouble( double min, double max )
        {
            return min + rand.NextDouble() * ( max - min );
        }
 
        public static char NextLetter(bool upperCase = false)
        {
            int startCode = upperCase ? (int)'A' : (int)'a';
            int endCode = upperCase ? (int)'Z' : (int)'z';
            return (char)NextInt( startCode, endCode + 1 );
        }
 
        public static Direction NextDirection()
        {
            double randdir = rand.NextDouble();
 
            if ( randdir <= 0.25 )
                return Direction.Up;
 
            if ( randdir <= 0.5 )
                return Direction.Down;
 
            if ( randdir <= 0.75 )
                return Direction.Left;
 
            return Direction.Right;
        }
 
        public static double[] NextDoubleArray( double min, double max, int size )
        {
            double[] array = new double[size];
 
            for ( int i = 0; i < size; i++ )
            {
                array[i] = NextDouble( min, max );
            }
 
            return array;
        }
 
        public static double[] NextDoubleArray( double min, double max, int size, int maxchange )
        {
            double[] array = new double[size];
            double curmin = min;
            double curmax = max;
 
            for ( int i = 0; i < size; i++ )
            {
                array[i] = NextDouble( curmin, curmax );
 
                curmin = AdvanceMath.MathHelper.Max((float)min, (float)(array[i] - maxchange));
                curmax = AdvanceMath.MathHelper.Min((float)max, (float)(array[i] + maxchange));
            }
 
            return array;
        }
 
        public static Color NextColor()
        {
            return new Color( (float)rand.NextDouble(), (float)rand.NextDouble(), (float)rand.NextDouble(), 1 );
        }
 
        public static Color NextLightColor()
        {
            return Color.Mix( NextColor(), Color.White );
        }
 
        public static Color NextDarkColor()
        {
            return Color.Mix( NextColor(), Color.Black );
        }
 
        public static Color NextColor( object obj )
        {
            var r = new Random( obj.GetHashCode() );
            return new Color( (float)r.NextDouble(), (float)r.NextDouble(), (float)r.NextDouble(), 1 );
        }
 
        public static Color NextColor( Color first, Color second )
        {
            return Color.Lerp( first, second, (float)rand.NextDouble());
        }
 
        public static Angle NextAngle()
        {
            return Angle.FromRadians( NextDouble( 0, 2 * Math.PI ) );
        }
 
        public static Vector NextVector( double minLength, double maxLength )
        {
            return Vector.FromLengthAndAngle( NextDouble( minLength, maxLength ), NextAngle() );
        }
 
        public static Vector NextVector( double minX, double minY, double maxX, double maxY )
        {
            return new Vector( NextDouble( minX, maxX ), NextDouble( minY, maxY ) );
        }
 
        public static Vector NextVector( BoundingRectangle rect, int r = 0 )
        {
            return new Vector( NextDouble( rect.Left + r, rect.Right - r ), NextDouble( rect.Bottom + r, rect.Top - r ) );
        }
 
        public static Angle NextAngle( Angle max )
        {
            return Angle.FromRadians( NextDouble( 0, max.Radians ) );
        }
 
        public static Angle NextAngle( Angle min, Angle max )
        {
            double a1 = min.Radians;
            double a2 = max.Radians;
            while ( a2 < a1 ) a2 += 2 * Math.PI;
            return Angle.FromRadians( NextDouble( a1, a2 ) );
        }
 
        public static TimeSpan NextTimeSpan( double minSeconds, double maxSeconds )
        {
            return TimeSpan.FromSeconds( NextDouble( minSeconds, maxSeconds ) );
        }
 
        public static Shape NextShape()
        {
            return SelectOne(new Shape[] { Shape.Diamond, Shape.Ellipse,
                Shape.Heart, Shape.Hexagon, Shape.Octagon, Shape.Pentagon,
                Shape.Rectangle, Shape.Star, Shape.Triangle });
        }
 
        public static int NextIntWithProbabilities( params double[] p )
        {
            double randomNum = rand.NextDouble();
            double accumulator = 0;
 
            for ( int i = 0; i < p.Length; i++ )
            {
                accumulator += p[i];
                if ( randomNum < accumulator ) return i;
            }
 
            return p.Length;
        }
 
 
        public static void Shuffle<T>(IList<T> list)
        {
            for (int i = list.Count; i > 1; i--)
            {
                // Pick random element to swap.
                int j = rand.Next(i); // 0 <= j <= i-1
                // Swap.
                T tmp = list[j];
                list[j] = list[i - 1];
                list[i - 1] = tmp;
            }
        }
 
        public static T SelectOne<T>( params T[] choices )
        {
            int i = NextInt( choices.Length );
            return choices[i];
        }
 
        public static T SelectOne<T>( IList<T> choices )
        {
            int i = NextInt( choices.Count );
            return choices[i];
        }
    }
}