/// <summary>
/// Deliver me
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverAct(string Message, string Channel, priority Pr = priority.normal)
{
// first of all we check if we are in correct instance
if (Channel.StartsWith("#"))
{
config.channel ch = core.getChannel(Channel);
if (ch == null)
{
core.Log("Not sending message to unknown channel: " + Channel);
return;
}
// this is wrong instance so let's put this message to correct one
if (ch.instance != Parent.ParentInstance)
{
ch.instance.irc._SlowQueue.DeliverAct(Message, Channel, Pr);
return;
}
}
Message text = new Message {
_Priority = Pr, message = Message, channel = Channel
};
lock (messages)
{
messages.Add(text);
}
}
public ActionsToDo(action targetAction, int targetObjectTypeID, priority targetPriority, parameters targetParameters)
{
_action = targetAction;
_priority = targetPriority;
_objectTypeID = targetObjectTypeID;
_parameters = targetParameters;
}
public ActionResult DeleteConfirmed(byte id)
{
priority priority = db.priorities.Find(id);
db.priorities.Remove(priority);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "id,priorityname")] priority priority)
{
if (ModelState.IsValid)
{
db.Entry(priority).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(priority));
}
public Part()
{
this.position_x = 0.0d;
this.position_y = 0.0d;
this.is_placed = true;
this.part_orientation = rotation.top;
this.placement_priority = priority.normal;
this.clashes = false;
this.border_mm = 0.0d;
}
private bool makedecision()
{
candidates.AddRange(makedecisions(gatherinfo()));
if (candidates.Count <= 0)
{
return(false);
}
switch (type)
{
case normalunit:
{
//우선도
priority p = new priority();
foreach (UnitAction.act c in candidates)
{
switch (c.type)
{
case "useweapon":
{
p.add("unitact", c, 3);
}
break;
case "movedest":
{
p.add("unitact", c, 2);
}
break;
default:
{
p.add("unitact", c, 1);
}
break;
}
}
decision = (UnitAction.act)p.getrandom_priority().msg;
Debug.Log("Decision set");
}
break;
case building:
{
}
break;
}
candidates.Clear();
return(true);
}
/// <summary>
/// Send a command to server
/// </summary>
/// <param name="Data"></param>
/// <param name="Priority"></param>
public void Send(string Data, priority Priority = priority.high)
{
Message text = new Message {
_Priority = Priority, channel = null, message = Data, command = true
};
lock (messages)
{
messages.Add(text);
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="User">User</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, User User, priority Pr = priority.low)
{
Message text = new Message {
_Priority = Pr, message = Message, channel = User.Nick
};
lock (messages)
{
messages.Add(text);
}
}
public ActionResult Create([Bind(Include = "id,priorityname")] priority priority)
{
if (ModelState.IsValid)
{
db.priorities.Add(priority);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(priority));
}
public Part(double pos_x, double pos_y, double sizex, double sizey, double border, priority priority_to_set)
{
this.position_x = pos_x;
this.position_y = pos_y;
this.border_mm = border;
this.placement_priority = priority_to_set;
this.size_x = sizex;
this.size_y = sizey;
this.is_placed = true;
this.clashes = false;
}
// GET: priorities/Delete/5
public ActionResult Delete(byte?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
priority priority = db.priorities.Find(id);
if (priority == null)
{
return(HttpNotFound());
}
return(View(priority));
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, config.channel Channel, priority Pr = priority.normal)
{
if (Channel == null)
{
core.Log("Not sending message to unknown channel");
return;
}
// this is wrong instance so let's put this message to correct one
if (Channel.instance != Parent.ParentInstance)
{
Channel.instance.irc._SlowQueue.DeliverMessage(Message, Channel, Pr);
return;
}
Message text = new Message {
_Priority = Pr, message = Message, channel = Channel.Name
};
lock (messages)
{
messages.Add(text);
}
}
/// Displays text for an (optional) amount of time, then disables the game object.
/// Note that if you omit 'timer' it will display forever (or until it's interruped/disabled). However,
/// passing a timer value will make it remain on screen for that time.
public void DisplayText(string text, priority newMessagePriority = priority.highest, float timer = 0.0f)
{
// Compare priorities
if ((int)newMessagePriority < (int)m_currentMessagePriority)
{
Debug.LogWarning("Requested message is lower than current priority message, not displaying");
Debug.LogWarning("Not displaying: " + text);
return;
}
// If another message was active and we are interrupting it, ensure we cancel the previous coroutine
// that was created and would otherwise disable the message
if (messageOSDTimer != null)
{
StopCoroutine(messageOSDTimer);
messageOSDTimer = null;
}
// Update priority value
m_currentMessagePriority = newMessagePriority;
// Turn on the parent game object
messageOSD.transform.parent.gameObject.SetActive(true);
// Set the text
messageOSD.text = text;
// If a timer value isn't passed, we dont' trigger the coroutine so it remains active.
// Otherwise, if a value is passed, then it'll use that in the coroutine
if (timer > 0.0f)
{
messageOSDTimer = StartCoroutine(Helper.Utilities.Wait(timer, () => {
// switch of the game object
messageOSD.transform.parent.gameObject.SetActive(false);
// We've stopped displaying the message, so set it to the lowest to allow other messages to be displayed
m_currentMessagePriority = priority.lowest;
})
);
}
}
/// <summary>
/// Deliver me
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverAct(string Message, string Channel, priority Pr = priority.normal)
{
// first of all we check if we are in correct instance
if (Channel.StartsWith("#"))
{
Channel ch = Core.GetChannel(Channel);
if (ch == null)
{
Syslog.Log("Not sending message to unknown channel: " + Channel);
return;
}
// this is wrong instance so let's put this message to correct one
if (ch.PrimaryInstance != Parent.ParentInstance)
{
ch.PrimaryInstance.irc.Queue.DeliverAct(Message, Channel, Pr);
return;
}
}
Message text = new Message { MessagePriority = Pr, Text = Message, Channel = Channel };
lock (Messages)
{
Messages.Add(text);
}
}
partial void Updatepriority(priority instance);
public ServiceContracts(uint fileNumber, priority priority)
{
this.fileNumber = fileNumber;
this.priority = priority;
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, config.channel Channel, priority Pr = priority.normal)
{
if (Channel == null)
{
core.Log("Not sending message to unknown channel");
return;
}
// this is wrong instance so let's put this message to correct one
if (Channel.instance != Parent.ParentInstance)
{
Channel.instance.irc._SlowQueue.DeliverMessage(Message, Channel, Pr);
return;
}
Message text = new Message { _Priority = Pr, message = Message, channel = Channel.Name };
lock (messages)
{
messages.Add(text);
}
}
/// <summary>
/// Internal function
/// </summary>
public void Run()
{
while (true)
{
try
{
if (!running)
{
return;
}
if (messages.Count > 0)
{
lock (messages)
{
newmessages.AddRange(messages);
messages.Clear();
}
}
if (newmessages.Count > 0)
{
List <Message> Processed = new List <Message>();
priority highest = priority.low;
lock (newmessages)
{
while (newmessages.Count > 0)
{
// we need to get all messages that have been scheduled to be send
lock (messages)
{
if (messages.Count > 0)
{
newmessages.AddRange(messages);
messages.Clear();
}
}
highest = priority.low;
// we need to check the priority we need to handle first
foreach (Message message in newmessages)
{
if (message._Priority > highest)
{
highest = message._Priority;
if (message._Priority == priority.high)
{
break;
}
}
}
// send highest priority first
foreach (Message message in newmessages)
{
if (message._Priority >= highest)
{
Processed.Add(message);
Transfer(message);
System.Threading.Thread.Sleep(config.Interval);
if (highest != priority.high)
{
break;
}
}
}
foreach (Message message in Processed)
{
if (newmessages.Contains(message))
{
newmessages.Remove(message);
}
}
}
}
lock (newmessages)
{
newmessages.Clear();
}
}
}
catch (ThreadAbortException)
{
return;
}
System.Threading.Thread.Sleep(200);
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="User">User</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, User User, priority Pr = priority.low)
{
Message text = new Message { MessagePriority = Pr, Text = Message, Channel = User.Nick };
lock (Messages)
{
Messages.Add(text);
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, Channel Channel, priority Pr = priority.normal)
{
if (Channel == null)
{
Syslog.Log("Not sending message to null channel");
return;
}
// this is wrong instance so let's put this message to correct one
if (Channel.PrimaryInstance != Parent.ParentInstance)
{
Channel.PrimaryInstance.irc.Queue.DeliverMessage(Message, Channel, Pr);
return;
}
Message text = new Message { MessagePriority = Pr, Text = Message, pChannel = Channel };
lock (Messages)
{
Messages.Add(text);
}
}
/// <summary>
/// Send a command to server
/// </summary>
/// <param name="Data"></param>
/// <param name="Priority"></param>
public void Send(string Data, priority Priority = priority.high)
{
Message text = new Message { MessagePriority = Priority, Channel = null, Text = Data, Command = true };
lock (Messages)
{
Messages.Add(text);
}
}
/// <summary>
/// Send a command to server
/// </summary>
/// <param name="Data"></param>
/// <param name="Priority"></param>
public void Send(string Data, priority Priority = priority.high)
{
Message text = new Message { _Priority = Priority, channel = null, message = Data, command = true };
lock (messages)
{
messages.Add(text);
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, string Channel, priority Pr = priority.normal)
{
// first of all we check if we are in correct instance
if (Channel.StartsWith("#"))
{
config.channel ch = core.getChannel(Channel);
if (ch == null)
{
core.Log("Not sending message to unknown channel: " + Channel);
return;
}
// this is wrong instance so let's put this message to correct one
if (ch.instance != Parent.ParentInstance)
{
ch.instance.irc._SlowQueue.DeliverMessage(Message, Channel, Pr);
return;
}
}
else
{
lock (core.TargetBuffer)
{
if (core.TargetBuffer.ContainsKey(Channel))
{
if (core.TargetBuffer[Channel] != Parent.ParentInstance)
{
core.TargetBuffer[Channel].irc._SlowQueue.DeliverMessage(Message, Channel, Pr);
return;
}
}
}
}
Message text = new Message { _Priority = Pr, message = Message, channel = Channel };
lock (messages)
{
messages.Add(text);
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="Channel">Channel</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, config.channel Channel, priority Pr = priority.normal)
{
Message text = new Message();
text._Priority = Pr;
text.message = Message;
text.channel = Channel.Name;
lock (messages)
{
messages.Add(text);
return;
}
}
/// <summary>
/// Deliver a message
/// </summary>
/// <param name="Message">Text</param>
/// <param name="User">User</param>
/// <param name="Pr">Priority</param>
public void DeliverMessage(string Message, User User, priority Pr = priority.low)
{
Message text = new Message();
text._Priority = Pr;
text.message = Message;
text.channel = User.Nick;
lock (messages)
{
messages.Add(text);
return;
}
}
public static priority Createpriority(int priority_id)
{
priority priority = new priority();
priority.priority_id = priority_id;
return priority;
}
partial void Insertpriority(priority instance);
public void AddTopriorities(priority priority)
{
base.AddObject("priorities", priority);
}
partial void Deletepriority(priority instance);
public Part(int price, string type, int buildSpeed, priority pr)
{
Done = false;
Type = type;
BuildProgress = 0;
Priority = pr;
BuildSpeed = buildSpeed;
Price = price;
}