private void BtnBuild_Click(object sender, RoutedEventArgs e)
{
// создаем набор случайных примитивов
RandomFactory drankDirector = new RandomFactory();
for (int i = 0; i < 5; i++)
{
AddToCanvas(
drankDirector.BuildRandomShape(), // директор
random.NextDouble() * (canvas.ActualWidth - 50),
random.NextDouble() * (canvas.ActualHeight - 50));
}
// клонирование дерева
Shape tree = new ShapeBuilder(ShapeBuilder.Type.TREE).Build();
tree.Stroke = Brushes.Blue;
double left = random.NextDouble() * (canvas.ActualWidth - 50);
double top = random.NextDouble() * (canvas.ActualHeight - 50);
AddToCanvas(tree, left, top);
for (int j = 0; j < 2; j++)
{
left += tree.Width * 0.5;
Tree copy = (tree as Tree).Clone() as Tree; // копия
copy.Stroke = Brushes.Green;
AddToCanvas(copy, left, top);
}
}
//随机列表
//获取随机
public int[] GetRandNumbers(string lotteryType, ulong issue, string randType)
{
RichLotteryRecord record = m_dataCenter.GetRecordOf(lotteryType);
RichDataEntry entry = m_dataCenter.GetEntryOf(record, issue);
//找到随机
IRandom rand = RandomFactory.GetRandom(randType);
rand.SetRandomSeed(entry);
//获取规则
int count = m_setting.m_LottryTypes[lotteryType].totalNum;
var seg = m_setting.m_LottryTypes[lotteryType].segments;
int[] result = new int[count];
int pos = 0;
foreach (var s in seg)
{
int[] r = rand.GetRandNum(s.max, s.min, s.count);
r.CopyTo(result, pos);
pos += s.count;
}
return(result);
}
public void Initialize(RandomFactory <T> factory,
Dictionary <T, float> updatedChances = default(Dictionary <T, float>),
float chanceToGetNothing = -1.0f)
{
// Updated chances specified: generate chanceTable and intialize with it
if (updatedChances != default(Dictionary <T, float>))
{
// create new dict based on factory
var chanceTable = new Dictionary <T, float> ();
for (int i = 0; i < factory._ranges.Length; i++)
{
chanceTable.Add(factory._objects[i], factory._ranges[i]);
}
// update dict with updateChances
foreach (var pair in updatedChances)
{
chanceTable[pair.Key] = pair.Value;
}
// call Initialize with that dict
this.Initialize(chanceTable, chanceToGetNothing);
}
// Updated chances NOT specified: just copy data from a factory
else
{
_lowwater = (chanceToGetNothing > 0f) ? 0f - chanceToGetNothing : factory._lowwater;
_hightwater = factory._hightwater;
factory._ranges.CopyTo(_ranges, factory._ranges.Length);
factory._objects.CopyTo(_objects, factory._objects.Length);
}
}
public static KeyValuePair <int, T> GetRandomElementWithIndex <T>(this ICollection <T> collection)
{
var randomIndex = RandomFactory.GetInstance().Next(collection.Count);
var randomElement = collection.ElementAtOrDefault(randomIndex);
return(new KeyValuePair <int, T>(randomIndex, randomElement));
}
public Engine(Matrix3D camera)
{
var ambient = 0.00;
var diffuse = 0.95;
var scale = 75;
var distance = 100.0;
this.camera = camera;
this.screen = new Screen(width, height);
this.window = new Window(width, height, scale, distance, camera);
var randomFactory = new RandomFactory();
var hemiSamplerFactory = new HemiSamplerFactory();
var triangleSampler = new TriangleSampler(randomFactory);
var primitives = new Construction();
var illumination = new Illumination(primitives, randomFactory, triangleSampler);
var seedFactory = new Random();
this.tracer = new Tracer(primitives, new Emissive(Constant.WHITE, ambient, 1.0), randomFactory, hemiSamplerFactory);
ExampleUtil.buildCornelBox(primitives, illumination, diffuse, tracer, randomFactory, hemiSamplerFactory);
}
public void TestFakerBaseDictionary()
{
Name n = new Name();
RandomFactory random = new RandomFactory(null, LocaleType.en);
Assert.AreEqual(n.GetType(), random.GetFakerObjectFromName("Name").GetType());
}
public void Test_IsStringValid()
{
List <string> myList;
for (var i = 1; i < 128; i++)
{
myList = RandomFactory.GetRandomListOfString(64, i);
foreach (var s in myList)
{
var res = Utils.IsStringValid(s);
Assert.AreEqual(res, true);
}
}
for (var i = 1; i < 128; i++)
{
myList = RandomFactory.GetRandomListOfInt(64, i);
foreach (var s in myList)
{
var res = Utils.IsStringValid(s);
Assert.AreEqual(res, true);
}
}
for (var i = 1; i < 128; i++)
{
myList = RandomFactory.GetRandomListOfSpecialString(64, i);
foreach (var s in myList)
{
var res = Utils.IsStringValid(s);
Assert.AreEqual(res, false);
}
}
}
public void GeneratingAMazeWithABlockInTheMiddleWorks()
{
var map = new BitArreintjeFastInnerMap(128, 128);
for (int y = 33; y < 96; y++)
{
for (int x = 33; x < 96; x++)
{
map[x, y] = true;
}
}
var mapFactory = new InnerMapFactoryCustom <BitArreintjeFastInnerMap>(map);
var randomFactory = new RandomFactory <NetRandom>(1337);
var algorithm = new AlgorithmBacktrack();
var generatedMap = algorithm.GoGenerate(mapFactory, randomFactory, null);
var path = PathFinderDepthFirstSmartWithPos.GoFind(map, null);
using (var fs = new FileStream("GeneratingAMazeWithABlockInTheMiddleWorks.png", FileMode.Create))
{
WithPath.SaveMazeAsImageDeluxePng(map, path, fs);
}
}
/// <summary>
/// Take all modifyable parameters from the given data object.
/// </summary>
/// <param name="data"></param>
public void TakeParametersFrom(AriadneSettingsData data)
{
// The Auto... flags for Width and Height have already been checked by the MazeUserControl.
this.xSize = Math.Max(dimensionsObj.MinSize, Math.Min(dimensionsObj.MaxXSize, data.MazeWidth));
this.ySize = Math.Max(dimensionsObj.MinSize, Math.Min(dimensionsObj.MaxYSize, data.MazeHeight));
if (!data.AutoSeed)
{
this.seed = Math.Max(0, Math.Min(codeObj.SeedLimit - 1, data.Seed));
}
else
{
Random r = RandomFactory.CreateRandom();
this.seed = r.Next(codeObj.SeedLimit);
}
this.random = RandomFactory.CreateRandom(seed);
this.reservedAreas.Clear();
this.reservedAreaShapes.Clear();
this.outlineShape = null;
this.embeddedMazeShapes.Clear();
this.embeddedMazes.Clear();
this.Irregular = data.IrregularMaze;
this.Irregularity = data.Irregularity;
// Decode(data.Code);
}
private GroupDto SetupGroupDto()
{
return(new GroupDto()
{
Name = RandomFactory.GetCompanyName(),
IsActive = RandomFactory.GetBoolean()
});
}
/// <summary>
/// Creates a new instance of <see cref="DynamicParameterProvider"/>
/// </summary>
/// <param name="parameterSetListCapacity">Parameter set list capacity</param>
public DynamicParameterProvider(int parameterSetListCapacity)
{
_random = RandomFactory.GetInstance();
_currentParameterSetIndex = 0;
ParameterSets = GenerateRandomParameters(parameterSetListCapacity);
WinningParameterSets = new List <Tuple <double, double> >();
}
public DCSBIOSDecoder()
{
_jaceId = RandomFactory.Get();
_imageUpdateTread = new Thread(ImageRefreshingThread);
_imageUpdateTread.Start();
DCSBIOS.GetInstance().AttachDataReceivedListener(this);
EventHandlers.AttachDCSBIOSDecoder(this);
}
protected GroupDto GetGroupDto()
{
return(new GroupDto()
{
Name = RandomFactory.GetCompanyName(),
IsActive = RandomFactory.GetBoolean()
});
}
public void TestRandomSelection()
{
int i = RandomProxy.Next();
DummyClass d = new DummyClass(i);
var r = new RandomFactory(d, LocaleType.en);
var result = r.GetRandomItemFromProperty <int>("Test1", d);
Assert.IsTrue(Array.Exists(d.Test1, n => n == result));
}
public JsonResult GetRandom()
{
var response = _tipService.Filter(new TipFilter {
StartPage = 1, EndPage = 1, OnlyStatusActivated = true
});
var randomId = new RandomFactory().Number(response.TotalRecords);
var tip = _tipService.Get(randomId);
return(new JsonFactory().Success(tip));
}
public DataProcessor(DataScheme scheme, IGeneratorFactory generatorFactory)
{
scheme.ThrowIfNull(nameof(scheme));
scheme.Root.ThrowIfNull(nameof(scheme.Root));
scheme.Definitions.ThrowIfNullOrEmpty(nameof(scheme.Definitions));
_scheme = scheme;
_generatorFactory = generatorFactory ?? throw new ArgumentNullException(nameof(generatorFactory));
_propertyObjectFactory = new PropertyObjectFactory();
_randomFactory = new RandomFactory();
}
/// <summary>
/// Makes a random Movie
/// </summary>
/// <returns>A Movie with randomly generated variables</returns>
public static Movie Random() => new Movie(
RandomFactory.String(),
RandomFactory.String(),
RandomFactory.String(),
RandomFactory.Int(),
RandomFactory.Enum <Genre>(),
RandomFactory.Enum <Classification>(),
RandomFactory.DateTime(),
RandomFactory.Int(),
RandomFactory.Int(),
RandomFactory.Int());
/// <summary>
/// Return the move with the highest win-rate after performing in parallel the specified number of simulations on the game.
/// </summary>
/// <param name="game">The starting gamestate.</param>
/// <param name="simulations">The number of simulations to perform.</param>
public static TMove ParallelSearch(TGame game, int simulations)
{
TPlayer aiPlayer = game.CurrentPlayer;
List <TMove> legalMoves = game.GetLegalMoves();
int count = legalMoves.Count;
MoveStats[] moveStats = new MoveStats[count];
Parallel.For(0, simulations,
() => RandomFactory.Create(),
(i, loop, localRandom) =>
{
int moveIndex = localRandom.Next(0, count);
TGame copy = game.DeepCopy();
copy.DoMove(legalMoves[moveIndex]);
while (!copy.IsGameOver())
{
copy.DoMove(
copy.GetLegalMoves().RandomItem(localRandom));
}
Interlocked.Add(ref moveStats[moveIndex].executions, 1);
if (copy.IsWinner(aiPlayer))
{
Interlocked.Add(ref moveStats[moveIndex].victories, 1);
}
return(localRandom);
},
x => { }
);
int bestMoveFound = 0;
double bestScoreFound = 0f;
for (int i = 0; i < count; i++)
{
double score = moveStats[i].Score();
if (score > bestScoreFound)
{
bestScoreFound = score;
bestMoveFound = i;
}
}
//for (int i = 0; i < legalMoves.Count; i++)
// Console.WriteLine("Move " + legalMoves[i] + " has " + moveStats[i].victories + " victories / " + moveStats[i].executions + " executions.");
return(legalMoves[bestMoveFound]);
}
private void RoundReset()
{
AssingGridsToPlayers();
// randomize the pool
_roundItems = new List <string>(_items);
var roundGuid = Guid.NewGuid();
var random = RandomFactory.FromGuid(roundGuid);
_roundItems.Shuffle(random);
_winners = 0;
}
public async Task CreateGroup_NameTooLong_BadRequest()
{
// Arrange
var dto = GetGroupDto();
dto.Name = RandomFactory.GetAlphanumericString(Constants.MaximumLengths.StringColumn + 1);
// Act
using var response = await Client.PostAsJsonAsync("/api/groups", dto);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void GroupDtoValidation_Valid_NoErrors()
{
var dto = new GroupDto
{
Name = RandomFactory.GetCompanyName(),
};
var validationContext = new ValidationContext(dto);
var validationResults = dto.Validate(validationContext);
validationResults.Should().HaveCount(0);
}
/// <summary>
/// Constructor.
/// Create a maze whose parameters are encoded in the given code (see property Code).
/// </summary>
/// <param name="code">a string of seven letters (case is ignored)</param>
public Maze(string code)
{
int version = MazeCode.GetCodeVersion(code);
this.dimensionsObj = MazeDimensions.Instance(version);
this.codeObj = MazeCode.Instance(version);
codeObj.Decode(code
, out this.seed
, out this.xSize, out this.ySize
);
this.random = RandomFactory.CreateRandom(seed);
}
public void setMarkVisible(bool isVisible, int num)
{
int index = -1;
foreach (var randomType in RandomFactory.GetRandomFuncList())
{
index++;
if (index >= mItemCount || num == index)
{
continue;
}
items[index].GetComponent <RandomItemUI>().setMarkVisible(false);
}
}
/// <summary>
/// Generate a Maze
/// </summary>
/// <param name="map">The inner map to generate the maze in</param>
/// <param name="seed">The seed that is used to generate a maze</param>
/// <param name="pixelChangedCallback">When a pixel is changed you can define a callback here to for example draw the maze while its being generated, add null if you don't want this. Last 2 longs are for the current step and the total steps (can be used to calculate how far the maze is done being generated)</param>
public InnerMap Generate <M, R>(int width, int height, int seed, Action <int, int, long, long> pixelChangedCallback) where M : InnerMap where R : IRandom
{
if (pixelChangedCallback == null)
{
pixelChangedCallback = (x, y, z, u) => { };
}
var innerMapFactory = new InnerMapFactory <M>(width, height);
var randomFactory = new RandomFactory <R>(seed);
var generatedMap = GoGenerate(innerMapFactory, randomFactory, pixelChangedCallback);
return(generatedMap);
}
public void GroupDtoValidation_NameTooLong_HasValidationErrors()
{
var dto = new GroupDto
{
Name = RandomFactory.GetAlphanumericString(Constants.MaximumLengths.StringColumn + 1),
};
var validationContext = new ValidationContext(dto);
var validationResults = dto.Validate(validationContext);
validationResults.Should().HaveCountGreaterThan(0);
validationResults.FirstOrDefault(validationResult => validationResult.MemberNames.Any(memberName => memberName.Equals(nameof(GroupDto.Name))))?.Should().NotBeNull();
}
/// <summary>
/// Loads the game from the given save file
/// </summary>
/// <param name="saveFile">the path to the save file</param>
private static void LoadGame(string saveFile)
{
// Reset the random generator
RandomFactory.Reset();
// Reset the id factory
IdFactory.ResetIdFactory();
// Create the GamePlay simulator
GamePlay sim = new GamePlay(saveFile);
// Replace this instance of Game with the simulated one
game = sim.GetLoadedGame();
}
public object Perform(StepContext ctx, object input)
{
var random = RandomFactory.Create();
return(CreateCellMatrix(ctx)
.Fill(random, ctx.RandomFillPercent)
.Smooth(
ctx.SmoothSteps,
ctx.MaxActiveNeighbors,
ctx.NeighboursRadio
)
.RemoveRegions(ctx.RemoveRegionsSize)
.MakeBorders());
}
public void TestNextMethod2()
{
int m = RandomProxy.Next(2, 100);
DummyClass d = new DummyClass(m);
string format = @"#{Test1} #{Test1}";
var r = new RandomFactory(d, LocaleType.en);
var result = r.Next <int>(format);
string[] numbers = result.Split(' ');
Assert.AreEqual(numbers.Length, 2);
Assert.IsTrue(Array.Exists(d.Test1, n => n == int.Parse(numbers[0])));
Assert.IsTrue(Array.Exists(d.Test1, n => n == int.Parse(numbers[0])));
Assert.IsTrue(numbers[0] != numbers[1]);
}
public static string GenerateRandomAlphaString(int length = 8)
{
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
var r = RandomFactory.Create();
var handle = "";
for (var count = 0; count < length; count++)
{
var chosenCharIndex = r.Next(0, alphabet.Length);
handle += alphabet[chosenCharIndex];
}
return(handle);
}
public async Task UpdateGroup_NameTooLong_BadRequest()
{
// Arrange
Data.Models.Group randomGroup = null;
ServiceProvider.ExecuteWithDbScope(db => randomGroup = SeedHelper.GetRandomGroup(db));
var dto = Mapper.Map <GroupDto>(randomGroup);
dto.Name = RandomFactory.GetAlphanumericString(Constants.MaximumLengths.StringColumn + 1);
// Act
using var response = await Client.PutAsJsonAsync("/api/groups", dto);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}