public void StartRandom()
{
System.Random ran = new System.Random();
ran.Shuffle(mainArray);
ran.Shuffle(subArray);
setText(MainText, mainArray, 6);
setText(SubText, subArray, 1);
}
public List <CardData> GetCards()
{
if (cards.Count <= 8)
{
return(cards);
}
Random random = new Random();
int[] targetNumbers = new int[numberOfItems];
for (int i = 0; i < numberOfItems; i++)
{
targetNumbers[i] = random.Next(timeRanges.First().start, timeRanges.Last().end);
}
List <CardData> clampedCards = cards
.Where(x => x.value >= timeRanges.First().start&&
x.value <= timeRanges.Last().end)
.ToList();
CardData[] returnCards = new CardData[numberOfItems];
for (int i = 0; i < numberOfItems; i++)
{
CardData card = clampedCards.OrderBy(n => Math.Abs(n.value - targetNumbers[i])).First();
returnCards[i] = card;
clampedCards.Remove(card); // Make sure no duplicate cards happen
}
random.Shuffle(returnCards);
return(returnCards.ToList().GetRange(0, numberOfItems));
}
void Start()
{
int[] indices = new int[_size * _size - 1];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = i;
}
if (_randomize)
{
System.Random rng = new System.Random();
rng.Shuffle(indices);
}
for (int row = 0; row < _size; row++)
{
for (int col = 0; col < _size; col++)
{
int i = row * _size + col;
if (i < (_size * _size - 1))
{
Tile tile = Instantiate(_tilePrefab).GetComponent <Tile>();
tile.Index = indices[i];
tile.Row = row;
tile.Col = col;
_tiles[tile.Index] = tile;
UpdateTile(tile);
}
}
}
}
public void Start()
{
Shelf[] randomizedShelves = shelves;
System.Random rng = new System.Random();
rng.Shuffle(randomizedShelves);
SpawnProduct(randomizedShelves);
shelves = new Shelf[0];
Transform[] randomizeStacks = stacks;
rng = new System.Random();
rng.Shuffle(randomizeStacks);
for (int i = 0; i < stacks.Length; i++)
{
if (i < standsWithPaperCount)
{
SpawnStack(productPrefabs[0], 5, stacks[i].position);
}
else
{
Destroy(stacks[i].gameObject);
}
}
stacks = new Transform[0];
}
private void RandomGenerator()
{
GameObject[] nextBag = random.Shuffle(tetriminos);
for (int i = 0; i < nextBag.Length; i++)
{
generatedQueue.Enqueue(nextBag[i]);
}
}
//shuffles the choices, but ensuring the answer is at answer index (between 0 and 4[exclusive])
public List <String> ShuffleChoicesAndAnswer(int answerIndex)
{
List <string> temp = new List <string>(choices);
System.Random rng = new System.Random();
rng.Shuffle(temp);
temp.Insert(answerIndex, answer);
return(temp);
}
public void FromHexString()
{
Random random = new Random();
string value;
{
byte[] buffer = new byte[32];
random.NextBytes(buffer);
value = NetworkConverter.ToHexString(buffer);
}
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
for (int i = 0; i < 1024 * 1024 * 2; i++)
{
byte[] result1 = null;
byte[] result2 = null;
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
result1 = NetworkConverter.FromHexString(value);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
result2 = NetworkConverter.FromHexString_2(value);
sw2.Stop();
}
}
Assert.IsTrue(Unsafe.Equals(result1, result2));
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("FromHexString: " + sw1.Elapsed.ToString());
sb.AppendLine("FromHexString_2: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
public void Copy()
{
Random random = new Random();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
var length = 1024 * 256;
byte[] x1 = new byte[length];
byte[] y1 = new byte[length];
byte[] x2 = new byte[length];
byte[] y2 = new byte[length];
random.NextBytes(x1);
random.NextBytes(x2);
for (int i = 0; i < 1024 * 256; i++)
{
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
Unsafe.Copy(x1, 0, y1, 0, length);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
Array.Copy(x2, 0, y2, 0, length);
sw2.Stop();
}
}
Assert.IsTrue(Unsafe.Equals(x1, y1));
Assert.IsTrue(Unsafe.Equals(x2, y2));
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Native Copy: " + sw1.Elapsed.ToString());
sb.AppendLine("Array Copy: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
public List <int> PrepareSampleSpace(List <int> space, SampleMethod samplemethod)
{
switch (samplemethod)
{
case SampleMethod.Descending:
space.Reverse();
break;
case SampleMethod.UniformWithoutReplacement:
space = rng.Shuffle(space);
break;
default:
break;
}
return(space);
}
public void ToHexString()
{
Random random = new Random();
byte[] value = new byte[32];
random.NextBytes(value);
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
for (int i = 0; i < 1024 * 1024 * 2; i++)
{
string result1 = null;
string result2 = null;
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
result1 = NetworkConverter.ToHexString(value, 0, value.Length);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
result2 = NetworkConverter.ToHexString_2(value, 0, value.Length);
sw2.Stop();
}
}
Assert.IsTrue(result1 == result2);
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("ToHexString: " + sw1.Elapsed.ToString());
sb.AppendLine("ToHexString_2: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
public void Crc32_Castagnoli()
{
Random random = new Random();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
var length = 1024;
byte[] value = new byte[length];
for (int i = 0; i < 1024 * 1024; i++)
{
byte[] result1 = null;
byte[] result2 = null;
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
result1 = Library.Security.Crc32_Castagnoli.ComputeHash(value, 0, length);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
result2 = T_Crc32_Castagnoli.ComputeHash(value, 0, length);
sw2.Stop();
}
}
Assert.IsTrue(Unsafe.Equals(result1, result2));
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Unsafe Crc32_Castagnoli: " + sw1.Elapsed.ToString());
sb.AppendLine("Managed Crc32_Castagnoli: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
private void Awake()
{
var playerName = string.IsNullOrWhiteSpace(GetName.PlayerName) ? "Quandary" : GetName.PlayerName;
JsonData json = JsonMapper.ToObject(contentJson.text);
var characterModelList = new List <CharacterModel>();
foreach (JsonData characterJson in json)
{
var characterModel = new CharacterModel();
characterModel.ParseJson(characterJson, playerName);
characterModelList.Add(characterModel);
}
characterModels = characterModelList.ToArray();
characters = GetComponentsInChildren <Character>();
rnd = new Random(GetName.NameSeed);
rnd.Shuffle(characterModels);
menuDialog.SetActive(false);
}
public static void Main(string[] args)
{
System.Random TempRand = new System.Random();
Configuration Config = new Configuration(args);
using (var Bootstrapper = Utilities.IoC.Manager.Bootstrapper)
{
IEnumerable<IDataFormatter> Formatters = Bootstrapper.ResolveAll<IDataFormatter>();
if (Formatters.Count() == 0)
{
Console.WriteLine("No formatters found.");
return;
}
IEnumerable<ITimedTask> TimedTasks = TempRand.Shuffle(Bootstrapper.ResolveAll<ITimedTask>());
if (TimedTasks.Count() == 0)
{
Console.WriteLine("No tasks found.");
return;
}
using (var Profiler = Manager.StartProfiling())
{
foreach (ITimedTask Task in TimedTasks)
{
for (int x = 0; x < Config.NumberIterations; ++x)
{
using (var Timer = Manager.Profile(Task.Name))
{
Task.Run();
}
}
}
}
var Result = Manager.StopProfiling(false);
var Results = Result.Children
.ForEach(x => new Result(x.Value.Entries, x.Key))
.ToLookup(x => TimedTasks.FirstOrDefault(y => string.Equals(y.Name, x.Name, StringComparison.Ordinal))
.GetType()
.Attribute<SeriesAttribute>() as ISeries ?? new SeriesAttribute(""),
x => x);
Formatters.ForEach(x => x.Format(Results, Config.OutputDirectory));
}
}
public override bool RunProcess()
{
bool moved = false;
isVisited[currCellX, currCellY, 0] = true;
// Set the order to check for moving forward
//TODO: Maybe have different ways to randomize the dirs
// Such as weighting toward straight movement, left turns, etc
rand.Shuffle(dirs);
// Attempt to move forward
for (int i = 0; i < dirs.Length; i++)
{
// If valid forward move
if (CanMoveInDir(dirs[i], map, isVisited))
{
// Move forward
#if LOG_DEBUG
Debug.Log("Moving forward with dir: " + dirs[i].ToString());
#endif
MoveInDir(dirs[i], map);
previousPath.Push(dirs[i]);
moved = true;
break;
}
}
// Could not move forward, attempt to move backward
if (!moved && previousPath.Count > 0)
{
#if LOG_DEBUG
Debug.Log("Moving backward with dir opposite of: " + previousPath.Peek().ToString());
#endif
MoveInReverseDir(previousPath.Pop());
moved = true;
}
return(moved);
}
public void Equals()
{
Random random = new Random();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
for (int i = 0; i < 1024; i++)
{
byte[] x;
byte[] y;
if (random.Next(0, 2) == 0)
{
var length = random.Next(0, 1024 * 256);
x = new byte[length];
y = new byte[length];
}
else
{
x = new byte[random.Next(0, 1024 * 256)];
y = new byte[random.Next(0, 1024 * 256)];
}
if (random.Next(0, 3) == 0)
{
random.NextBytes(x);
random.NextBytes(y);
}
for (int j = 0; j < 32; j++)
{
bool result1 = false;
bool result2 = false;
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
result1 = Unsafe.Equals(x, y);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
result2 = Benchmark.Equals(x, y);
sw2.Stop();
}
}
Assert.IsTrue(result1 == result2);
}
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Native Equals: " + sw1.Elapsed.ToString());
sb.AppendLine("Unsafe Equals: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
public static void Shuffle <T>(this Random self, List <T> list)
{
self.Shuffle(list, list.Count);
}
internal WriteThreadsTest(int num_values=10, int checkpoint_interval_rowcount=50, bool withMerge=false)
{
System.GC.Collect();
db = new LayerManager(InitMode.NEW_REGION, "c:\\BENDtst\\11");
// db.startMaintThread();
this.checkpoint_interval = checkpoint_interval_rowcount;
this.withMerge = withMerge;
// init sequential data-values...
datavalues = new int[num_values];
for (int i = 0; i < num_values; i++) {
datavalues[i] = i;
}
// then shuffle them..
Random rnd = new Random();
rnd.Shuffle(datavalues);
}
private void PlaceWifiPoints()
{
//Debug.Log("Starting placing wifi points");
int childCount = transform.childCount;
for (int i = 1; i < childCount; i++)
{
DestroyImmediate(transform.GetChild(1).gameObject);
}
int totalAmount = mSquareAmount * mSquareAmount;
//Random IDs for random masking
float[] ids = new float[totalAmount];
List <float> test = new List <float>(5);
float fraction = 1f / (totalAmount - 1);
for (int i = 0; i < totalAmount; i++)
{
ids[i] = fraction * i;
}
System.Random rnd = new System.Random();
rnd.Shuffle <float>(ids);
//Debug.Log("IDs after randomization:" + ids.ToString());
List <WifiPoint> wifiPoints = new List <WifiPoint>(totalAmount);
#region Random Placing
float singleDistance = 1f / (mSquareAmount - 1) * mDistance * 2;
Vector3 startingPoint = transform.position - mDistance * Vector3.right - mDistance * Vector3.forward;
for (int i = 0; i < mSquareAmount; i++)
{
for (int j = 0; j < mSquareAmount; j++)
{
float randomX = mOffsetIntensityCurve.Evaluate(Random.value) * mRandomMaxOffset * (Random.value < 0.5 ? -1 : 1);
float randomZ = mOffsetIntensityCurve.Evaluate(Random.value) * mRandomMaxOffset * (Random.value < 0.5 ? -1 : 1);
Vector3 actualPosition = startingPoint + Vector3.right * (singleDistance * (j + randomX)) + Vector3.forward * (singleDistance * (i + randomZ));
WifiPoint newPoint = Instantiate(mPrefab, actualPosition, Quaternion.identity, transform).GetComponent <WifiPoint>();
newPoint.mIDMask = ids[i * mSquareAmount + j];
newPoint.mIDCounter = i * mSquareAmount + j;
wifiPoints.Add(newPoint);
//Debug.LogFormat("Placed a new point at {0} with ID {1}, actual number {2}", actualPosition, newPoint.mIDMask, i * mSquareAmount + j);
}
}
#endregion
#region Random Masking
for (int i = 0; i < wifiPoints.Count; i++)
{
if (wifiPoints[i].mIDMask < mRandomMask)
{
//Debug.LogFormat("Destroying the point number {0} with an ID of {1}", i, wifiPoints[i].mIDMask);
DestroyImmediate(wifiPoints[i].gameObject);
wifiPoints.RemoveAt(i);
i--;
}
}
#endregion
#region Removing points too close one another
RaycastHit[] hitInfos;
for (int i = 0; i < wifiPoints.Count; i++)
{
hitInfos = Physics.SphereCastAll(wifiPoints[i].transform.position, mMinDistanceBetweenPoints, Vector3.up, 0.1f, _WifiLayerMask);
foreach (RaycastHit hit in hitInfos)
{
WifiPoint wifiRef = hit.collider.GetComponent <WifiPoint>();
int ID = wifiRef.mIDCounter;
//Debug.LogFormat("Point {0} was too close so it's been removed", ID);
DestroyImmediate(hit.collider.gameObject);
wifiPoints.Remove(wifiRef);
}
}
#endregion
#region Removing pounts out of range distance
Vector2 maxXranges = Vector2.one * transform.position.x - Vector2.right * mDistance + Vector2.up * mDistance;
Vector2 maxZranges = Vector2.one * transform.position.z - Vector2.right * mDistance + Vector2.up * mDistance;
for (int i = 0; i < wifiPoints.Count; i++)
{
if (!maxXranges.WithinRange(wifiPoints[i].transform.position.x) || !maxZranges.WithinRange(wifiPoints[i].transform.position.z))
{
int ID = wifiPoints[i].mIDCounter;
DestroyImmediate(wifiPoints[i].gameObject);
wifiPoints.RemoveAt(i);
i--;
//Debug.LogFormat("Removed point {0} because it was out of range", ID);
}
}
#endregion
#region Link points
float closestDistance = Vector3.Distance(wifiPoints[0].transform.position, transform.position);
WifiPoint closestPoint = wifiPoints[0];
for (int i = 0; i < wifiPoints.Count; i++)
{
WifiPoint currentPoint = wifiPoints[i];
if (i != 0)
{
float currentDistance = Vector3.Distance(wifiPoints[i].transform.position, transform.position);
if (currentDistance < closestDistance)
{
closestDistance = currentDistance;
closestPoint = wifiPoints[i];
}
}
List <WifiPoint> currentLinkedPoints = new List <WifiPoint>();
for (int j = 0; j < wifiPoints.Count; j++)
{
WifiPoint currentSubPoint = wifiPoints[j];
if (j != i && Vector3.Distance(currentSubPoint.transform.position, currentPoint.transform.position) < mMaxDistanceLinkBetweenPoints)
{
currentLinkedPoints.Add(currentSubPoint);
}
}
currentPoint.mWifiPoints = currentLinkedPoints;
}
sClosestWifiPoint = closestPoint;
#endregion
}
public void Xor()
{
Random random = new Random();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
var flags = new int[] { 0, 1 };
for (int i = 0; i < 1024 * 4; i++)
{
byte[] x;
byte[] y;
if (random.Next(0, 2) == 0)
{
var length = random.Next(0, 1024 * 256);
x = new byte[length];
y = new byte[length];
}
else
{
x = new byte[random.Next(0, 1024 * 256)];
y = new byte[random.Next(0, 1024 * 256)];
}
random.NextBytes(x);
random.NextBytes(y);
byte[] result1 = new byte[Math.Min(x.Length, y.Length)];
byte[] result2 = new byte[Math.Min(x.Length, y.Length)];
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
Unsafe.Xor(x, y, result1);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
Benchmark.Xor(x, y, result2);
sw2.Stop();
}
}
Assert.IsTrue(Unsafe.Equals(result1, result2));
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Unsafe Xor: " + sw1.Elapsed.ToString());
sb.AppendLine("Managed Xor: " + sw2.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
public static void Shuffle <T>(this Random self, T[] array)
{
self.Shuffle(array, array.Length);
}
public void Compare()
{
Random random = new Random();
Stopwatch totalStopwatch = new Stopwatch();
totalStopwatch.Start();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
Stopwatch sw3 = new Stopwatch();
Stopwatch sw4 = new Stopwatch();
var flags = new int[] { 0, 1, 2, 3 };
for (int i = 0; i < 1024 * 256 * 32; i++)
{
byte[] x;
byte[] y;
if (random.Next(0, 2) == 0)
{
var length = random.Next(0, 1024);
x = new byte[length];
y = new byte[length];
}
else
{
x = new byte[random.Next(0, 1024)];
y = new byte[random.Next(0, 1024)];
}
if (random.Next(0, 2) == 0)
{
random.NextBytes(x);
random.NextBytes(y);
}
int result1 = 0;
int result2 = 0;
int result3 = 0;
int result4 = 0;
var maxLength = Math.Min(x.Length, y.Length);
random.Shuffle(flags);
foreach (var index in flags)
{
if (index == 0)
{
sw1.Start();
result1 = Unsafe.Compare(x, y);
sw1.Stop();
}
else if (index == 1)
{
sw2.Start();
result2 = Unsafe.Compare2(x, y);
sw2.Stop();
}
else if (index == 2)
{
sw3.Start();
result3 = Unsafe.Compare(x, 0, y, 0, maxLength);
sw3.Stop();
}
else if (index == 3)
{
sw4.Start();
result4 = Unsafe.Compare2(x, 0, y, 0, maxLength);
sw4.Stop();
}
}
Assert.IsTrue(result1 == result2);
Assert.IsTrue(result3 == result4);
if (totalStopwatch.ElapsedMilliseconds > 1000 * 60) break;
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Native Compare: " + sw1.Elapsed.ToString());
sb.AppendLine("Native Compare2: " + sw2.Elapsed.ToString());
sb.AppendLine("Native Compare: " + sw3.Elapsed.ToString());
sb.AppendLine("Native Compare2: " + sw4.Elapsed.ToString());
Console.WriteLine(sb.ToString());
}
private void DownloadManagerThread()
{
Random random = new Random();
int round = 0;
for (; ; )
{
Thread.Sleep(1000 * 3);
if (this.State == ManagerState.Stop) return;
BackgroundDownloadItem item = null;
try
{
lock (this.ThisLock)
{
if (_settings.BackgroundDownloadItems.Count > 0)
{
{
var items = _settings.BackgroundDownloadItems
.Where(n => n.State == BackgroundDownloadState.Downloading)
.Where(x =>
{
if (x.Rank == 1) return 0 == (!_cacheManager.Contains(x.Seed.Key) ? 1 : 0);
else return 0 == (x.Index.Groups.Sum(n => n.InformationLength) - x.Index.Groups.Sum(n => Math.Min(n.InformationLength, _existManager.GetCount(n))));
})
.ToList();
item = items.FirstOrDefault();
}
if (item == null)
{
var items = _settings.BackgroundDownloadItems
.Where(n => n.State == BackgroundDownloadState.Downloading)
.ToList();
if (items.Count > 0)
{
round = (round >= items.Count) ? 0 : round;
item = items[round++];
}
}
}
}
}
catch (Exception)
{
return;
}
if (item == null) continue;
try
{
if (item.Rank == 1)
{
if (!_cacheManager.Contains(item.Seed.Key))
{
item.State = BackgroundDownloadState.Downloading;
_connectionsManager.Download(item.Seed.Key);
}
else
{
item.State = BackgroundDownloadState.Decoding;
}
}
else
{
if (!item.Index.Groups.All(n => _existManager.GetCount(n) >= n.InformationLength))
{
item.State = BackgroundDownloadState.Downloading;
int limitCount = 256;
foreach (var group in item.Index.Groups.ToArray().Randomize())
{
if (_existManager.GetCount(group) >= group.InformationLength) continue;
foreach (var key in _existManager.GetKeys(group, false))
{
if (_connectionsManager.IsDownloadWaiting(key))
{
limitCount--;
if (limitCount <= 0) goto End;
}
}
}
List<Key> keyList = new List<Key>();
foreach (var group in item.Index.Groups.ToArray().Randomize())
{
if (_existManager.GetCount(group) >= group.InformationLength) continue;
List<Key> tempKeys = new List<Key>();
foreach (var key in _existManager.GetKeys(group, false))
{
if (!_connectionsManager.IsDownloadWaiting(key))
{
tempKeys.Add(key);
}
}
random.Shuffle(tempKeys);
foreach (var key in tempKeys)
{
_connectionsManager.Download(key);
limitCount--;
}
if (limitCount <= 0) goto End;
}
End: ;
}
else
{
item.State = BackgroundDownloadState.Decoding;
}
}
}
catch (Exception e)
{
item.State = BackgroundDownloadState.Error;
Log.Error(e);
this.Remove(item);
}
}
}
public static void Shuffle <T>(this Random self, List <T> list, int end)
{
self.Shuffle(list, 0, end);
}
public void Shuffle()
{
System.Random Rand = new System.Random(1231415);
Assert.Equal(new int[] { 3, 1, 4, 5, 2 }, Rand.Shuffle(new int[] { 1, 2, 3, 4, 5 }));
}
public NormalRoom(NormalRoom prev, Random rand, bool noEvil)
{
var indexes = Enumerable.Range(0, roomTemplates.Length).ToList();
rand.Shuffle(indexes);
foreach (var index in indexes) {
if (prev != null && index == prev.currentId)
continue;
if ((roomTemplates[index].Flags & RoomFlags.Evil) != 0 && noEvil)
continue;
if (prev != null) {
bool ok = false;
foreach (var conn in prev.ConnectionPoints) {
var d = conn.Item1.Reverse();
if (roomTemplates[index].Connections.Any(targetConn => targetConn.Item1 == d)) {
ok = true;
break;
}
}
if (!ok)
continue;
}
currentId = index;
}
current = roomTemplates[currentId];
}
private void DownloadThread()
{
var random = new Random();
int round = 0;
for (;;)
{
Thread.Sleep(1000 * 1);
if (this.State == ManagerState.Stop) return;
DownloadItem item = null;
try
{
lock (_thisLock)
{
if (_settings.DownloadItems.Count > 0)
{
{
var items = _settings.DownloadItems
.Where(n => n.State == DownloadState.Downloading)
.Where(n => n.Priority != 0)
.Where(x =>
{
if (x.Depth == 1) return 0 == (!_cacheManager.Contains(x.Seed.Metadata.Key) ? 1 : 0);
else return 0 == (x.Index.Groups.Sum(n => n.InformationLength) - x.Index.Groups.Sum(n => Math.Min(n.InformationLength, _existManager.GetCount(n))));
})
.ToList();
item = items.FirstOrDefault();
}
if (item == null)
{
var items = _settings.DownloadItems
.Where(n => n.State == DownloadState.Downloading)
.Where(n => n.Priority != 0)
.OrderBy(n => -n.Priority)
.ToList();
if (items.Count > 0)
{
round = (round >= items.Count) ? 0 : round;
item = items[round++];
}
}
}
}
}
catch (Exception)
{
return;
}
if (item == null) continue;
try
{
if (item.Depth == 1)
{
if (!_cacheManager.Contains(item.Seed.Metadata.Key))
{
item.State = DownloadState.Downloading;
_connectionsManager.Download(item.Seed.Metadata.Key);
}
else
{
item.State = DownloadState.Decoding;
}
}
else
{
if (!item.Index.Groups.All(n => _existManager.GetCount(n) >= n.InformationLength))
{
item.State = DownloadState.Downloading;
var limitCount = (int)(256 * Math.Pow(item.Priority, 3));
foreach (var group in item.Index.Groups.ToArray().Randomize())
{
if (_existManager.GetCount(group) >= group.InformationLength) continue;
foreach (var key in _existManager.GetKeys(group, false))
{
if (_connectionsManager.IsDownloadWaiting(key))
{
limitCount--;
if (limitCount <= 0) goto End;
}
}
}
foreach (var group in item.Index.Groups.ToArray().Randomize())
{
if (_existManager.GetCount(group) >= group.InformationLength) continue;
var tempKeys = new List<Key>();
foreach (var key in _existManager.GetKeys(group, false))
{
if (!_connectionsManager.IsDownloadWaiting(key))
{
tempKeys.Add(key);
}
}
random.Shuffle(tempKeys);
foreach (var key in tempKeys)
{
_connectionsManager.Download(key);
limitCount--;
}
if (limitCount <= 0) goto End;
}
End:;
}
else
{
item.State = DownloadState.ParityDecoding;
}
}
}
catch (Exception e)
{
item.State = DownloadState.Error;
Log.Error(e);
}
}
}
public void Shuffle()
{
var Rand = new System.Random(1231415);
Assert.Equal(new int[] { 3, 1, 4, 5, 2 }, Rand.Shuffle(new int[] { 1, 2, 3, 4, 5 }));
}
public static void Shuffle <T>(this Random self, T[] array, int end)
{
self.Shuffle(array, 0, end);
}
