public int CompareTo(IQueueable item)
{
if (CTR < item.CTR)
{
return(-1);
}
if (CTR > item.CTR)
{
return(1);
}
if (Priority < item.Priority)
{
return(-1);
}
if (Priority > item.Priority)
{
return(1);
}
if (ID < item.ID)
{
return(-1);
}
if (ID > item.ID)
{
return(1);
}
return(0); //this should never happen
}
public DataFeed(IQueueable <DataMessage> dataQueue, IDataFeed <DataMessage> feed)
{
_Queue = dataQueue;
_Feed = feed;
_Feed.EnqueDataMessage = processDataMessage;
}
public void Queue_CountIsProperlyChanged(IQueueable <int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(queue.Dequeue());
Assert.Equal(2, queue.Count);
}
public void Queue_DeletedFromEmpty_ShouldThrowInvalidOperation(IQueueable <int> queue)
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
queue.Dequeue();
});
}
public void CreateJob(IQueueable item, Tile tile)
{
JobType jobType = JobType.Idle;
if (item.GetType() == typeof(Wall))
{
jobType = JobType.Building;
Wall wall = item as Wall;
wall.BlueprintType = BlueprintType.Stockpile;
}
Job job = new Job(tile, jobType);
job.JobObjectPrototype = item;
job.JobComplete += OnJobComplete;
job.JobCancel += OnJobCancel;
tile.Enterability = EnterabilityType.IsEnterable;
tile.Blueprint = item;
tile.IsOccupied = true;
_jobs.Add(job, item);
JobQueue.Enqueue(job);
}
protected CommandButton(ICommand command, IQueueable <TextureValue> queueableObject, Point Size)
{
this.bounds = new Rectangle(queueableObject.Position.ToPoint(), Size);
this.Position = queueableObject.Position;
this.picture = ContentHandler.DrawnTexture(queueableObject.Icon);
this.command = command;
}
public void Queue_DeletedFromEmpty_ShouldThrowInvalidOperation(IQueueable<int> queue)
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
queue.Dequeue();
});
}
public void Queue_CountIsProperlyChanged(IQueueable<int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(queue.Dequeue());
Assert.Equal(2, queue.Count);
}
//this method is called every second
public IQueueable <TextureValue> Train(GraphicsDevice gd)
{
if (trainingQueue.Count > 0)
{
trainingObject = trainingQueue.Peek();
if (trainingObject is IEntity)
{
if (((IEntity)trainingObject).CurrentHealth >= ((IEntity)trainingObject).TotalHealth)
{
if (trainingObject is BasicUnit)
{
((BasicUnit)trainingObject).UpdatePosition(gd, spawnPoint);
//((BasicUnit)trainingObject).PlacedTile(gd);
((BasicUnit)trainingObject).SetTeam(this.TeamAssociation);
}
return(trainingQueue.Dequeue());
}
((BasicUnit)trainingObject).CurrentHealth += 10f;//this probably should be updated too
}
else if (trainingObject is ITech)
{
if (trainTimer >= ((Technology)trainingObject).LearnTime)
{
trainTimer = 0;
Learn((ITech)trainingObject);
trainingQueue.Dequeue();
return(null);
}
trainTimer++;//Since it's supposed to be called every one second it's fair to add 1 every time
}
}
return(null);
}
/// <summary>
/// Add a new entitity to the queue
/// </summary>
/// <param name="elem">The queueing entity</param>
/// <param name="bloctime">Time the entity will block others</param>
public void Add(IQueueable elem, uint bloctime, DESF.Flow.Event.Event ev)
{
Flow.Calendar.Term term = new Flow.Calendar.Term(_context.Calendar.Time + _length + bloctime, this, "ElementEjected", null);
_elements.Add(new QueueElement(elem, bloctime, _context.Calendar.Time, term, ev));
_context.Calendar.AddTerm(term);
_length += bloctime;
_context.Logger.Log(this, String.Format("Added new element. Bloctime: {0}, new length: {1}, elements: {2}", bloctime, _length, MembersCount), 9);
}
public void Queue_Cleared(IQueueable <int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
queue.Clear();
Assert.Equal(0, queue.Count);
}
public void Queue_Cleared(IQueueable<int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
queue.Clear();
Assert.Equal(0, queue.Count);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="elem">Object to be queued</param>
/// <param name="btime">Time it will take to finish it's buissines</param>
/// <param name="term">Term created for calendar callback</param>
public QueueElement(IQueueable elem, uint btime, uint timecame, Flow.Calendar.Term term, DESF.Flow.Event.Event ev)
{
_element = elem;
_blockingTime = btime;
_timeCame = timecame;
_term = term;
_event = ev;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="elem">Object to be queued</param>
/// <param name="btime">Time it will take to finish it's buissines</param>
/// <param name="term">Term created for calendar callback</param>
public QueueElement(IQueueable elem, uint btime, uint timecame, Flow.Calendar.Term term, DESF.Flow.Event.Event ev)
{
_element = elem;
_blockingTime = btime;
_timeCame = timecame;
_term = term;
_event = ev;
}
public void Enqueue <TEnqueued>(IQueueable job) where TEnqueued : IEnqueued
{
var jobId = BackgroundJob.Enqueue(job.Operation);
var result = (IEnqueued)Activator.CreateInstance(typeof(TEnqueued));
result.Id = Guid.Parse(jobId);
}
public void Queue_PeekedAndDequeuedAreEqual(IQueueable <int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
var temp = queue.Peek();
Assert.Equal(temp, queue.Dequeue());
}
public void Queue_MultipleItemsStored(IQueueable <int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
Assert.Equal(42, queue.Dequeue());
Assert.Equal(37, queue.Dequeue());
Assert.Equal(100500, queue.Dequeue());
}
public void Execute(IQueueable queueable, QueueItemType type)
{
using (var context = new QueueContext(_appSettingsService.ConnectionString))
{
var queueItem = new QueueItem(type, JsonConvert.SerializeObject(queueable));
context.QueueItems.Add(queueItem);
context.SaveChanges();
}
}
public virtual int GetPositionInQueue(IQueueable queueable)
{
if (queue.Contains(queueable))
{
return(queue.IndexOf(queueable));
}
else
{
return(queue.Count);
}
}
public void Queue_PeekedFromClear_ShouldThrowInvalidOperation(IQueueable <int> queue)
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
queue.Clear();
queue.Peek();
});
}
public void Begin()
{
if (_queue.Count > 0)
{
_current = _queue.Dequeue();
_current.OnEnded += OnCurrentEnded;
_current.OnKilled += OnCurrentKilled;
_current.Begin();
}
OnBegan.Execute(this);
}
public void Kill()
{
if (_current != null)
{
_current.OnEnded -= OnCurrentEnded;
_current.OnKilled -= OnCurrentKilled;
_current.Kill();
_current = null;
}
OnKilled.Execute(this);
}
public void update()
{
activeItem = queue.getActiveItem();
if (activeItem != null)
{
activeItem.invoke(map, units, queue);
}
queue.update();
}
public void Queue_IEnumerableImplemented(IQueueable<int> queue)
{
int[] array = { 42, 37, 100500 };
foreach (var t in array) //t -> temp
{
queue.Enqueue(t);
}
var i = 0;
foreach (var temp in queue)
{
Assert.Equal(temp, array[i]);
i++;
}
}
public void RemoveFromQueue(IQueueable itemInQueue)
{
Queue.Remove(itemInQueue);
if (Queue.Count <= 0)
{
UpdateInfo(this, 0); return;
}
var firstItem = Queue[0];
if (itemInQueue != firstItem)
{
_timeSpentBuilding = 0;
UpdateBuildInfo(firstItem.Time);
}
}
public void Queue_IEnumerableImplemented(IQueueable <int> queue)
{
int[] array = { 42, 37, 100500 };
foreach (var t in array) //t -> temp
{
queue.Enqueue(t);
}
var i = 0;
foreach (var temp in queue)
{
Assert.Equal(temp, array[i]);
i++;
}
}
public async Task Command(params int[] args)
{
LavaPlayer player = ConfigProperties.LavaNode.GetPlayer(Context.Guild);
PlayerState playerState = player.PlayerState;
DefaultQueue <IQueueable> queue = player.Queue;
if (!(playerState == PlayerState.Playing || playerState == PlayerState.Paused) || !queue.Any())
{
await SendBasicErrorEmbedAsync("The player must be either playing " +
"or paused and must have at least 1 song " +
"in the queue.");
return;
}
int failedAttempts = 0;
const int LIMIT_ATTEMPTS = 3; // Maximum amount of error messages to send in one session.
var descSb = new StringBuilder();
foreach (int num in args.OrderByDescending(x => x))
{
if (failedAttempts >= LIMIT_ATTEMPTS)
{
return;
}
IQueueable match = queue.ElementAtOrDefault(num - 1);
if (match == null)
{
await SendBasicErrorEmbedAsync($"{Context.User.Mention} There is no track `#{num}` in the current queue.");
failedAttempts++;
continue;
}
player.Queue.RemoveAt(num - 1);
descSb.AppendLine($"Successfully removed track `#{num}`.");
}
var embed = new KaguyaEmbedBuilder
{
Description = descSb.ToString()
};
await SendEmbedAsync(embed);
}
public static BattleUnit getActiveUnit()
{
BattleUnit unit = null;
IQueueable activeItem = instance.queue.getActiveItem();
if (activeItem != null)
{
if (activeItem.GetType() == typeof(BattleUnit))
{
unit = (BattleUnit)activeItem;
}
}
return(unit);
}
// Producer
public bool Add(IQueueable item)
{
if (item.IsCompleted || _queueList.Contains(item))
{
return(true);
}
if (_queueList.TryAdd(item))
{
if (!HasItems)
{
HasItems = true;
RaisePropertyChanged(nameof(this.HasItems));
}
return(true);
}
return(false);
}
/// <summary>
/// Withdraws the element from the queue before its' schedule. Reorders left queuers
/// </summary>
/// <param name="queuer">The entity to be dropped</param>
public void Remove(IQueueable queuer)
{
//throw new NotImplementedException("To be implemented. And I will, that I swear before my God. May he strike me down with fury and anger if do not!");
/*_context.Logger.Log(this, String.Format("{0} is quitting the queue", queuer), 8);
*
* // do we have it?
* bool exists = false;
* foreach ( QueueElement elem in _elements)
* {
* if (elem.Element == queuer)
* {
* exists = true;
* }
* }
* if (!exists)
* {
* throw new ArgumentException("Given element is not present in this queue");
* }
*
* List<QueueElement> origElems = _elements;
* bool first = true;
* _elements = new List<QueueElement>();
* _length = 0;
* // will look up the element in local register and then reconstruct the calendar terms
* foreach (QueueElement elem in origElems)
* {
* if (first)
* {
* if (!(elem.Element == queuer))
* {
* Add(elem.Element, elem.BlockingTime - _context.Calendar.Time + elem.TimeCame,elem.Event);
* }
* }
* else
* {
* if (elem.Element != queuer)
* {
* //neat code reuse :]
* Add(elem.Element, elem.BlockingTime,elem.Event);
* }
* }
* }*/
}
/// <summary>
/// Actual training update loop - returns the units that are at full health(AKA fully trained)
/// </summary>
private void Train()
{
if (resources.Count(new Energy()) > 0)//Shut off training if out of power
{
Building[] buildings = world.GetTiles(Team).Where(l => l is Building).Cast <Building>().ToArray();
for (int i = 0; i < buildings.Length; i++)
{
IQueueable <TextureValue> item = buildings[i].Train(Game.GraphicsDevice);
if (item != null)
{
if (item is BasicUnit)
{
((BasicUnit)item).Move(buildings[i].GetSpawn(), world);
world.AddMob((BasicUnit)item);
}
}
}
}
}
private void Enqueue(IQueueable queueable, string serviceName, string methodName)
{
try
{
_queueService.Execute(queueable, queueable.QueueItemType);
}
catch (Exception qex)
{
var queueErrorMsgToLog = $"{serviceName}.{methodName} | An exception has occurred on {serviceName} trying to enqueue data | errorMessage ={qex.Message}";
if (IsLogService(serviceName))
{
_logService.FileSystemLog(queueErrorMsgToLog);
}
else
{
_logService.LogErrorMessageAsync(queueErrorMsgToLog);
}
}
}
private void ProcessQueue()
{
if (Queue.Count > 0)
{
_timeSpentBuilding += Time.deltaTime;
IQueueable firstItem = Queue[0];
float timeNeeded = firstItem.Time;
UpdateBuildInfo(timeNeeded);
if (_timeSpentBuilding >= timeNeeded)
{
firstItem.OnProductionComplete(this);
Queue.Remove(firstItem);
if (Queue.Count <= 0)
{
UpdateInfo(this, 0);
}
_timeSpentBuilding = 0;
}
}
}
public ParallelQueueableExecutor(IQueueable single)
{
AddQueueable(single);
}
/// <summary>
/// Add a new entitity to the queue
/// </summary>
/// <param name="elem">The queueing entity</param>
/// <param name="bloctime">Time the entity will block others</param>
public void Add(IQueueable elem, uint bloctime, DESF.Flow.Event.Event ev)
{
Flow.Calendar.Term term = new Flow.Calendar.Term(_context.Calendar.Time + _length + bloctime, this, "ElementEjected", null);
_elements.Add(new QueueElement(elem, bloctime, _context.Calendar.Time, term,ev));
_context.Calendar.AddTerm(term);
_length += bloctime;
_context.Logger.Log(this, String.Format("Added new element. Bloctime: {0}, new length: {1}, elements: {2}", bloctime, _length, MembersCount), 9);
}
private void OnEntryEnded(IQueueable obj)
{
obj.OnEnded -= OnEntryEnded;
obj.OnKilled -= OnEntryKilled;
_inProgress.Remove(obj);
if (_inProgress.Count == 0) { OnEnded.Execute(this); }
}
private void OnCurrentEnded(IQueueable obj)
{
_current.OnKilled -= OnCurrentKilled;
_current.OnEnded -= OnCurrentEnded;
if (_queue.Count > 0)
{
_current = _queue.Dequeue();
_current.OnEnded += OnCurrentEnded;
_current.OnKilled += OnCurrentKilled;
_current.Begin();
}
else
{
OnEnded.Execute(this);
}
}
public void Queue_EnqueuedDequeued(IQueueable <int> queue)
{
queue.Enqueue(42);
Assert.Equal(42, queue.Dequeue());
}
private void OnEntryKilled(IQueueable obj)
{
obj.OnEnded -= OnEntryEnded;
obj.OnKilled -= OnEntryKilled;
_inProgress.Remove(obj);
Kill();
}
public void Queue(IQueueable queueable)
{
_queue.Enqueue(queueable);
}
public void Queue_PeekedAndDequeuedAreEqual(IQueueable<int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
var temp = queue.Peek();
Assert.Equal(temp, queue.Dequeue());
}
public void Queue_EnqueuedDequeued(IQueueable<int> queue)
{
queue.Enqueue(42);
Assert.Equal(42, queue.Dequeue());
}
public SerialQueueableExecutor(IQueueable[] queue)
{
foreach (var entry in queue) { Queue(entry); }
}
private void OnCurrentKilled(IQueueable obj)
{
_current.OnKilled -= OnCurrentKilled;
_current.OnEnded -= OnCurrentEnded;
OnKilled.Execute(this);
}
public virtual void Enqueue(IQueueable queueable)
{
queue.Add(queueable);
queueable.OnEnqueue(this);
}
public void AddQueueable(IQueueable queueable)
{
_notInProgress.Add(queueable);
}
public virtual void Remove(IQueueable queueable)
{
queue.Remove(queueable);
}
public void Queue_MultipleItemsStored(IQueueable<int> queue)
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
Assert.Equal(42, queue.Dequeue());
Assert.Equal(37, queue.Dequeue());
Assert.Equal(100500, queue.Dequeue());
}
public ParallelQueueableExecutor(IQueueable[] list)
{
list.ForEach(entry => AddQueueable(entry));
}
public SerialQueueableExecutor(IQueueable entry)
{
Queue(entry);
}
/// <summary>
/// Withdraws the element from the queue before its' schedule. Reorders left queuers
/// </summary>
/// <param name="queuer">The entity to be dropped</param>
public void Remove(IQueueable queuer)
{
//throw new NotImplementedException("To be implemented. And I will, that I swear before my God. May he strike me down with fury and anger if do not!");
/*_context.Logger.Log(this, String.Format("{0} is quitting the queue", queuer), 8);
// do we have it?
bool exists = false;
foreach ( QueueElement elem in _elements)
{
if (elem.Element == queuer)
{
exists = true;
}
}
if (!exists)
{
throw new ArgumentException("Given element is not present in this queue");
}
List<QueueElement> origElems = _elements;
bool first = true;
_elements = new List<QueueElement>();
_length = 0;
// will look up the element in local register and then reconstruct the calendar terms
foreach (QueueElement elem in origElems)
{
if (first)
{
if (!(elem.Element == queuer))
{
Add(elem.Element, elem.BlockingTime - _context.Calendar.Time + elem.TimeCame,elem.Event);
}
}
else
{
if (elem.Element != queuer)
{
//neat code reuse :]
Add(elem.Element, elem.BlockingTime,elem.Event);
}
}
}*/
}
public bool Contains(IQueueable value)
{
return(_queueList.Contains(value));
}
public void Queue_PeekedFromClear_ShouldThrowInvalidOperation(IQueueable<int> queue)
{
Assert.Throws(typeof(InvalidOperationException), () =>
{
queue.Enqueue(42);
queue.Enqueue(37);
queue.Enqueue(100500);
queue.Clear();
queue.Peek();
});
}
