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; }