public void Sync(SortableObservableCollection <T> list)
{
lock (locker)
{
lock (list.locker)
{
var firstCount = list.Count;
for (int j = 0; j < list.Count; j++)
{
Debug.Assert(firstCount == list.Count);
if (this.Count - 1 < j)
{
this.Add(list[j]);
}
var item1 = this[j];
var item2 = list[j];
if (item1.Equals(item2))
{
continue;
}
this.SetItem(j, item2);
}
while (this.Count > firstCount)
{
this.RemoveAt(this.Count - 1);
}
}
}
}
public static void Foreach(SortableObservableCollection <T> source, Action <T> action)
{
if (myThreads.Count == 0)
{
for (int i = 0; i < 2; i++)
{
var thread = new Thread(ProcessThreadQueue);
var wrapper = new ThreadWrapper()
{
Thread = thread, Id = counter++
};
myThreads.Add(wrapper);
queues.Add(wrapper.Id, new ConcurrentQueue <MyActionWrapper <T> >());
}
foreach (var myThread in myThreads)
{
myThread.Thread.Start(myThread);
}
}
Debug.Assert(_processedCount == 0);
for (int i = 0; i < source.Count(); i++)
{
Interlocked.Increment(ref _processedCount);
var index = i % (myThreads.Count);
var thread = myThreads[index];
var queue = queues[thread.Id];
queue.Enqueue(new MyActionWrapper <T>(action, source[i]));
}
while (_processedCount > 0)
{
Thread.Sleep(1);
}
//foreach (var myThread in myThreads)
//{
// myThread.Thread.Abort();
//}
//myThreads.Clear();
}
public void GenerateNumbersBuyTickets(Player player, SortableObservableCollection <NumberStat> stats)
{
player.LuckyNumbers.Clear();
if (prevNumbers.Count > 0)
{
var array = new HashSet <int>();
while (array.Count < player.LuckyAmount)
{
var index = player.Random.Next(0, generator.MaxNumbers);
var number = prevNumbers[index];
array.Add(number);
}
Debug.Assert(array.Count <= 10);
foreach (var number in array)
{
player.LuckyNumbers.Add(number);
}
}
Debug.Assert(player.LuckyAmount <= 10);
Debug.Assert(player.LuckyNumbers.Count <= 10);
{
while (player.Tickets.Count < player.NumberOfTickets)
{
var ticket = new Ticket();
foreach (var luckyNumber in player.LuckyNumbers)
{
ticket.Numbers.Add(luckyNumber);
}
if (player.HotNumbers > 0)
{
while (ticket.Numbers.Count < player.HotNumbers)
{
var hotindex = random.Next(0, player.HotRange);
if (!ticket.Numbers.Contains(stats[hotindex].Number))
{
ticket.Numbers.Add(stats[hotindex].Number);
}
}
}
if (player.ColdNumbers > 0)
{
var coldRange = player.ColdRange;
while (ticket.Numbers.Count < player.ColdNumbers + player.HotNumbers)
{
var coldindex = random.Next(0, coldRange);
var stat = stats.Get(stats.Count - (coldindex + 1));
if (!ticket.Numbers.Contains(stat.Number))
{
ticket.Numbers.Add(stat.Number);
}
else
{
coldRange++;
}
}
}
ticket.Numbers = GenerateRandomsArray(player.System, ticket.Numbers, random);
player.Tickets.Add(ticket);
}
for (int j = 0; j < player.Tickets.Count; j++)
{
var currentTicket = player.Tickets[j];
if (player.LuckyAmount != player.System || currentTicket.IsWon)
{
currentTicket.Numbers = GenerateRandomsArray(player.System, currentTicket.Numbers, random);
}
currentTicket.Stake = player.Stake;
}
}
foreach (var ticket in player.Tickets)
{
player.Money -= ticket.Stake;
player.SpendMoney += ticket.Stake;
if (player.Money < 0)
{
ticket.Stake = 0;
}
}
}
public void ProcessGames()
{
int counter = PlayerCounter;
while (generator.HaveNext)
{
var start = DateTime.UtcNow;
// MyThreadPool<Player>.Foreach(Players, player =>
foreach (var player in Players)
{
var tempStat = new SortableObservableCollection <NumberStat>();
tempStat.Sync(NumbersStatistic);
if (player.ColdNumbers + player.HotNumbers > 0)
{
var player1 = player;
tempStat.Sort(x => x.TimesAppear(player1.StatRange), ListSortDirection.Descending);
}
GenerateNumbersBuyTickets(player, tempStat);
player.CurrentMinus += player.Tickets.Count * player.Stake;
}
var numbers = generator.Generate();
prevNumbers = numbers.ToList();
foreach (var numberStat in NumbersStatistic)
{
numberStat.Appear(numbers.Contains(numberStat.Number));
}
SortableObservableCollection <Player> lostPlayers = new SortableObservableCollection <Player>();
foreach (var player in Players)
{
var moneyWon = Calculate.CalculateTickets(numbers, player.Tickets);
player.Money += moneyWon;
if (moneyWon == 0)
{
player.NumberOfTickets += player.TicketChangeLost;
if (player.TicketChangeLost < 0)
{
while (player.Tickets.Count > player.NumberOfTickets && player.Tickets.Count > 1)
{
player.Tickets.RemoveAt(player.Tickets.Count - 1);
}
}
}
if (moneyWon > 0)
{
player.NumberOfTickets += player.TicketChangeWon;
if (player.TicketChangeWon < 0)
{
while (player.Tickets.Count > player.NumberOfTickets && player.Tickets.Count > 1)
{
player.Tickets.RemoveAt(player.Tickets.Count - 1);
}
}
}
var currentMinus = moneyWon - player.CurrentMinus;
if (currentMinus < 0)
{
player.CurrentMinus = -currentMinus;
}
else
{
player.CurrentMinus = 0;
}
// if (player.CurrentMinus > startMoney)
// lostPlayers.Add(player);
if (player.Money <= 0)
{
lostPlayers.Add(player);
}
player.NumberOfTickets = player.Tickets.Count;
player.GamesPlayed++;
}
foreach (var player in lostPlayers)
{
counter = RemoveAndCreateNewPlayer(player, counter);
}
GamesPlayed++;
if (Players.Count < 500)
{
counter = CreateChildren(counter);
}
if (generator.isLast)
{
foreach (var player in Players)
{
player.Money = startMoney;
}
}
while (Players.Count > 1000)
{
Players.RemoveAt(Players.Count - 1);
}
PlayerCounter = Players.Count;
if (GamesPlayed % 20 == 0)
{
if (Dispatcher.Thread.IsAlive)
{
Dispatcher.Invoke(() =>
{
DPlayers.Sync(Players);
DTopPlayers.Sync(TopPlayers);
});
}
}
var end = DateTime.UtcNow;
Console.WriteLine(end - start);
//haveChanges = true;
}
Players.Sort(x => x.Money, ListSortDirection.Descending);
Dispatcher.Invoke(() =>
{
DPlayers.Sync(Players);
DTopPlayers.Sync(TopPlayers);
});
}
