public override void execute3(RunTimeValueBase thisObj,FunctionDefine functionDefine,SLOT returnSlot,SourceToken token,StackFrame stackframe,out bool success)
{
System.Collections.Queue queue =
(System.Collections.Queue)((LinkObj <object>)((ASBinCode.rtData.rtObjectBase)thisObj).value).value;
try
{
queue.Clear();
returnSlot.setValue(ASBinCode.rtData.rtUndefined.undefined);
success = true;
}
//catch (KeyNotFoundException)
//{
// success = false;
// stackframe.throwAneException(token, arraylist.ToString() + "没有链接到脚本");
//}
catch (ArgumentException a)
{
success = false;
stackframe.throwAneException(token,a.Message);
}
catch (IndexOutOfRangeException i)
{
success = false;
stackframe.throwAneException(token,i.Message);
}
}
internal PacketReceiver(string LocalAddress) : base (LocalAddress)
{
packetReceiver = new Queue();
tokenSource = new CancellationTokenSource();
readerWriterLock = new ReaderWriterLockSlim();
tokenSource.Token.Register(() => {
// Clear on cancel
packetReceiver.Clear();
});
var thReceiveQueue = Task.Factory.StartNew(() => {
while (tokenSource.Token.IsCancellationRequested == false)
{
readerWriterLock.EnterUpgradeableReadLock();
if (packetReceiver.Count > 0)
{
readerWriterLock.EnterWriteLock();
byte[] data = (byte[])packetReceiver.Dequeue();
readerWriterLock.ExitWriteLock();
if (OnNewPacketReceived != null)
OnNewPacketReceived(this, new NewPacketEventArgs(data));
}
readerWriterLock.ExitUpgradeableReadLock();
}
});
}
public static void Main(string[] args)
{
System.Collections.Queue kö = new System.Collections.Queue(10);
{
kö.Enqueue(1);
kö.Enqueue(2);
kö.Enqueue(3);
kö.Enqueue(15);
kö.Enqueue(null);
kö.Enqueue(20);
kö.Enqueue("test string");
kö.Enqueue(25);
Console.WriteLine($"Totalt antal element = {kö.Count}"); //Räknar antal element i kön
Console.WriteLine(kö.Peek()); //Kollar elementen i kön enligt ordning
kö.Dequeue();
Console.WriteLine(kö.Peek());
kö.Dequeue();
Console.WriteLine(kö.Peek());
kö.Dequeue();
kö.Dequeue();
Console.WriteLine(kö.Peek());
kö.Dequeue();
kö.Dequeue();
Console.WriteLine(kö.Peek());
kö.Dequeue();
Console.WriteLine(kö.Peek());
Console.WriteLine($"Antal element efter = {kö.Count}"); // Visar att elementen tagits bort
kö.Clear();
}
}
/// <summary>Aborts worker thread and clears the Queue</summary>
private void Stop()
{
System.GC.SuppressFinalize(this);
if (!Abort)
{
Abort = true;
WorkerThread.Abort();
Q.Clear();
}
}
public void runQueue()
{
// Create a queue
// Using Queue class
System.Collections.Queue my_queue = new System.Collections.Queue();
// Adding elements in Queue
// Using Enqueue() method
my_queue.Enqueue("GFG");
my_queue.Enqueue("Geeks");
my_queue.Enqueue("GeeksforGeeks");
my_queue.Enqueue("geeks");
my_queue.Enqueue("Geeks123");
Console.WriteLine("Total elements present in my_queue: {0}",
my_queue.Count);
// Checking if the element is
// present in the Queue or not
if (my_queue.Contains("GeeksforGeeks") == true)
{
Console.WriteLine("Element available...!!");
}
else
{
Console.WriteLine("Element not available...!!");
}
// Obtain the topmost element of my_queue
// Using Dequeue method
Console.WriteLine("Topmost element of my_queue"
+ " is: {0}", my_queue.Dequeue());
Console.WriteLine("Total elements present in my_queue: {0}",
my_queue.Count);
// Obtain the topmost element of my_queue
// Using Peek method
Console.WriteLine("Topmost element of my_queue is: {0}",
my_queue.Peek());
// After Dequeue method
Console.WriteLine("Total elements present in my_queue: {0}",
my_queue.Count);
// Remove all the elements from the queue
my_queue.Clear();
// After Clear method
Console.WriteLine("Total elements present in my_queue: {0}",
my_queue.Count);
Console.ReadLine();
}
/// <summary>
/// 充值新功能开启
/// </summary>
private void ResetFuncOpen()
{
//新功能提醒
m_lst_alreadyDoFuncOpen.Clear();
m_lst_canDoFuncOpen.Clear();
m_lst_closeFuncOpen.Clear();
m_FuncCommonNoticesQ.Clear();
m_currentFuncOpenShowData = null;
m_newFuncFlyGrid = null;
m_dic_completeFuncSort.Clear();
m_bNewFuncDataReady = false;
}
static public int Clear(IntPtr l)
{
try {
System.Collections.Queue self = (System.Collections.Queue)checkSelf(l);
self.Clear();
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public void Close()
{
lock (semaphore)
{
m_bClosed = true;
queue.Clear();
if (m_bAsyncDelivery)
{
messageReceivedEventHandle.Set();
}
}
}
void CopyItems()
{
Collections.NgbhItems selitems = SelectedNgbhItems;
if (selitems.Count > 0)
{
this.Cursor = Cursors.WaitCursor;
try
{
clipboard.Clear();
foreach (NgbhItem item in selitems)
{
clipboard.Enqueue(item);
}
}
catch (Exception exception1)
{
this.Cursor = Cursors.Default;
Helper.ExceptionMessage(Localization.Manager.GetString("errconvert"), exception1);
}
this.Cursor = Cursors.Default;
}
}
static int Clear(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
System.Collections.Queue obj = (System.Collections.Queue)ToLua.CheckObject(L, 1, typeof(System.Collections.Queue));
obj.Clear();
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// 打印之前需要初始化的数据
/// </summary>
public void BeginPrint()
{
HasDrawRowCount = 0;
PageNumber = 1;
DIYReport.Express.ExSpecial._Page = 1;
DIYReport.Express.ExSpecial._PageCount = 1;
DIYReport.Express.ExSpecial._RowOrderNO = 0;
_GroupFoots.Clear();
_GroupHeads.Clear();
foreach (object field in _DrawDetailInfo.GroupFields)
{
DrawGroupField groupField = field as DrawGroupField;
groupField.CurrGroupValue = null;
}
}
/* Clear() will only remove object references from the cache
* and queue. Capacity will remain unchanged.
*/
public static void Clear()
{
_readWriteLock.EnterWriteLock();
//Monitor.Enter(keyQueue);
//Monitor.Enter(ItemDictionary);
try
{
Size = 0;
keyQueue.Clear();
ItemDictionary.Clear();
}
finally
{
_readWriteLock.ExitWriteLock();
//Monitor.Exit(ItemDictionary);
//Monitor.Exit(keyQueue);
}
}
static void Main(string[] args)
{
Queue<Action> action_queue = new Queue<Action>();
action_queue.Enqueue(new Action(1));
action_queue.Enqueue(new Action(2));
action_queue.Enqueue(new Action(3));
Console.Write("ActionQueue : ");
foreach (Action action in action_queue)
{
Console.Write("{0} ", action.action_no_);
}
Console.WriteLine();
{
Action action = action_queue.Dequeue();
Console.WriteLine("Dequeue {0} : ", action.action_no_);
}
Console.Write("ActionQueue : ");
foreach (Action action in action_queue)
{
Console.Write("{0} ", action.action_no_);
}
Console.WriteLine();
{
Console.WriteLine("Clear");
action_queue.Clear();
}
Console.Write("ActionQueue : ");
foreach (Action action in action_queue)
{
Console.Write("{0} ", action.action_no_);
}
Console.WriteLine();
}
// Use this for initialization
void Start()
{
Debug.Log("START");
cf = new ConnectionFactory();
cf.HostName = serverip;
conn = cf.CreateConnection();
conn.ConnectionShutdown += new ConnectionShutdownEventHandler(LogConnClose);
ch = conn.CreateModel();
ch.ExchangeDeclare(exchange, "fanout");
string queueName = ch.QueueDeclare();
ch.QueueBind(queueName, exchange, "");
//ch.QueueBind(queueName,exchange,"",false,null); //version shup
consumer = new QueueingBasicConsumer(ch);
ch.BasicConsume(queueName, true, consumer);
//ch.BasicConsume(queueName,null,consumer); //version shup
queue = new System.Collections.Queue();
queue.Clear();
}
/// <summary>
/// Clears any unverified events.
/// </summary>
public static void Clear()
{
_events.Clear();
}
//
/*public void returnHex(SendMessageContext context)
* {
* context.returnGameObject = Hex;
* }*/
public int MovePath(GameObject obj1, GameObject obj2)
{
//listPath.Clear();
if (obj2.GetComponent <Hex>().currentStat != 2)
{
return(-1);
}
System.Collections.Queue queuePath = new System.Collections.Queue();
queuePath.Enqueue(obj1);
bool flag = false;
while (flag != true)
{
int count = queuePath.Count;
for (int i = 0; i < count; i++)
{
GameObject tempobj = (GameObject)queuePath.Dequeue();
if (tempobj != obj2)
{
for (int j = 0; j < 6; j++)
{
GameObject neighbor = tempobj.GetComponent <Hex>().neighbor[j];
if ((neighbor != null) &&
(neighbor.GetComponent <Hex>().LabelObject == null) &&
(listHexToMove.Contains(neighbor)))
{
neighbor.GetComponent <Hex>().LabelObject = tempobj;
queuePath.Enqueue(neighbor);
}
}
}
else
{
flag = true;
break;
}
}
}
queuePath.Clear();
listPath.Add(obj2);
obj2.GetComponent <Hex>().currentStat = 3;
while (obj2 != obj1)
{
obj2 = obj2.GetComponent <Hex>().LabelObject;
obj2.GetComponent <Hex>().currentStat = 3;
listPath.Add(obj2);
}
listPath.Reverse();
foreach (GameObject obj in listHexToMove)
{
obj.GetComponent <Hex>().LabelObject = null;
}
return(listPath.Count - 1);
}
private static bool ParseOptions(string progdir, string[] args, out Options options)
{
options = new Options();
bool endnamed = false;
string optname = null;
bool help = false;
Queue<string> unnamed = new Queue<string>();
for (int i = 0; i < args.Length; i++)
{
string optarg = null;
if (args[i].StartsWith("--"))
{
optname = args[i].Substring(2);
}
else if (args[i].StartsWith("-") || args[i].StartsWith("/"))
{
optname = args[i].Substring(1);
}
else
{
optarg = args[i];
}
if (optname == "")
{
endnamed = true;
}
if (!endnamed && optname != null)
{
if (optname.Contains(":"))
{
optarg = optname.Substring(optname.IndexOf(":") + 1);
optname = optname.Substring(0, optname.IndexOf(":")).ToLower();
}
if (optname != null &&
optname.Length >= 1 &&
("template".StartsWith(optname) ||
"datasource".StartsWith(optname) ||
"savedir".StartsWith(optname) ||
"record".StartsWith(optname)))
{
if (optarg == null && i + 1 < args.Length)
{
i++;
optarg = args[i];
}
if ("template".StartsWith(optname))
{
optname = "template";
}
else if ("datasource".StartsWith(optname))
{
optname = "datasource";
}
else if ("savedir".StartsWith(optname))
{
optname = "savedir";
}
else if ("record".StartsWith(optname))
{
optname = "record";
}
}
switch (optname)
{
case "pdf":
options.ExportPdf = true;
optname = null;
break;
case "no-pdf":
options.ExportPdf = false;
optname = null;
break;
case "pub":
options.ExportPub = true;
optname = null;
break;
case "no-pub":
options.ExportPub = false;
optname = null;
break;
case "wingdings":
options.UseWingdingTicks = true;
optname = null;
break;
case "no-wingdings":
options.UseWingdingTicks = false;
optname = null;
break;
case "template":
try
{
options.TemplateName = Path.GetFullPath(optarg);
}
catch
{
options.TemplateName = optarg;
}
optname = null;
break;
case "datasource":
try
{
options.DataSourceName = Path.GetFullPath(optarg);
}
catch
{
options.DataSourceName = optarg;
}
optname = null;
break;
case "savedir":
options.SaveDir = Path.GetFullPath(optarg);
optname = null;
break;
case "record":
options.Names.Add(optarg);
break;
case "help":
help = true;
break;
case "?":
goto case "help";
default:
goto case "help";
}
}
else
{
unnamed.Enqueue(optarg);
}
}
if (options.TemplateName == null && unnamed.Count != 0)
{
string name = unnamed.Peek();
if (name.ToLower().EndsWith(".pub"))
{
name = unnamed.Dequeue();
}
else if (name.ToLower().EndsWith(".xls") ||
name.ToLower().EndsWith(".xlsx") ||
name.ToLower().EndsWith(".xlsb") ||
name.ToLower().EndsWith(".xlsm"))
{
options.DataSourceName = unnamed.Dequeue();
name = options.DataSourceName.Substring(0, options.DataSourceName.LastIndexOf('.')) + ".pub";
}
else
{
name = null;
help = true;
}
try
{
if (name != null)
{
options.TemplateName = Path.GetFullPath(name);
}
}
catch
{
options.TemplateName = name;
}
}
if (unnamed.Count != 0)
{
options.Names.AddRange(unnamed);
unnamed.Clear();
}
if (String.IsNullOrEmpty(options.SaveDir))
{
if (options.TemplateName != null)
{
options.SaveDir = Path.GetDirectoryName(Path.GetFullPath(options.TemplateName));
}
else
{
options.SaveDir = progdir;
}
}
return !help;
}
private static void JoinOperandSymbols(Queue<string> queueOperand, Queue<string> queueTokens)
{
queueTokens.Enqueue(String.Join("", queueOperand.ToArray()));
queueOperand.Clear();
}
private void ThreadpoolMethod_Retweet(object parameters)
{
TweetAccountManager tweetAccountManager = new TweetAccountManager();
try
{
Array paramsArray = new object[1];
paramsArray = (Array)parameters;
KeyValuePair<string, TweetAccountManager> keyValue = (KeyValuePair<string, TweetAccountManager>)paramsArray.GetValue(0);
List<TwitterDataScrapper.StructTweetIDs> lst_DivideTweets = new List<TwitterDataScrapper.StructTweetIDs>();
if (TweetAccountManager.IsRetweetDivideRetweet)
{
lst_DivideTweets = (List<TwitterDataScrapper.StructTweetIDs>)paramsArray.GetValue(1);
}
tweetAccountManager = keyValue.Value;
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Starting ReTweet For Account : " + keyValue.Key + " ]");
//Add to Threads Dictionary
AddThreadToDictionary(strModule(Module.Retweet), tweetAccountManager.Username);
try
{
//Thread.CurrentThread.Name = "ReTweet_" + tweetAccountManager.Username;
//Thread.CurrentThread.IsBackground = true;
//dictionary_Threads.Add("ReTweet_" + tweetAccountManager.Username, Thread.CurrentThread);
AddThreadToDictionary(strModule(Module.Retweet), tweetAccountManager.Username);
}
catch { }
//Create logger Event for lof MSg's .
tweetAccountManager.logEvents.addToLogger += new EventHandler(logEvents_Tweet_addToLogger);
//tweetAccountManager.logEvents.addToLogger += logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger += logEvents_Tweet_addToLogger;
if (GlobusRegex.ValidateNumber(txtMinDelay_Tweet.Text))
{
retweetMinDealy = Convert.ToInt32(txtMinDelay_Tweet.Text);
}
if (GlobusRegex.ValidateNumber(txtMaxDelay_Tweet.Text))
{
retweetMaxDealy = Convert.ToInt32(txtMaxDelay_Tweet.Text);
}
if (chkboxRetweetPerDay.Checked)
{
TweetAccountManager.RetweetPerDay = true;
if (!string.IsNullOrEmpty(txtMaximumNoRetweet.Text) && NumberHelper.ValidateNumber(txtMaximumNoRetweet.Text))
{
TweetAccountManager.NoOFRetweetPerDay = Convert.ToInt32(txtMaximumNoRetweet.Text);
}
else
{
TweetAccountManager.NoOFRetweetPerDay = 10;
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Setting Maximum No Of ReTweets Per Day as 10 ]");
}
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageData(keyValue.Key, "ReTweet");
int TodayReTweet = Ds.Tables["tb_MessageRecord"].Rows.Count;
tweetAccountManager.AlreadyRetweeted = TodayReTweet;
if (TodayReTweet >= TweetAccountManager.NoOFRetweetPerDay)
{
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Already Retweeted " + tweetAccountManager.AlreadyRetweeted + " ]");
return;
}
}
if (chkCheckDatabaseInEvery2Minutes.Checked == true || chkAutoFavorite.Checked == true)
{
while (true)
{
try
{
string count_tweet = string.Empty;
string count_tweet1 = string.Empty;
TwitterDataScrapper tweetScrapper = new TwitterDataScrapper();
TwitterDataScrapper.StructTweetIDs item1 = new TwitterDataScrapper.StructTweetIDs();
TweetAccountManager.que_lst_Struct_TweetData.Clear();
Queue<TwitterDataScrapper.StructTweetIDs> tempQueue = new Queue<TwitterDataScrapper.StructTweetIDs>();
TwitterDataScrapper.noOfRecords = 1;
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching tweets for " + keyValue.Key + " ]");
count_tweet = tweetScrapper.countNoOfTweet(txtTweetKeyword.Text.Trim());
startAgain:
TweetAccountManager.static_lst_Struct_TweetData = tweetScrapper.TweetExtractor_ByUserName_New_New(txtTweetKeyword.Text.Trim());
int count = TweetAccountContainer.dictionary_TweetAccount.Count();
foreach (TwitterDataScrapper.StructTweetIDs item in TweetAccountManager.static_lst_Struct_TweetData)
{
//for (int i = 1; i <= count * TweetAccountManager.static_lst_Struct_TweetData.Count(); i++)
{
TweetAccountManager.que_lst_Struct_TweetData.Enqueue(item);
tempQueue.Enqueue(item);
}
}
try
{
if (TweetAccountManager.que_lst_Struct_TweetData.Count > 0)
{
item1 = tempQueue.Dequeue();
}
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
try
{
clsDBQueryManager DbQueryManager = new clsDBQueryManager();
DataSet Ds = DbQueryManager.SelectMessageDataForRetweet(keyValue.Key, item1.ID_Tweet, "ReTweet");
int count_NO_RoWs = Ds.Tables[0].Rows.Count;
if (count_NO_RoWs == 0)
{
if (chkCheckDatabaseInEvery2Minutes.Checked)
{
tweetAccountManager.ReTweet("", retweetMinDealy, retweetMaxDealy);
}
if (chkAutoFavorite.Checked && tweetAccountManager.IsNotSuspended && tweetAccountManager.IsLoggedIn)
{
string TUri = item1.ID_Tweet.ToString();
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Added To Favorite : " + TUri + " from " + tweetAccountManager.Username + " ]");
FavoriteOfUrl(new object[] { TUri, keyValue, tweetAccountManager });
}
}
AddToLog_Tweet("[ " + DateTime.Now + " ] => [ Searching new tweets will start after 3 minutes from " + tweetAccountManager.Username + " ]");
Thread.Sleep(3 * 60 * 1000);
count_tweet1 = tweetScrapper.countNoOfTweet(txtTweetKeyword.Text.Trim());
if (Convert.ToInt32(count_tweet) == Convert.ToInt32(count_tweet1))
{
TwitterDataScrapper.noOfRecords = 1;
}
else if (Convert.ToInt32(count_tweet1) > Convert.ToInt32(count_tweet))
{
TwitterDataScrapper.noOfRecords = Convert.ToInt32(count_tweet1) - Convert.ToInt32(count_tweet);
}
else
{
TwitterDataScrapper.noOfRecords = 1;
}
TweetAccountManager.static_lst_Struct_TweetData.Clear();
TweetAccountManager.que_lst_Struct_TweetData.Clear();
tempQueue.Clear();
count_tweet = count_tweet1;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
goto startAgain;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
}
}
else
{
if (TweetAccountManager.IsRetweetDivideRetweet)
{
tweetAccountManager.ReTweetDivideRetweet(lst_DivideTweets, retweetMinDealy, retweetMaxDealy);
}
else
{
tweetAccountManager.ReTweet("", retweetMinDealy, retweetMaxDealy);
}
}
tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
}
catch (Exception ex)
{
ErrorLogger.AddToErrorLogText(ex.Message);
GlobusFileHelper.AppendStringToTextfileNewLine(DateTime.Now + " --> Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TweetingErroLog);
GlobusFileHelper.AppendStringToTextfileNewLine("Error --> ThreadpoolMethod_Retweet() --> " + ex.Message, Globals.Path_TwtErrorLogs);
}
finally
{
tweetAccountManager.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
tweetAccountManager.tweeter.logEvents.addToLogger -= logEvents_Tweet_addToLogger;
}
}
// [Test]
public void Validation() {
Queue events = new Queue();
FormCustom form = new FormCustom("form1", true, events);
ContainerControlCustom container1 = new ContainerControlCustom("container1", true, events);
ContainerControlCustom container2 = new ContainerControlCustom("container2", true, events);
ContainerControlCustom container3 = new ContainerControlCustom("container3", true, events);
UserControlCustom userctl1 = new UserControlCustom("userctl1", true, events);
UserControlCustom userctl2 = new UserControlCustom("userctl2", true, events);
UserControlCustom userctl3 = new UserControlCustom("userctl3", true, events);
container2.Controls.Add(userctl2);
container2.Controls.Add(userctl3);
container1.Controls.Add(userctl1);
form.Controls.Add(container1);
form.Controls.Add(container2);
form.Controls.Add(container3);
form.Show();
object s;
events.Enqueue("START");
container3.Select();
events.Enqueue("END");
events.Enqueue("START");
container1.Select();
events.Enqueue("END");
events.Enqueue("START");
container2.Select();
events.Enqueue("END");
events.Enqueue("START");
userctl1.Select();
events.Enqueue("END");
events.Enqueue("START");
userctl2.Select();
events.Enqueue("END");
events.Enqueue("START");
userctl2.Select();
events.Enqueue("END");
while (events.Count > 0) {
s = events.Dequeue();
Console.WriteLine(s.ToString());
}
events.Clear();
form.Close();
userctl1.Dispose();
userctl2.Dispose();
userctl3.Dispose();
container1.Dispose();
container1.Dispose();
form.Dispose();
}
public void MakeLeak(int iRep, int iObj)
{
Queue L_Queue1;
Queue L_Queue2 = new Queue(1);
Queue L_Queue3 = new Queue(1, 1);
byte[] l_obj1;
BitArrayNode l_obj2;
int[] l_obj3;
for(int i=0; i<iRep; i++)
{
L_Queue1 = new Queue();
for(int j=1; j<iObj; j++)
{
l_obj1 = new byte[j];
l_obj2 = new BitArrayNode(j);
l_obj3 = new int[j];
l_obj1[0] = (byte)1;
l_obj3[0] = 1;
if(j>1)
{
l_obj1[j-1] = (byte)2;
}
L_Queue1.Enqueue(new BitArray(l_obj1));
L_Queue2.Enqueue(l_obj2);
L_Queue3.Enqueue(new BitArray(l_obj3));
}
L_Queue2.Clear();
while(L_Queue3.Count>0)
{
L_Queue3.Dequeue();
}
}
}
public static void Play_OnCommand(CommandEventArgs e)
{
PlayerMobile pm = (PlayerMobile)e.Mobile;
Queue PlayList = new Queue();
Object LastItem = null;
string[] Notes = { "cl", "csl", "d", "ds", "e", "f", "fs", "g", "gs", "a", "as",
"b", "c", "cs", "dh", "dsh", "eh", "fh", "fsh", "gh", "gsh",
"ah", "ash", "bh", "ch"};
Regex ValidPause = new Regex(@"^((1\.0)|(0\.[0-9]))$");
int NumOfNotes = 0;
int MaxQueueSize = 64;
double MinMusicSkill = 80.0;
// Allows dynamic control through the CoreManagementConsole.
if (e.Mobile.AccessLevel < CoreAI.PlayAccessLevel)
{
e.Mobile.SendMessage("Playing music is currently disabled.");
return;
}
if (e.Arguments.Length == 0)
{
Usage(pm);
return;
}
// If the player's Musicianship is too low, don't let them play at all.
if (e.Mobile.Skills[SkillName.Musicianship].Value < MinMusicSkill)
{
e.Mobile.SendMessage("You do not have enough skill to play a tune.");
return;
}
// If there are too many notes in the queue, make the player pause and try again.
if (pm.PlayList != null && pm.PlayList.Count + e.Arguments.Length > MaxQueueSize)
{
e.Mobile.SendMessage("Your fingers hurt from so much playing. You must rest a moment before playing another note.");
return;
}
// If there are some leftover notes in the playlist but we're starting a new tune,
// clear the playlist.
if (!pm.Playing && pm.PlayList != null)
pm.PlayList.Clear();
for (int i = 0; i < e.Length; ++i)
{
string item = e.Arguments[i].ToLower();
bool Queued = false;
for (int j = 0; j < Notes.Length; ++j)
{
if (item == Notes[j]) // If the argument is a note, add it directly to the queue.
{
// Detect repeated notes
if (PlayList.Count > 0 && LastItem is String && ((String)LastItem).ToLower() == item)
e.Mobile.SendMessage("Warning: Repeated note detected. Some notes may not play. Insert a 0.3 pause between repeated notes.");
PlayList.Enqueue(item);
LastItem = item;
NumOfNotes++;
Queued = true;
break;
}
}
if (Queued) continue;
if (ValidPause.IsMatch(item)) // Otherwise, check if it is a valid pause value.
{
double d = 0.0;
try
{
d = System.Convert.ToDouble(item);
// Console.WriteLine(
// "The argument has been converted to a double: {0}", d);
}
catch (Exception ex)
{
Scripts.Commands.LogHelper.LogException(ex);
}
PlayList.Enqueue(d); // If so, add it to the queue as a double.
LastItem = item;
continue;
}
else
{
Usage(pm);
return;
}
}
if (NumOfNotes == 0) // If the list is all pauses, do nothing.
{
PlayList.Clear();
return;
}
// Append the new playlist to the player's existing playlist (or make a new one).
if (pm.PlayList == null) pm.PlayList = new Queue();
foreach (Object obj in PlayList)
pm.PlayList.Enqueue(obj);
PlayList.Clear();
// Make sure an instrument is selected.
BaseInstrument.PickInstrument(pm, new InstrumentPickedCallback(OnPickedInstrument));
}
void CompleteAllOnDispose (Queue queue)
{
object [] pending = queue.ToArray ();
queue.Clear ();
WaitCallback cb;
for (int i = 0; i < pending.Length; i++) {
SocketAsyncResult ares = (SocketAsyncResult) pending [i];
cb = new WaitCallback (ares.CompleteDisposed);
ThreadPool.QueueUserWorkItem (cb, null);
}
}
public void HackerCheckerThreadLoop() {
Double checkedPlayers = 0;
Double playersWithStats = 0;
try {
DebugWrite("HCKCHK: Starting Hacker Checker Thread", 1);
Thread.CurrentThread.Name = "HackerChecker";
var playerCheckingQueue = new Queue<AdKatsPlayer>();
var repeatCheckingQueue = new Queue<AdKatsPlayer>();
DateTime loopStart;
while (true) {
loopStart = DateTime.UtcNow;
try {
DebugWrite("HCKCHK: Entering Hacker Checker Thread Loop", 7);
if (!_pluginEnabled) {
playerCheckingQueue.Clear();
repeatCheckingQueue.Clear();
DebugWrite("HCKCHK: Detected AdKats not enabled. Exiting thread " + Thread.CurrentThread.Name, 6);
break;
}
try {
//Get all unchecked players
if (_HackerCheckerQueue.Count > 0) {
DebugWrite("HCKCHK: Preparing to lock hackerCheckerMutex to retrive new players", 6);
if (_isTestingAuthorized)
PushThreadDebug(DateTime.Now.Ticks, (String.IsNullOrEmpty(Thread.CurrentThread.Name) ? ("mainthread") : (Thread.CurrentThread.Name)), Thread.CurrentThread.ManagedThreadId, new System.Diagnostics.StackTrace(true).GetFrame(0).GetFileLineNumber(), "");
lock (_HackerCheckerQueue) {
DebugWrite("HCKCHK: Inbound players found. Grabbing.", 5);
//Grab all players in the queue
playerCheckingQueue = new Queue<AdKatsPlayer>(_HackerCheckerQueue.ToArray());
//Clear the queue for next run
_HackerCheckerQueue.Clear();
}
}
else {
DebugWrite("HCKCHK: No inbound hacker checks. Waiting 10 seconds or for input.", 4);
//Wait for input
_HackerCheckerWaitHandle.Reset();
//Either loop when handle is set, or after 3 minutes
_HackerCheckerWaitHandle.WaitOne(180000 / ((repeatCheckingQueue.Count > 0) ? (repeatCheckingQueue.Count) : (1)));
}
}
catch (Exception e) {
HandleException(new AdKatsException("Error while fetching new players to check.", e));
}
//Current player being checked
AdKatsPlayer aPlayer = null;
try {
if (!_UseHackerChecker) {
repeatCheckingQueue.Clear();
}
//Check one player from the repeat checking queue
if (repeatCheckingQueue.Count > 0) {
//Only keep players still in the server in the repeat checking list
Boolean stillInServer = true;
do {
if (!_pluginEnabled) {
break;
}
aPlayer = repeatCheckingQueue.Dequeue();
if (!_PlayerDictionary.ContainsKey(aPlayer.player_name)) {
stillInServer = false;
}
} while (!stillInServer && repeatCheckingQueue.Count > 0);
if (aPlayer != null) {
//Fetch their stats from appropriate source
FetchPlayerStats(aPlayer);
if (aPlayer.stats != null && aPlayer.stats.StatsException == null) {
playersWithStats++;
ConsoleSuccess(aPlayer.player_name + " now has stats. Checking.");
if (!PlayerProtected(aPlayer)) {
RunStatSiteHackCheck(aPlayer, false);
}
DebugWrite("Players with " + _gameVersion + "Stats: " + String.Format("{0:0.00}", (playersWithStats / checkedPlayers) * 100) + "%", 3);
}
else {
aPlayer.stats = null;
//If they still dont have stats, add them back to the queue
repeatCheckingQueue.Enqueue(aPlayer);
}
}
}
}
catch (Exception e) {
HandleException(new AdKatsException("Error while in repeat checking queue handler", e));
}
//Get all checks in order that they came in
while (playerCheckingQueue.Count > 0) {
if (!_pluginEnabled) {
break;
}
//Grab first/next player
aPlayer = playerCheckingQueue.Dequeue();
if (aPlayer != null) {
DebugWrite("HCKCHK: begin reading player", 4);
if (!PlayerProtected(aPlayer)) {
FetchPlayerStats(aPlayer);
checkedPlayers++;
if (aPlayer.stats != null && aPlayer.stats.StatsException == null) {
playersWithStats++;
if (_UseHackerChecker) {
RunStatSiteHackCheck(aPlayer, false);
}
else {
DebugWrite("Player skipped after disabling hacker checker.", 2);
}
}
else {
//ConsoleError(aPlayer.player_name + " doesn't have stats.");
repeatCheckingQueue.Enqueue(aPlayer);
}
DebugWrite("Players with " + _gameVersion + "Stats: " + String.Format("{0:0.00}", (playersWithStats / checkedPlayers) * 100) + "%", 3);
}
}
}
}
catch (Exception e) {
if (e is ThreadAbortException) {
HandleException(new AdKatsException("Hacker Checker thread aborted. Exiting."));
break;
}
HandleException(new AdKatsException("Error occured in Hacker Checker thread. Skipping current loop.", e));
}
if (AdKats.FullDebug && ((DateTime.UtcNow - loopStart).TotalMilliseconds > 100))
ConsoleWrite(Thread.CurrentThread.Name + " thread loop took " + ((int) ((DateTime.UtcNow - loopStart).TotalMilliseconds)));
}
DebugWrite("HCKCHK: Ending Hacker Checker Thread", 1);
LogThreadExit();
}
catch (Exception e) {
HandleException(new AdKatsException("Error occured in Hacker Checker thread.", e));
}
}
public void MakeTableAndTree()
{
Queue<Symbol> currentQueue = new Queue<Symbol>();
Ensemble.OrderBy(o => o.Frequency).ToList().ForEach(p => currentQueue.Enqueue(p));
ProbabilityTable.Add(currentQueue.ToList());
while (currentQueue.Count > 1)
{
var newNode = new Symbol(currentQueue.Dequeue(), currentQueue.Dequeue());
var temporaryQueue = currentQueue.ToList();
if (currentQueue.Count == 0)
{
currentQueue.Enqueue(newNode);
}
else
{
int index = 0;
currentQueue.ToList().ForEach(p =>
{
if (newNode.Frequency <= p.Frequency)
{
index = currentQueue.ToList().IndexOf(p);
}
else
{
index++;
}
});
temporaryQueue.Insert(index, newNode);
currentQueue.Clear();
temporaryQueue.ForEach(p => currentQueue.Enqueue(p));
}
ProbabilityTable.Add(currentQueue.ToList());
}
}
static bool RunServer(bool network)
{
//TODO: Move proxy into set command
/*
* UNCOMMENT FOR RMIT
Console.WriteLine("Setting proxy settings...");
ConnectionInfo.Proxy = new WebProxy(
"http://aproxy.rmit.edu.au:8080", false, null, new NetworkCredential("s3229159", "MuchosRowlies1"));
*/
Console.WriteLine("Loading CoreLibraries Assembly...");
Assembly coreLibraries;
try
{
try
{
coreLibraries = Assembly.Load("RmitJourneyPlanner.CoreLibraries");
}
catch (Exception)
{
coreLibraries = Assembly.LoadFile(Directory.GetCurrentDirectory() + "/RmitJourneyPlanner.CoreLibraries.dll");
}
}
catch (Exception e)
{
Console.WriteLine("There was an error loading the CoreLibraries assembly. Please check if 'RmitJourneyPlanner.CoreLibraries.dll' is present in the program directory.\nError Message: {0}", e.Message);
return false;
}
string attributes = coreLibraries.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false).Cast<AssemblyFileVersionAttribute>().Aggregate("", (current, attribute) => current + attribute.Version);
Console.WriteLine("Version: {0}",String.Join("\n",attributes));
Console.WriteLine("Hooking into logging interface...");
Logger.LogEvent += LoggerOnLogEvent;
Logger.ProgressEvent += new ProgressEventHandler(Logger_ProgressEvent);
/*
Type[] types = coreLibraries.GetTypes();
Console.WriteLine("Loading point data providers:");
Type[] pdpTypes = getTypesImplimenting("IPointDataProvider", types);
List<IPointDataProvider> pointDataProviders = new List<IPointDataProvider>();
foreach (Type type in pdpTypes)
{
Console.WriteLine("--> {0} ", type.Name);
IPointDataProvider pdp = type.InvokeMember("", BindingFlags.CreateInstance, null, null, null, null) as IPointDataProvider;
if (pdp == null)
{
Console.WriteLine("Error initializing the data provider.");
}
else
{
pointDataProviders.Add(pdp);
}
}
Console.WriteLine("Loading network data providers:");
Type[] ndpTypes = getTypesImplimenting("INetworkDataProvider", types);
List<INetworkDataProvider> networkDataProviders = new List<INetworkDataProvider>();
foreach (Type type in ndpTypes)
{
Console.WriteLine("--> {0} ", type.Name);
INetworkDataProvider ndp = type.InvokeMember("", BindingFlags.CreateInstance, null, null, null, null) as INetworkDataProvider;
if (ndp == null)
{
Console.WriteLine("Error initializing the data provider.");
}
else
{
networkDataProviders.Add(ndp);
}
}
*/
var properties = new EvolutionaryProperties();
EvolutionaryRoutePlanner planner = null;
bool run = true;
StreamWriter resultWriter = null;
string resultPath = "";
Queue<string> commands = new Queue<string>();
var results = new List<Result>();
var loopCommands = new Queue<string>();
var loopStack = new Stack<KeyValuePair<Queue<string>, int>>();
int resultIndex = 0;
//bool loop = false;
Socket socket = null;
if (network)
{
Console.WriteLine("Listening for socket connection.");
TcpListener listener = new TcpListener(IPAddress.Loopback,3000);
listener.Start();
socket = listener.AcceptSocket();
}
while (run)
{
Console.Write("> ");
string input = String.Empty;
if (network)
{
Byte[] buffer = new byte[1024];
socket.Receive(buffer);
BinaryReader reader = new BinaryReader(new MemoryStream(buffer));
input = reader.ReadString();
}
else
{
if (filename == String.Empty)
{
input = Console.ReadLine().Trim();
}
else
{
input = "run " + filename;
}
}
RegexOptions options = RegexOptions.None;
Regex regex = new Regex(@"[ ]{2,}", options);
input = regex.Replace(input, @" ");
foreach (var value in input.Split(';'))
{
commands.Enqueue(value.Replace(";","").Trim());
}
bool echo = false;
while (commands.Count > 0)
{
string command = commands.Dequeue();
if (echo == false)
{
echo = true;
}
else
{
Console.WriteLine(command.Trim());
}
if (command.Length == 0)
{
continue;
}
if (command.ToLower() == "quit" || command.ToLower() == "exit")
{
run = false;
return true;
}
try
{
if (command.Contains("randomNode()"))
{
command = command.Replace(
"randomNode()",
((MetlinkDataProvider)properties.NetworkDataProviders[0]).GetRandomNodeId().ToString(
CultureInfo.InvariantCulture));
}
string[] segments = splitWithQuotes(command);
switch (segments[0].ToLower())
{
case "//":
break;
case "":
break;
case "help":
if (segments[1].ToLower() == "set")
{
if (segments.Length == 2)
{
Console.WriteLine(" Help: set [parameter] [value]. - Sets a property.");
Console.WriteLine(
" Here is a list of available properties. Type help set <property> for help on an individual property.");
foreach (PropertyInfo p in typeof(EvolutionaryProperties).GetProperties())
{
if (p.CanWrite)
{
if (p.PropertyType.Name == "List`1")
{
Type pType = p.PropertyType;
PropertyInfo pCount = pType.GetProperty("Count");
object o = p.GetValue(properties, null);
object count = pCount.GetValue(o, null);
Console.WriteLine(
" {0} ({1}) = {2} ",
p.Name,
String.Format("List<{0}>", pType.Name),
count);
}
else
{
string name = p.PropertyType.Name;
if (name.Contains("."))
{
name = name.Remove(
0, name.LastIndexOf(".", System.StringComparison.Ordinal));
}
Console.WriteLine(
" {0} ({1}) = {2} ",
p.Name,
name,
p.GetValue(properties, null));
}
}
}
}
}
break;
case "loop":
string s;
int nestLevel = 0;
loopCommands.Clear();
while ((s = commands.Dequeue().ToLower()) != "end loop" || nestLevel > 0)
{
string[] split = s.Split(' ');
if (split.Length > 1 && split[0].Trim() == "loop")
{
nestLevel++;
}
if (s == "end loop")
{
nestLevel--;
}
loopCommands.Enqueue(s);
}
var loopedCommands = new Queue<string>();
for (int i = 0; i < int.Parse(segments[1]); i ++ )
{
loopedCommands.Enqueue("// Loop " + i );
foreach (var lcommand in loopCommands)
{
loopedCommands.Enqueue(lcommand);
}
}
foreach (var mcommand in commands)
{
loopedCommands.Enqueue(mcommand);
}
commands = loopedCommands;
break;
case "set":
if (segments[2].ToLower() == "new")
{
///Console.WriteLine("Creating new instance...");
PropertyInfo info = typeof(EvolutionaryProperties).GetProperty(segments[1]);
if (info == null)
{
throw new Exception("That property does not exist.");
}
string typeName = segments[3];
Type type = searchForType(typeName, coreLibraries);
object o = null;
if (segments.Length == 4)
{
try
{
o = type.InvokeMember("", BindingFlags.CreateInstance, null, null, null);
}
catch( MissingMethodException )
{
o = type.InvokeMember(
"", BindingFlags.CreateInstance, null, null, new object[] { properties });
}
catch (Exception e)
{
Logger.Log(typeof(Program), "Warning: Exception on instance creation: " + e.Message);
if (e.InnerException != null)
{
Logger.Log(
typeof(Program),
"-------> Inner exception: " + e.InnerException.Message);
if (e.InnerException.InnerException != null)
{
Logger.Log(
typeof(Program),
"-------> ------->Inner inner exception: " + e.InnerException.InnerException.Message);
}
}
}
}
else
{
int noParam = segments.Length - 4;
bool created = false;
foreach (var constructor in type.GetConstructors())
{
//int count = 0;
ParameterInfo[] infos = constructor.GetParameters();
if (infos.Length == noParam)
{
var p = new List<object>();
for (int z = 4; z < segments.Length; z++)
{
if (segments[z].ToLower() == "metlinkprovider")
{
p.Add(properties.NetworkDataProviders[0]);
}
else
{
p.Add(Convert.ChangeType(segments[z], infos[z - 4].ParameterType));
}
}
o = type.InvokeMember(
"", BindingFlags.CreateInstance, null, null, p.ToArray());
created = true;
}
}
if (!created)
{
throw new Exception("Error executing constructor / Unable to find a constuctor with those values.");
}
}
//PropertyInfo info = typeof(EvolutionaryProperties).GetProperty(segments[1]);
if (info.PropertyType.Name == "List`1")
{
Type listType = info.PropertyType;
object list = info.GetValue(
properties, BindingFlags.GetProperty, null, null, null);
MethodInfo methodInfo = listType.GetMethod("Add");
methodInfo.Invoke(
list, BindingFlags.InvokeMethod, null, new object[] { o }, null);
}
else
{
typeof(EvolutionaryProperties).GetProperty(segments[1]).SetValue(
properties, o, BindingFlags.SetProperty, null, null, null);
}
}
else if (segments[1].ToLower() == "resultoutput")
{
if (File.Exists(segments[2]))
{
Console.WriteLine(" Warning: File exists and will be overwritten.");
}
resultWriter = new StreamWriter(segments[2], false);
resultPath = segments[2];
}
else
{
string propertyName = segments[1];
string value = segments[2];
PropertyInfo info = typeof(EvolutionaryProperties).GetProperty(propertyName);
if (info.PropertyType.IsValueType)
{
object o = Convert.ChangeType(value, info.PropertyType);
typeof(EvolutionaryProperties).GetProperty(propertyName).SetValue(
properties, o, BindingFlags.SetProperty, null, null, null);
}
else
{
Console.WriteLine(
" Only value types (int, string) can be used with this property. Try the new keyword to create an instance.");
}
}
break;
case "run":
try
{
using (var reader = new StreamReader(segments[1]))
{
var newQueue = new Queue<string>();
string script = reader.ReadToEnd();
foreach (var c in script.Split(';'))
{
newQueue.Enqueue(c.Replace(";", "").Trim());
}
foreach (var c in commands)
{
newQueue.Enqueue(c);
}
commands = newQueue;
}
}
catch (Exception e)
{
Console.WriteLine("Error running script: {0}", e.Message);
}
break;
case "dump":
if (segments[1].ToLower() == "population")
{
resultWriter.WriteLine("\n[Population Dump]");
foreach (var critter in planner.Result.Population)
{
string line = critter.Route.Aggregate(
"", (current, node) => current + (node.Node.Id + ","));
resultWriter.WriteLine(line);
}
resultWriter.WriteLine("[End Population Dump]");
}
if (segments[1].ToLower() == "averageresults")
{
int n = Int32.Parse(segments[2]);
for (int i = 0; i < n; i++)
{
Result average = default(Result);
for (int j = 0; j < results.Count / n; j++)
{
average.AverageFitness += results[i + (j*n)].AverageFitness;
average.DiversityMetric += results[i + (j*n)].DiversityMetric;
average.MinimumFitness += results[i + (j*n)].MinimumFitness;
average.Totaltime += results[i + (j*n)].Totaltime;
}
average.AverageFitness /= (results.Count / (double) n);
average.DiversityMetric /= (results.Count / (double)n);
average.MinimumFitness /= (results.Count / (double) n);
average.Totaltime = new TimeSpan(average.Totaltime.Ticks / (results.Count / n));
if (resultWriter != null)
{
resultWriter.WriteLine(average.ToString());
}
}
results.Clear();
}
if (segments[1].ToLower() == "htmlmap")
{
Tools.SavePopulation(planner.Population.GetRange(0,1),0,properties,resultPath+ ".html");
}
if (segments[1].ToLower() == "saveline")
{
if (resultWriter.BaseStream.CanWrite)
{
resultWriter.Close();
}
StreamReader reader = new StreamReader(resultPath);
string text = reader.ReadToEnd().Trim();
reader.Close();
string[] lines = text.Split('\n');
try
{
if (resultIndex < lines.Length)
{
if (resultIndex < results.Count)
{
lines[resultIndex] = lines[resultIndex].Trim() + ","
+ results[resultIndex].AverageFitness;
}
else
{
lines[resultIndex] = lines[resultIndex].Trim() + ","
+ "-1";
}
resultWriter = new StreamWriter(resultPath, false);
string st = String.Join("\n", lines);
resultWriter.Write(st);
}
else
{
resultWriter = new StreamWriter(resultPath, true);
if (resultIndex < results.Count)
{
resultWriter.WriteLine(results[resultIndex].AverageFitness);
}
else
{
resultWriter.WriteLine("-1");
}
}
}
catch (Exception)
{
Console.WriteLine("Error writing things...");
}
}
break;
case "start":
//try
try
{
planner = new EvolutionaryRoutePlanner(properties);
planner.Start();
results.Clear();
results.Add(planner.Result);
}
catch (Exception e)
{
var r = new Result { AverageFitness = new Fitness() };
results.Add(r);
Console.WriteLine(" Error starting travel planner:\n {0}\n {1}", e.Message, e.StackTrace);
}
resultIndex = 0;
/*
if (resultWriter != null)
{
resultWriter.WriteLine(planner.Result.ToString());
}
*/
/*
catch (Exception e)
{
Console.WriteLine(" Error starting travel planner:\n {0}\n {1}", e.Message,e.StackTrace);
}
*/
break;
case "disable":
if (segments[1] == "log")
{
Logger.LogEvent -= LoggerOnLogEvent;
}
break;
case "enable":
if (segments[1] == "log")
{
Logger.LogEvent += LoggerOnLogEvent;
}
break;
case "step":
try
{
int iterations = 1;
if (segments.Length > 1)
{
int i;
if (Int32.TryParse(
segments[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out i))
{
iterations = i;
}
}
for (int i = 0; i < iterations; i++)
{
planner.SolveStep();
/*
if (resultWriter != null)
{
resultWriter.WriteLine(planner.Result.ToString());
}
* */
results.Add(planner.Result);
}
}
catch (Exception e)
{
Console.WriteLine(" Error stepping travel planner:\n {0}\n {1}", e.Message, e.StackTrace);
var r = new Result { AverageFitness = new Fitness()};
results.Add(r);
}
resultIndex++;
break;
default:
throw new Exception(" Command not recognised.");
}
}
catch(TargetInvocationException e)
{
Console.WriteLine(" There was an error parsing your command.");
Console.WriteLine(" There was an error invoking the new instance.\n {0}", e.InnerException.Message);
}
catch (IndexOutOfRangeException)
{
Console.WriteLine(
" There was an error parsing your command. Type help for a list of commands.");
//commands.Clear();
}
catch (Exception e)
{
Console.WriteLine(
" There was an error parsing your command. \n {0} \nType help for a list of commands.",
e.Message);
if (e.InnerException != null)
{
Console.WriteLine(" Inner Exception Message: " + e.InnerException.Message);
}
//commands.Clear();
}
}
}
return true;
}
/// <summary>
/// MIDI Input Port object constructor
/// </summary>
/// <param name="i"></param>
public MidiInputPort(int i /*,Midi midi*/) : base(i /*, midi*/)
{
int dwInstance = i; // This can be any data we want
NumMidiCallbacksReceived = 0;
int dwFlags = MidiLibWrap.CALLBACK_FUNCTION;
try
{
MidiLibWrap.MidiInCapabilities midiInCaps = new MidiLibWrap.MidiInCapabilities();
MidiLibWrap.midiInGetDevCaps(i, out midiInCaps, Marshal.SizeOf( typeof(MidiLibWrap.MidiInCapabilities)));
m_Name = midiInCaps.Name;
RC.WriteLine(string.Format("Input port name = {0}", m_Name));
m_SysExHeaderQueue = Queue.Synchronized(new Queue());
m_InputMethod = new MidiInProc( MidiCallback );
int rc = MidiLibWrap.midiInOpen(out m_MidiHandle, m_PortIndex, m_InputMethod, dwInstance, dwFlags);
CreateHeaders();
// Initializes headers for system exclusive messages.
for(int j = 0; j < HeaderCount; j++)
{
// Reset flags.
m_Headers[j].flags = 0;
// Imprint header structure onto raw memory.
Marshal.StructureToPtr(m_Headers[j], m_HeadersPointers[j], false);
// Prepare header.
MidiLibWrap.midiInPrepareHeader(m_MidiHandle, m_HeadersPointers[j], Marshal.SizeOf(typeof(MidiLibWrap.MidiHeader)));
// Add header to buffer.
MidiLibWrap.midiInAddBuffer(m_MidiHandle, m_HeadersPointers[j],
Marshal.SizeOf(typeof(MidiLibWrap.MidiHeader)));
}
// Clear system exclusive header queue.
m_SysExHeaderQueue.Clear();
// Create thread for processing system exclusive headers.
m_SysExHeaderThread =
new Thread(new ThreadStart(ManageSysExHeaders));
// Start worker thread.
m_SysExHeaderThread.Start();
rc = MidiLibWrap.midiInStart( m_MidiHandle );
}
catch( Exception e )
{
RC.WriteLine(string.Format("Error: {0}", e.Message));
}
NumOpenInputPorts++;
}
private static void HandleComm( Buffer *inBuff, Buffer *outBuff, Queue queue, PacketPath path )
{
CommMutex.WaitOne();
while ( inBuff->Length > 0 )
{
byte *buff = (&inBuff->Buff0) + inBuff->Start;
int len = GetPacketLength( buff, inBuff->Length );
if ( len > inBuff->Length || len <= 0 )
break;
inBuff->Start += len;
inBuff->Length -= len;
bool viewer = false;
bool filter = false;
switch ( path )
{
case PacketPath.ClientToServer:
viewer = PacketHandler.HasClientViewer( buff[0] );
filter = PacketHandler.HasClientFilter( buff[0] );
break;
case PacketPath.ServerToClient:
viewer = PacketHandler.HasServerViewer( buff[0] );
filter = PacketHandler.HasServerFilter( buff[0] );
break;
}
Packet p = null;
PacketReader pr = null;
if ( viewer )
{
pr = new PacketReader( buff, len, IsDynLength( buff[0] ) );
if ( filter )
p = MakePacketFrom( pr );
}
else if ( filter )
{
byte[] temp = new byte[len];
fixed ( byte *ptr = temp )
memcpy( ptr, buff, len );
p = new Packet( temp, len, IsDynLength( buff[0] ) );
}
bool blocked = false;
switch ( path )
{
// yes it should be this way
case PacketPath.ClientToServer:
{
blocked = !PacketPlayer.ClientPacket( p );
if ( !blocked )
blocked = PacketHandler.OnClientPacket( buff[0], pr, p );
break;
}
case PacketPath.ServerToClient:
{
if ( !PacketPlayer.Playing )
{
blocked = PacketHandler.OnServerPacket( buff[0], pr, p );
}
else
{
blocked = true;
if ( p != null && p.PacketID == 0x1C )
{
// 0, 1, 2
Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
ushort body = p.ReadUInt16(); // 7, 8
MessageType type = (MessageType)p.ReadByte(); // 9
ushort hue = p.ReadUInt16(); // 10, 11
ushort font = p.ReadUInt16();
string name = p.ReadStringSafe( 30 );
string text = p.ReadStringSafe();
if ( World.Player != null && serial == Serial.Zero && body == 0 && type == MessageType.Regular && hue == 0xFFFF && font == 0xFFFF && name == "SYSTEM" )
{
p.Seek( 3, SeekOrigin.Begin );
p.WriteAsciiFixed( "", (int)p.Length-3 );
// CHEAT UO.exe 1/2 251--
// 1 = 2d
// 2 = 3d!
DoFeatures( World.Player.Features );
}
}
}
if ( !blocked )
blocked = !PacketPlayer.ServerPacket( p );
break;
}
}
if ( filter )
{
byte[] data = p.Compile();
fixed ( byte *ptr = data )
{
Packet.Log( path, ptr, data.Length, blocked );
if ( !blocked )
CopyToBuffer( outBuff, ptr, data.Length );
}
}
else
{
Packet.Log( path, buff, len, blocked );
if ( !blocked )
CopyToBuffer( outBuff, buff, len );
}
if ( !PacketPlayer.Playing )
{
while ( queue.Count > 0 )
{
p = (Packet)queue.Dequeue();
if ( PacketPlayer.Recording )
{
switch ( path )
{
case PacketPath.ClientToServer:
PacketPlayer.ClientPacket( p );
break;
case PacketPath.ServerToClient:
PacketPlayer.ServerPacket( p );
break;
}
}
byte[] data = p.Compile();
fixed ( byte *ptr = data )
{
CopyToBuffer( outBuff, ptr, data.Length );
Packet.Log( (PacketPath)(((int)path)+1), ptr, data.Length );
}
}
}
else
{
queue.Clear();
}
}
CommMutex.ReleaseMutex();
}
/**
* Takes messages off the internal message queue and handles them by either
* sending responses, forwarding the message on, or processing it internally
*/
private void ProcessMessagesThreadProc()
{
// A response message queue used to send messages back to the one which sent it
Queue<AgentMessage> ResponseMessageQueue = new Queue<AgentMessage>();
while( AgentHasShutDown == false )
{
StartTiming( "ProcessMessage-Internal", true );
lock( MessageQueueLock )
{
// Swap the SM and PM message queue to keep things moving at full speed
Queue<AgentMessage> Temp = MessageQueuePM;
MessageQueuePM = MessageQueueSM;
MessageQueueSM = Temp;
}
// Process all messages currently in the queue
while( MessageQueuePM.Count > 0 )
{
Debug.Assert( ResponseMessageQueue.Count == 0 );
// Get and process the next message
AgentMessage NextMessage = MessageQueuePM.Dequeue();
Debug.Assert( NextMessage != null );
bool bMessageHandled = false;
switch( NextMessage.Type )
{
case EMessageType.SIGNAL:
{
if( NextMessage is DisconnectionSignalMessage )
{
// Mark the connection as inactive
DisconnectionSignalMessage DisconnectMessage = NextMessage as DisconnectionSignalMessage;
Log( EVerbosityLevel.Informative, ELogColour.Green, String.Format( "[CloseConnection] Connection disconnected {0:X8}", DisconnectMessage.ConnectionToDisconnect.Handle ) );
DisconnectMessage.ConnectionToDisconnect.CurrentState = ConnectionState.DISCONNECTED;
DisconnectMessage.ConnectionToDisconnect.DisconnectedTime = DateTime.UtcNow;
}
// Signal the message and move on
AgentSignalMessage SignalMessage = NextMessage as AgentSignalMessage;
SignalMessage.ResetEvent.Set();
bMessageHandled = true;
}
break;
case EMessageType.TIMING:
{
Connection FromConnection;
if( ( Connections.TryGetValue( NextMessage.From, out FromConnection ) ) )
{
Connection ToConnection;
if( ( Connections.TryGetValue( NextMessage.To, out ToConnection ) ) &&
( ToConnection is LocalConnection ) )
{
// Handle message
AgentTimingMessage TimingMessage = NextMessage as AgentTimingMessage;
AgentApplication.UpdateMachineState( MachineNameFromConnection( FromConnection ), TimingMessage.ThreadNum, TimingMessage.State );
bMessageHandled = true;
}
}
}
break;
case EMessageType.TASK_REQUEST:
{
// Look up the requesting connection
Debug.Assert( NextMessage.From != Constants.INVALID );
Connection RequestingConnection;
if( Connections.TryGetValue( NextMessage.From, out RequestingConnection ) )
{
// Look up the specified Job
AgentJob JobToAskForTasks = RequestingConnection.Job;
if( JobToAskForTasks != null )
{
// If we get a valid response back, add it to the queue
AgentTaskRequestResponse Response = JobToAskForTasks.GetNextTask( RequestingConnection );
if( Response != null )
{
ResponseMessageQueue.Enqueue( Response );
// Specifications and releases are always handled here, but
// reservations are special in that we will send a reservation
// back to local connections but we'll need to make sure the
// message continues on to remote connections.
if( ( Response.ResponseType == ETaskRequestResponseType.SPECIFICATION ) ||
( Response.ResponseType == ETaskRequestResponseType.RELEASE ) ||
( ( Response.ResponseType == ETaskRequestResponseType.RESERVATION ) &&
( JobToAskForTasks.Owner is LocalConnection ) ) )
{
bMessageHandled = true;
}
}
}
else
{
// Unable to find the Job, just send back a release message
Log( EVerbosityLevel.Verbose, ELogColour.Orange, "[ProcessMessage] Unable to find Job for Task Request; may have been closed" );
//ResponseMessageQueue.Enqueue( new AgentTaskRequestResponse( RequestingConnection.Job.JobGuid,
// ETaskRequestResponseType.RELEASE ) );
bMessageHandled = true;
}
}
else
{
// Unable to find the connection, swallow the request
Log( EVerbosityLevel.Verbose, ELogColour.Orange, "[ProcessMessage] Unable to find owning Connection for Task Request" );
bMessageHandled = true;
}
}
break;
case EMessageType.TASK_STATE:
{
// Look up the sending connection
Debug.Assert( NextMessage.From != Constants.INVALID );
Connection SendingConnection;
if( ( Connections.TryGetValue( NextMessage.From, out SendingConnection ) ) &&
( SendingConnection.Job != null ) )
{
// Look up the specified Job
AgentJob UpdatedJob;
if( ActiveJobs.TryGetValue( SendingConnection.Job.JobGuid, out UpdatedJob ) )
{
AgentTaskState UpdatedTaskState = NextMessage as AgentTaskState;
UpdatedJob.UpdateTaskState( UpdatedTaskState );
if( UpdatedJob.Owner is LocalConnection )
{
// If the Task state change is of a type potentially interesting to
// the Instigator, return it
switch( UpdatedTaskState.TaskState )
{
case EJobTaskState.TASK_STATE_INVALID:
case EJobTaskState.TASK_STATE_COMPLETE_SUCCESS:
case EJobTaskState.TASK_STATE_COMPLETE_FAILURE:
// For these message types, allow the message to continue on
break;
default:
// Nothing to do otherwise, mark the message as handled
bMessageHandled = true;
break;
}
}
else
{
// Always send messages on for remote connections
}
}
else
{
// Unable to find the Job, swallow the request
Log( EVerbosityLevel.Verbose, ELogColour.Orange, "[ProcessMessage] Unable to find Job for Task Request" );
bMessageHandled = true;
}
}
else
{
// Unable to find the connection, swallow the request
Log( EVerbosityLevel.Verbose, ELogColour.Orange, "[ProcessMessage] Unable to find owning Connection for Task Request" );
bMessageHandled = true;
}
}
break;
}
// If the message was not handled completely, send it on
if( bMessageHandled == false )
{
// Look up who the message is being sent to and make sure they're
// still active and if not, ignore the message
Connection Recipient;
Debug.Assert( NextMessage.To != Constants.INVALID );
if( Connections.TryGetValue( NextMessage.To, out Recipient ) )
{
if( Recipient is LocalConnection )
{
// If the recipient is local, place it in the proper queue
// and signal that a message is ready
LocalConnection LocalRecipient = Recipient as LocalConnection;
lock( LocalRecipient.MessageQueue )
{
LocalRecipient.MessageQueue.Enqueue( NextMessage );
string NewLogMessage = String.Format( "Step 2 of 4 for message: ({0:X8} -> {1:X8}), {2}, Message Count {3} (Local Connection)",
NextMessage.To,
NextMessage.From,
NextMessage.Type,
LocalRecipient.MessageQueue.Count );
Log( EVerbosityLevel.SuperVerbose, ELogColour.Green, NewLogMessage );
LocalRecipient.MessageAvailableSignal();
}
}
else
{
Debug.Assert( Recipient is RemoteConnection );
// If the recipient is remote, send the message via SendMessage
// unless the message is a Task being sent back, which is sent
// via the dedicated Task API
RemoteConnection RemoteRecipient = Recipient as RemoteConnection;
if( NextMessage is AgentTaskSpecification )
{
// All new Tasks are sent via the dedicated Task API
AgentTaskSpecification TaskSpecification = NextMessage as AgentTaskSpecification;
Hashtable RemoteInParameters = new Hashtable();
RemoteInParameters["Version"] = ESwarmVersionValue.VER_1_0;
RemoteInParameters["Specification"] = TaskSpecification;
Hashtable RemoteOutParameters = null;
Int32 Error = RemoteRecipient.Interface.AddTask( RemoteRecipient.Handle, RemoteInParameters, ref RemoteOutParameters );
if( Error >= 0 )
{
// Perhaps we should be sending an accept message back?
}
else
{
AgentTaskState UpdateMessage;
if( Error == Constants.ERROR_CONNECTION_DISCONNECTED )
{
// Special case of the connection dropping while we're adding the
// task, say it's been killed to requeue
UpdateMessage = new AgentTaskState( TaskSpecification.JobGuid,
TaskSpecification.TaskGuid,
EJobTaskState.TASK_STATE_KILLED );
}
else
{
// All other error cases will be rejections
UpdateMessage = new AgentTaskState( TaskSpecification.JobGuid,
TaskSpecification.TaskGuid,
EJobTaskState.TASK_STATE_REJECTED );
}
AgentJob Job;
if( ActiveJobs.TryGetValue( TaskSpecification.JobGuid, out Job ) )
{
Job.UpdateTaskState( UpdateMessage );
}
}
}
else
{
// All standard messages are sent via the SendMessage API
Hashtable RemoteInParameters = new Hashtable();
RemoteInParameters["Version"] = ESwarmVersionValue.VER_1_0;
RemoteInParameters["Message"] = NextMessage;
Hashtable RemoteOutParameters = null;
RemoteRecipient.Interface.SendMessage( NextMessage.To, RemoteInParameters, ref RemoteOutParameters );
}
string NewLogMessage = String.Format( "Step 2 of 2 for message: ({0:X8} -> {1:X8}), {2}, (Remote Connection)",
NextMessage.To,
NextMessage.From,
NextMessage.Type );
Log( EVerbosityLevel.SuperVerbose, ELogColour.Green, NewLogMessage );
}
}
else
{
Log( EVerbosityLevel.Informative, ELogColour.Orange, "ProcessMessage: Message sent to invalid connection, ignoring: " + NextMessage.Type.ToString() );
}
}
// If there are any responses to the message, send them
if( ResponseMessageQueue.Count > 0 )
{
foreach( AgentMessage NextResponse in ResponseMessageQueue )
{
// For each one of the messages, set the routing fields properly
NextResponse.To = NextMessage.From;
NextResponse.From = NextMessage.To;
// And then queue the message back up immediately
MessageQueuePM.Enqueue( NextResponse );
}
ResponseMessageQueue.Clear();
}
}
StopTiming();
// Wait for a message to become available and once unlocked, swap the queues
// and check for messages to process. Set a timeout, so we'll wake up every
// now and then to check for a quit signal at least
MessageQueueReady.WaitOne( 500 );
}
}
public void HackerCheckerThreadLoop()
{
Double checkedPlayers = 0;
Double playersWithStats = 0;
try {
this.DebugWrite("HCKCHK: Starting Hacker Checker Thread", 1);
Thread.CurrentThread.Name = "HackerChecker";
Queue<AdKatsPlayer> playerCheckingQueue = new Queue<AdKatsPlayer>();
Queue<AdKatsPlayer> repeatCheckingQueue = new Queue<AdKatsPlayer>();
while (true) {
try {
this.DebugWrite("HCKCHK: Entering Hacker Checker Thread Loop", 7);
if (!this._IsEnabled) {
playerCheckingQueue.Clear();
repeatCheckingQueue.Clear();
this.DebugWrite("HCKCHK: Detected AdKats not enabled. Exiting thread " + Thread.CurrentThread.Name, 6);
break;
}
try {
//Get all unchecked players
if (this._HackerCheckerQueue.Count > 0) {
this.DebugWrite("HCKCHK: Preparing to lock hackerCheckerMutex to retrive new players", 6);
lock (this._HackerCheckerMutex) {
this.DebugWrite("HCKCHK: Inbound players found. Grabbing.", 5);
//Grab all players in the queue
playerCheckingQueue = new Queue<AdKatsPlayer>(this._HackerCheckerQueue.ToArray());
//Clear the queue for next run
this._HackerCheckerQueue.Clear();
}
}
else {
this.DebugWrite("HCKCHK: No inbound hacker checks. Waiting 10 seconds or for input.", 4);
//Wait for input
this._HackerCheckerWaitHandle.Reset();
//Either loop when handle is set, or after 3 minutes
this._HackerCheckerWaitHandle.WaitOne(180000 / ((repeatCheckingQueue.Count > 0) ? (repeatCheckingQueue.Count) : (1)));
}
}
catch (Exception e) {
this.HandleException(new AdKatsException("Error while fetching new players to check.", e));
}
//Current player being checked
AdKatsPlayer aPlayer = null;
try {
//Check one player from the repeat checking queue
if (repeatCheckingQueue.Count > 0) {
//Only keep players still in the server in the repeat checking list
Boolean stillInServer = true;
do {
if (!this._IsEnabled) {
break;
}
aPlayer = repeatCheckingQueue.Dequeue();
if (!this._PlayerDictionary.ContainsKey(aPlayer.player_name)) {
stillInServer = false;
}
} while (!stillInServer && repeatCheckingQueue.Count > 0);
if (aPlayer != null) {
//Fetch their stats from appropriate source
this.FetchPlayerStats(aPlayer);
//check for dmg mod if stats available
if (aPlayer.stats != null && aPlayer.stats.StatsException == null) {
playersWithStats++;
this.ConsoleSuccess(aPlayer.player_name + " now has stats. Checking.");
if (this._UseHackerChecker) {
if (!this.PlayerProtected(aPlayer)) {
this.RunStatSiteHackCheck(aPlayer, false);
}
}
else {
this.DebugWrite("Player removed from check list after disabling hacker checker.", 2);
}
this.DebugWrite("Players with " + this._GameVersion + "Stats: " + String.Format("{0:0.00}", (playersWithStats / checkedPlayers) * 100) + "%", 3);
}
else {
aPlayer.stats = null;
//If they still dont have stats, add them back to the queue
repeatCheckingQueue.Enqueue(aPlayer);
}
}
}
}
catch (Exception e) {
this.HandleException(new AdKatsException("Error while in repeat checking queue handler", e));
}
//Get all checks in order that they came in
while (playerCheckingQueue.Count > 0) {
if (!this._IsEnabled) {
break;
}
//Grab first/next player
aPlayer = playerCheckingQueue.Dequeue();
if (aPlayer != null) {
this.DebugWrite("HCKCHK: begin reading player", 4);
if (!this.PlayerProtected(aPlayer)) {
this.FetchPlayerStats(aPlayer);
checkedPlayers++;
//check for dmg mod if stats available
if (aPlayer.stats != null && aPlayer.stats.StatsException == null) {
playersWithStats++;
if (this._UseHackerChecker) {
this.RunStatSiteHackCheck(aPlayer, false);
}
else {
this.DebugWrite("Player skipped after disabling hacker checker.", 2);
}
}
else {
//this.ConsoleError(aPlayer.player_name + " doesn't have stats.");
repeatCheckingQueue.Enqueue(aPlayer);
}
this.DebugWrite("Players with " + this._GameVersion + "Stats: " + String.Format("{0:0.00}", (playersWithStats / checkedPlayers) * 100) + "%", 3);
}
}
}
}
catch (Exception e)
{
if (e is ThreadAbortException)
{
this.HandleException(new AdKatsException("Hacker Checker thread aborted. Exiting."));
break;
}
this.HandleException(new AdKatsException("Error occured in Hacker Checker thread. Skipping current loop.", e));
}
}
this.DebugWrite("HCKCHK: Ending Hacker Checker Thread", 1);
}
catch (Exception e) {
this.HandleException(new AdKatsException("Error occured in Hacker Checker thread.", e));
}
}
public void Clear()
{
m_logQueue.Clear();
}
public bool DoFracture(ref Particle other, ref Particle me)
{
bool somethingBroke = false;
double len = (other.goal - goal).Length();
double rest = (other.x0 - x0).Length();
double off = Math.Abs((len / rest) - 1.0);
if (off > LsmBody.fractureLengthTolerance)
{
somethingBroke = true;
Testbed.PostMessage("Length fracture: Rest = " + rest + ", actual = " + len);
}
if (!somethingBroke)
{
Vector2 a = new Vector2(other.R[0, 0], other.R[1, 0]);
Vector2 b = new Vector2(R[0, 0], R[1, 0]);
a.Normalize();
b.Normalize();
double angleDifference = Math.Acos(a.Dot(b));
if (angleDifference > LsmBody.fractureAngleTolerance)
{
somethingBroke = true;
Testbed.PostMessage("Angle fracture: angle difference = " + angleDifference);
}
}
if (somethingBroke)
{
Particle saved = other;
me = null;
other = null;
// Check if the chunks are still connected
Queue<Particle> edge = new Queue<Particle>();
List<Particle> found = new List<Particle>();
edge.Enqueue(this);
bool connected = false;
while (edge.Count > 0)
{
Particle p = edge.Dequeue();
if (!found.Contains(p))
{
found.Add(p);
if (p == saved)
{
// Connected
connected = true;
break;
}
if (p.xPos != null)
edge.Enqueue(p.xPos);
if (p.xNeg != null)
edge.Enqueue(p.xNeg);
if (p.yPos != null)
edge.Enqueue(p.yPos);
if (p.yNeg != null)
edge.Enqueue(p.yNeg);
}
}
if (connected == false)
{
// The chunks broke - there are now two separate chunks (maximally connected subgraphs)
chunk.particles.Clear();
chunk.particles.AddRange(found);
chunk.CalculateInvariants();
Chunk newChunk = new Chunk();
edge.Clear();
found.Clear();
edge.Enqueue(saved);
while (edge.Count > 0)
{
Particle p = edge.Dequeue();
if (!found.Contains(p))
{
found.Add(p);
p.chunk = newChunk;
if (p.xPos != null)
edge.Enqueue(p.xPos);
if (p.xNeg != null)
edge.Enqueue(p.xNeg);
if (p.yPos != null)
edge.Enqueue(p.yPos);
if (p.yNeg != null)
edge.Enqueue(p.yNeg);
}
}
newChunk.particles.AddRange(found);
newChunk.CalculateInvariants();
body.chunks.Add(newChunk);
Testbed.PostMessage("Chunk broken: the original chunk now has " + chunk.particles.Count + " particles, the new chunk has " + newChunk.particles.Count + " particles.");
Testbed.PostMessage("Number of chunks / particles: " + body.chunks.Count + " / " + body.particles.Count);
}
}
return somethingBroke;
}
private void ExecuteAlgorithm(int x, int y, IsValidHandler isValid, PointActionHandler action)
{
///Flood-Fill algorithm
Queue<Point> q = new Queue<Point>();
if (regionMask[x, y])
return;
q.Enqueue(new Point(x, y));
while (q.Count > 0)
{
Point p = q.Peek();
int x1 = p.X;
int y1 = p.Y;
if (isValid.Invoke(p))
{
action.Invoke(p.X, p.Y);
}
if (isValid.Invoke(new Point(x1, y1 + 1)))
{
action.Invoke(x1, y1 + 1);
q.Enqueue(new Point(x1, y1 + 1));
}
if (isValid.Invoke(new Point(x1, y1 - 1)))
{
action.Invoke(x1, y1 - 1);
q.Enqueue(new Point(x1, y1 - 1));
}
if (isValid.Invoke(new Point(x1 + 1, y1)))
{
action.Invoke(x1 + 1, y1);
q.Enqueue(new Point(x1 + 1, y1));
}
if (isValid.Invoke(new Point(x1 - 1, y1)))
{
action.Invoke(x1 - 1, y1);
q.Enqueue(new Point(x1 - 1, y1));
}
q.Dequeue();
if (border)
{
q.Clear();
depth = Int32.MaxValue;
}
}
///end of Flood-Fill algorithm
}
void CompleteAllOnDispose (Queue queue)
{
object [] pending = queue.ToArray ();
queue.Clear ();
WaitCallback cb;
for (int i = 0; i < pending.Length; i++) {
Worker worker = (Worker) pending [i];
SocketAsyncResult ares = worker.result;
cb = new WaitCallback (ares.CompleteDisposed);
#if MOONLIGHT
ThreadPool.QueueUserWorkItem (cb, null);
#else
ThreadPool.UnsafeQueueUserWorkItem (cb, null);
#endif
}
}
/// <summary>
/// 清除指定类型的资源缓存
/// </summary>
/// <param name="resType"></param>
/// <param name="clearDepend"></param>
public static void Clear(EResType resType, bool clearDepend = false)
{
var delList = new List<string>();
var list = new Queue<string>();
foreach (var resourceItem in m_resourceItemDic)
{
if (resourceItem.Value.Type == resType)
{
var path = resourceItem.Value.Path;
//Debug.LogError("before: " + path);
if (resType == EResType.Texture)
{
var assetName = getImagAssetName(resourceItem.Value.Path);
path = getImagePath(assetName);
}
//Debug.LogError("after: " + path);
delList.Add(path);
if (clearDepend)
{
list.Clear();
GetAllDependResources(resourceItem.Value.Path, list);
delList.AddRange(list);
}
}
}
for (int i = 0; i < delList.Count; i++)
{
if (m_resourceItemDic.ContainsKey(delList[i]))
{
m_resourceItemDic[delList[i]].Clear();
m_resourceItemDic.Remove(delList[i]);
i--;
}
}
delList.Clear();
}
public void dancefunction()
{
danceq = new Queue();
dancemre = new ManualResetEvent(false);
evtSkill s;
while (true)
{
dancemre.WaitOne();
if (gs.buffs == false)
{
lock (dancelock)
{
danceq.Clear();
}
}
while (danceq.Count > 0)
{
startdance = true;
lock (dancelock)
{
if (danceq.Count == 0)
continue;
s = (evtSkill)danceq.Dequeue();
}
//System.Console.WriteLine("launching skill {0} - event {1}", s.act.name, s.evt.name);
s.succeed = false;
launchMagic(s.act, 0, 0);
//bool ret = s.mre.WaitOne(3000);
//s.mre.Reset();
if (s.succeed || s.act.skillstate())
{
////skill succeeded
//probably do nothing?
//Console.WriteLine("skill {0} succeeded", s.act.name);
s.act.setstate(false);
}
else
{
//skill failed .. requeue
// Console.WriteLine("skill {0} failed", s.act.name);
lock (dancelock)
{
ReSkill r = new ReSkill(s.act, 0);
redolist.Enqueue(r);
}
}
}
startdance = false;
dancemre.Reset();
}
}
public void GeneratePLTS()
{
int i, j, m, k;
uint eidcount = 10;
uint sidbegin;
uint sid;
uint layernum;
uint current;
uint Allsnum = 0;
HashSet<uint> tmpeset = new HashSet<uint>();
Queue<uint> generatelts = new Queue<uint>();
Dictionary<uint, uint> tmpdic = new Dictionary<uint,uint>();
List<KeyValuePair<uint,uint>> tmplist;
Random rd = new Random((int)System.DateTime.Today.Ticks);
generatelts.Enqueue(1);
string path1 = "./test/Lts1.txt";
string path2 = "./test/Lts2.txt";
string path3 = "./test/evt.txt";
string path4 = "./test/allsnum.txt";
StreamWriter [] sw = new StreamWriter[2];
sw[0] = new StreamWriter(path1, true);
sw[1] = new StreamWriter(path2, true);
StreamWriter sw2 = new StreamWriter(path3, true);
StreamWriter sw3 = new StreamWriter(path4, true);
for (i = 0; i < LTSnum; i++)
{
Allsnum++;
layernum = (uint)(Math.Pow(2, beginsynlayer)*2 - 1);
for (j = 0; j < layernum; j++)
{
current = generatelts.Dequeue();
//layernum = layernum * 2;
sidbegin = current * 2;
for (m = 0; m < 2; m++)
{
sid = sidbegin + (uint)m;
generatelts.Enqueue(sid);
Allsnum++;
if (i == 0)
{
eidcount = (uint)rd.Next(11, 31);
if(!tmpeset.Contains(eidcount))
{
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
else
{
while (tmpeset.Contains(eidcount))
{
eidcount = (uint)rd.Next(11, 31);
}
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
}
else
{
eidcount = (uint)rd.Next(31, 51);
if (!tmpeset.Contains(eidcount))
{
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
else
{
while (tmpeset.Contains(eidcount))
{
eidcount = (uint)rd.Next(11, 31);
}
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
}
//sw[i].Write(" ");
tmpdic.Add(eidcount,sid);
}
tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
tmplist = tmpdic.ToList();
for(k = 0; k < tmplist.Count; k++){
sw[i].Write(tmplist[k].Key);
sw[i].Write(" ");
sw[i].Write(tmplist[k].Value);
sw[i].Write(" ");
}
tmpeset.Clear();
tmpdic.Clear();
sw[i].Write("\n");
}
layernum = (uint)(Math.Pow(2, beginsynlayer + 1));
layernum = (uint)((layernum + layernum*4*(totallayer-beginsynlayer-1))*(totallayer-beginsynlayer))/2;
for (k = 0; k < layernum; k++ )
{
current = generatelts.Dequeue();
sidbegin = current * 4;
if (rd.Next(0, 2) == 0)
{
for (m = 0; m < 4; m++)
{
sid = sidbegin + (uint)m;
generatelts.Enqueue(sid);
Allsnum++;
if (i == 0)
{
eidcount = (uint)rd.Next(11, 31);
if (!tmpeset.Contains(eidcount))
{
tmpeset.Add(eidcount);
if(!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
else
{
while (tmpeset.Contains(eidcount))
{
eidcount = (uint)rd.Next(11, 31);
}
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
}
else
{
eidcount = (uint)rd.Next(31, 51);
if (!tmpeset.Contains(eidcount))
{
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
// sw[i].Write(eidcount);
}
else
{
while (tmpeset.Contains(eidcount))
{
eidcount = (uint)rd.Next(31, 51);
}
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
}
tmpdic.Add(eidcount, sid);
//sw[i].Write(" ");
//sw[i].Write(sid);
}
tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
tmplist = tmpdic.ToList();
for(m = 0; m < tmplist.Count; m++){
sw[i].Write(tmplist[m].Key);
sw[i].Write(" ");
sw[i].Write(tmplist[m].Value);
sw[i].Write(" ");
}
tmpeset.Clear();
tmpdic.Clear();
sw[i].Write("\n");
}
else
{
sid = sidbegin;
generatelts.Enqueue(sid);
Allsnum++;
if(i == 0)
eidcount = (uint)rd.Next(11, 31);
else
eidcount = (uint)rd.Next(31, 51);
sw[i].Write(eidcount);
sw[i].Write(" ");
sw[i].Write(sid);
sw[i].Write(" 0 1 ");
for (m = 1; m < 4; m++)
{
sid = sidbegin + (uint)m;
generatelts.Enqueue(sid);
Allsnum++;
eidcount = (uint)rd.Next(0, 11);
if (!tmpeset.Contains(eidcount))
{
//sw[i].Write(eidcount);
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
}
else
{
while (tmpeset.Contains(eidcount))
{
eidcount = (uint)rd.Next(11, 31);
}
tmpeset.Add(eidcount);
if (!this.eventlist.Contains(eidcount))
this.eventlist.Add(eidcount);
//sw[i].Write(eidcount);
}
tmpdic.Add(eidcount, sid);
//sw[i].Write(" ");
//sw[i].Write(sid);
}
tmpdic = tmpdic.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
tmplist = tmpdic.ToList();
for(m = 0; m < tmplist.Count; m++){
sw[i].Write(tmplist[m].Key);
sw[i].Write(" ");
sw[i].Write(tmplist[m].Value);
sw[i].Write(" ");
}
tmpeset.Clear();
tmpdic.Clear();
sw[i].Write("\n");
}
}
while (generatelts.Count > 0)
{
sw[i].Write("\n");
generatelts.Dequeue();
}
sw[i].Flush();
sw[i].Close();
generatelts.Clear();
generatelts.Enqueue(1);
}
for (k = 0; k < this.eventlist.Count; k++)
{
sw2.Write(this.eventlist[k]);
sw2.Write(" ");
}
sw2.Flush();
sw2.Close();
sw3.Write(Allsnum);
sw3.Write("\n");
sw3.Flush();
sw3.Close();
}
public bool Load(Queue<Token> tokens, Type tokenizerType,TemplateGroup group)
{
Token t = tokens.Dequeue();
Queue<Token> toks = new Queue<Token>();
Match m;
if (regSimpleStyle.IsMatch(t.Content)){
m = regSimpleStyle.Match(t.Content);
toks.Enqueue(new Token(m.Groups[1].Value.Trim(), TokenType.COMPONENT));
_left = ComponentExtractor.ExtractComponent(toks,tokenizerType,group);
toks.Clear();
switch (m.Groups[2].Value.ToUpper())
{
case "NE":
_type = CompareType.NOT_EQUAL;
break;
case "GT":
_type = CompareType.GREATER_THAN;
break;
case "GE":
_type = CompareType.GREATER_THAN_OR_EQUAL_TO;
break;
case "LT":
_type = CompareType.LESS_THAN;
break;
case "LE":
_type = CompareType.LESS_THAN_OR_EQUAL_TO;
break;
case "ST":
_type = CompareType.SIMILAR_TO;
break;
case "NS":
_type = CompareType.NOT_SIMILAR_TO;
break;
}
if (m.Groups[11].Value.Trim().StartsWith("'")||m.Groups[11].Value.Trim().StartsWith("\""))
toks.Enqueue(new Token(m.Groups[11].Value.Trim().Substring(1,m.Groups[11].Value.Trim().Length-2), TokenType.TEXT));
else
toks.Enqueue(new Token(m.Groups[11].Value.Trim(),TokenType.COMPONENT));
_right = ComponentExtractor.ExtractComponent(toks,tokenizerType,group);
}else{
m = regFunctionStyle.Match(t.Content);
switch (m.Groups[1].Value.ToUpper())
{
case "NOTEQUAL":
_type = CompareType.NOT_EQUAL;
break;
case "GREATERTHAN":
_type = CompareType.GREATER_THAN;
break;
case "GREATERTHANOREQUALTO":
_type = CompareType.GREATER_THAN_OR_EQUAL_TO;
break;
case "LESSTHAN":
_type = CompareType.LESS_THAN;
break;
case "LESSTHANOREQUALTO":
_type = CompareType.LESS_THAN_OR_EQUAL_TO;
break;
case "SIMILARTO":
_type = CompareType.SIMILAR_TO;
break;
case "NOTSIMILARTO":
_type = CompareType.NOT_SIMILAR_TO;
break;
}
toks.Enqueue(new Token(m.Groups[12].Value,TokenType.COMPONENT));
_left = ComponentExtractor.ExtractComponent(toks, tokenizerType, group);
toks.Clear();
if (m.Groups[13].Value.Trim().StartsWith("'") || m.Groups[13].Value.Trim().StartsWith("\""))
toks.Enqueue(new Token(m.Groups[12].Value.Trim().Substring(1, m.Groups[13].Value.Trim().Length - 2), TokenType.TEXT));
else
toks.Enqueue(new Token(m.Groups[13].Value.Trim(), TokenType.COMPONENT));
_right = ComponentExtractor.ExtractComponent(toks, tokenizerType, group);
}
return true;
}
private void UpdateRightNodes(Node openNode, IList<Node> visitedNodes,
Queue<Node> openNodes, IList<Pair<Node>> parent)
{
foreach (var rightNode in _rightNodes)
{
bool freeNodeFound = true;
if (HasEdge(openNode, rightNode) && !visitedNodes.Contains(rightNode))
{
if (_matching.Any(matchingPair => matchingPair.Second.Equals(rightNode)))
{
openNodes.Enqueue(rightNode);
freeNodeFound = false;
}
UpdateParentList(parent, rightNode, openNode);
if (freeNodeFound)
{
UpdateMatching(parent, rightNode);
openNodes.Clear();
break;
}
}
}
}
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
int reading_size = 0;
using (TcpClient tcp = new TcpClient())
{
Queue<byte> reading_queue = new Queue<byte>(8192);
try
{
Thread.Sleep(m_delay_between_sending);
tcp.SendTimeout = 500;
tcp.ReceiveTimeout = 500;
IAsyncResult ar = tcp.BeginConnect(m_address, m_port, null, null);
using (WaitHandle wh = ar.AsyncWaitHandle)
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(10), false))
{
throw new TimeoutException();
}
else
{
if (tcp.Client.Connected)
{
tcp.Client.ReceiveTimeout = m_read_timeout;
tcp.Client.SendTimeout = m_write_timeout;
// посылка данных
if (tcp.Client.Send(out_buffer, out_length, SocketFlags.None) == out_length)
{
uint elapsed_time_count = 0;
Thread.Sleep(50);
// чтение данных
while (elapsed_time_count < m_read_timeout)
{
if (tcp.Client.Available > 0)
{
try
{
byte[] tmp_buff = new byte[tcp.Available];
int readed_bytes = tcp.Client.Receive(tmp_buff, 0, tmp_buff.Length, SocketFlags.None);
for (int i = 0; i < readed_bytes; i++)
{
reading_queue.Enqueue(tmp_buff[i]);
}
}
catch (Exception ex)
{
WriteToLog("Receive: " + ex.Message);
}
}
elapsed_time_count += 50;
Thread.Sleep(50);
}
int pos = -1;
if ((pos = func(reading_queue)) >= 0)
{
for (int i = 0; i < pos; i++)
{
reading_queue.Dequeue();
}
byte[] temp_buffer = new byte[reading_size = reading_queue.Count];
temp_buffer = reading_queue.ToArray();
if (target_in_length == 0)
{
if (reading_size > pos_count_data_size)
{
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
}
}
if (target_in_length > 0)
{
if (reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
}
}
}
}
}
}
}
}
catch (Exception ex)
{
WriteToLog(ex.Message);
return -1;
}
finally
{
reading_queue.Clear();
}
}
return reading_size;
}
public void SendThreadEntryPoint(object state)
{
try
{
Queue workQueue = new Queue();
// loop...
while (true)
{
WaitHandle[] handles = new WaitHandle[2];
handles[0] = StopEvent;
handles[1] = DataReady;
if (WaitHandle.WaitAny(handles) == 0)
{
break;
}
else if (_Socket != null && _Socket.Connected)
{
// not disconnected
// go through the queue...
TransmitLock.AcquireWriterLock(-1);
try
{
workQueue.Clear();
foreach (string message in TransmitQueue)
{
workQueue.Enqueue(message);
}
TransmitQueue.Clear();
}
catch { }
finally
{
TransmitLock.ReleaseWriterLock();
}
// loop the outbound messages...
foreach (string message in workQueue)
{
SocketStateObject so2 = new SocketStateObject(_Socket);
byte[] buff = Encoding.ASCII.GetBytes(message);
// send it...
System.IAsyncResult iar;
iar = _Socket.BeginSend(buff, 0, buff.Length, 0, new AsyncCallback(AsynchSendCallback), so2);
}
}
}
}
catch { }
}
public static void BuildSectorNodeNetwork(CommandEventArgs e)
{
if (m_Nodes == null)
{
try
{
Console.Write("Initializing SectorNodes...");
DateTime dt = DateTime.Now;
m_Nodes = new SectorNode[Map.Felucca.Width >> Map.SectorShift, Map.Felucca.Height >> Map.SectorShift];
for (int y = 0; y < (Map.Felucca.Height >> Map.SectorShift); y++)
{
for (int x = 0; x < (Map.Felucca.Width >> Map.SectorShift); x++)
{
SectorNode sn = new SectorNode();
sn.Point = Point3D.Zero;
sn.Island = -1;
sn.Links = new SectorNode[8];
sn.Distances = new int[8];
sn.NumLinks = 0;
for (int sy = 0; sy < Map.SectorSize && sn.Point == Point3D.Zero; sy++)
{
for (int sx = 0; sx < Map.SectorSize && sn.Point == Point3D.Zero; sx++)
{
if (Map.Felucca.CanSpawnMobile((x << Map.SectorShift) + sx, (y << Map.SectorShift) + sy,
Map.Felucca.GetAverageZ((x << Map.SectorShift) + sx, (y << Map.SectorShift) + sy)))
{
sn.Point = new Point3D((x << Map.SectorShift) + sx, (y << Map.SectorShift) + sy,
Map.Felucca.GetAverageZ((x << Map.SectorShift) + sx, (y << Map.SectorShift) + sy));
}
}
}
m_Nodes[x, y] = sn;
}
}
Console.WriteLine("done in {0} seconds.", (DateTime.Now - dt).TotalSeconds);
Console.Write("Computing SectorNode network...");
dt = DateTime.Now;
Mobile m = new Server.Mobiles.WanderingHealer();
MovementPath mp = null;
for (int y = 0; y < (Map.Felucca.Height >> Map.SectorShift); y++)
{
for (int x = 0; x < (Map.Felucca.Width >> Map.SectorShift); x++)
{
if (m_Nodes[x, y].Point != Point3D.Zero)
{
m.MoveToWorld(m_Nodes[x, y].Point, Map.Felucca);
if (x < (Map.Felucca.Width >> Map.SectorShift) - 1 && y > 0 && m_Nodes[x + 1, y - 1].Point != Point3D.Zero &&
(mp = new MovementPath(m, m_Nodes[x + 1, y - 1].Point)).Success)
{
m_Nodes[x, y].Links[m_Nodes[x, y].NumLinks] = m_Nodes[x + 1, y - 1];
m_Nodes[x, y].Distances[m_Nodes[x, y].NumLinks] = mp.Directions.Length;
m_Nodes[x, y].NumLinks++;
m_Nodes[x + 1, y - 1].Links[m_Nodes[x + 1, y - 1].NumLinks] = m_Nodes[x, y];
m_Nodes[x + 1, y - 1].Distances[m_Nodes[x + 1, y - 1].NumLinks] = mp.Directions.Length;
m_Nodes[x + 1, y - 1].NumLinks++;
}
if (x < (Map.Felucca.Width >> Map.SectorShift) - 1 && m_Nodes[x + 1, y].Point != Point3D.Zero &&
(mp = new MovementPath(m, m_Nodes[x + 1, y].Point)).Success)
{
m_Nodes[x, y].Links[m_Nodes[x, y].NumLinks] = m_Nodes[x + 1, y];
m_Nodes[x, y].Distances[m_Nodes[x, y].NumLinks] = mp.Directions.Length;
m_Nodes[x, y].NumLinks++;
m_Nodes[x + 1, y].Links[m_Nodes[x + 1, y].NumLinks] = m_Nodes[x, y];
m_Nodes[x + 1, y].Distances[m_Nodes[x + 1, y].NumLinks] = mp.Directions.Length;
m_Nodes[x + 1, y].NumLinks++;
}
if (x < (Map.Felucca.Width >> Map.SectorShift) - 1 && y < (Map.Felucca.Height >> Map.SectorShift) - 1 &&
m_Nodes[x + 1, y + 1].Point != Point3D.Zero && (mp = new MovementPath(m, m_Nodes[x + 1, y + 1].Point)).Success)
{
m_Nodes[x, y].Links[m_Nodes[x, y].NumLinks] = m_Nodes[x + 1, y + 1];
m_Nodes[x, y].Distances[m_Nodes[x, y].NumLinks] = mp.Directions.Length;
m_Nodes[x, y].NumLinks++;
m_Nodes[x + 1, y + 1].Links[m_Nodes[x + 1, y + 1].NumLinks] = m_Nodes[x, y];
m_Nodes[x + 1, y + 1].Distances[m_Nodes[x + 1, y + 1].NumLinks] = mp.Directions.Length;
m_Nodes[x + 1, y + 1].NumLinks++;
}
if (y < (Map.Felucca.Height >> Map.SectorShift) - 1 && m_Nodes[x, y + 1].Point != Point3D.Zero &&
(mp = new MovementPath(m, m_Nodes[x, y + 1].Point)).Success)
{
m_Nodes[x, y].Links[m_Nodes[x, y].NumLinks] = m_Nodes[x, y + 1];
m_Nodes[x, y].Distances[m_Nodes[x, y].NumLinks] = mp.Directions.Length;
m_Nodes[x, y].NumLinks++;
m_Nodes[x, y + 1].Links[m_Nodes[x, y + 1].NumLinks] = m_Nodes[x, y];
m_Nodes[x, y + 1].Distances[m_Nodes[x, y + 1].NumLinks] = mp.Directions.Length;
m_Nodes[x, y + 1].NumLinks++;
}
}
}
}
m.Delete();
Console.WriteLine("done in {0} seconds.", (DateTime.Now - dt).TotalSeconds);
Console.Write("Finding islands...");
dt = DateTime.Now;
int nextIsland = 0;
Queue open = new Queue();
ArrayList closed = new ArrayList();
for (int y = 0; y < (Map.Felucca.Height >> Map.SectorShift); y++)
{
for (int x = 0; x < (Map.Felucca.Width >> Map.SectorShift); x++)
{
if (m_Nodes[x, y].Point == Point3D.Zero)
continue;
if (m_Nodes[x, y].Island == -1)
{
int island = nextIsland++;
// now use dijkstra-style flood fill to find all connected nodes
open.Clear();
closed.Clear();
open.Enqueue(m_Nodes[x, y]);
while (open.Count > 0)
{
SectorNode sn = (SectorNode)open.Dequeue();
closed.Add(sn);
sn.Island = island;
for (int i = 0; i < sn.NumLinks; i++)
if (!closed.Contains(sn.Links[i]) && !open.Contains(sn.Links[i]))
open.Enqueue(sn.Links[i]);
}
}
}
}
Console.WriteLine("done in {0} seconds.", (DateTime.Now - dt).TotalSeconds);
}
catch (Exception ex)
{
LogHelper.LogException(ex);
Console.WriteLine("error!");
Console.WriteLine(ex);
}
}
}
void OnDestroy()
{
//m_sInstance = null;
PendingActions.Clear();
ActiveAction = null;
}
