public ThreadedAntiFlood(TickTime Start, long Interval, TickTime.Unit Unit) { this.Start = Start; this.Interval = Interval; this.Unit = Unit; locker = new object(); }
/// <summary> /// Waits for timeout /// </summary> /// <param name="start"></param> /// <param name="timeout"></param> /// <param name="unit"></param> /// <param name="intensity"></param> public static void Sleep(TickTime start, long timeout, TickTime.Unit timeoutUnit = TickTime.Unit.ms) { if (timeoutUnit < TickTime.Unit.ms) { throw new Exception("timeoutUnit is to small, must be greater or equal to ms"); } long end = start.Ticks + ((long)timeoutUnit * timeout); long now = TickTime.NowTicks; if (end <= now) { return; } /*while (end > now) * { * Thread.Sleep(1); * now = TickTime.NowTicks; * }*/ long wait = end - now; int sleep = (int)(wait / (long)TickTime.Unit.ms); if (sleep <= 0) { return; } Thread.Sleep(sleep); }
public void Synchronize() { bool done = false; while (!done) { if (Monitor.TryEnter(locker)) { try { long constant = ((long)this.Unit * this.Interval); long end = this.Start.Ticks + constant; while (end > TickTime.NowTicks) { int speep = AMath.Random(1, 11); Thread.Sleep(speep); end = this.Start.Ticks + constant; } this.Start = TickTime.Now; } finally { Monitor.Exit(locker); done = true; } } else { done = false; Thread.Sleep(100); } } }
/// <summary> /// @"Token\Pair\BID\OFFER\HIGH\LOW\STATUS\NOTATION\DECIMALS\CLOSINGBID", @"\"); /// </summary> /// <param name="data"></param> /// <param name="dateTimeFormat"></param> /// <returns></returns> public Rate ToRateOnConnect(string data, ref TickTime origin) { if (System.String.IsNullOrEmpty(data) || data.Length < 10) { return(null); } //Ignore token, might be corrupted string[] properties = Asmodat.Abbreviate.String.ToList(data, "\\"); if (properties.Length != 10) { return(null); } string status = properties[6]; string notation = properties[7]; if (status != "D" && status != "R") { return(null); } if (notation != "E" && notation != "A") { return(null); } Rate rate = new Rate(); try { rate.Pair = properties[1]; rate.DECIMALS = ForexConfiguration.GetDecimals(rate.Pair); rate.BID = Doubles.Parse(properties[2], rate.DECIMALS); rate.OFFER = Doubles.Parse(properties[3], rate.DECIMALS); rate.HIGH = Doubles.Parse(properties[4], rate.DECIMALS); rate.LOW = Doubles.Parse(properties[5], rate.DECIMALS); rate.STATUS = status; rate.NOTATION = notation; rate.CLOSINGBID = Doubles.Parse(properties[8], rate.DECIMALS); rate.ChartData.TickTime = (origin += 1); //backtest double pchange = RateInfo.ChangePercentage(rate.BID, rate.OFFER, rate.HIGH, rate.LOW); if (pchange < 25) { return(null); } } catch (Exception e) { Exceptions.Add(e); return(null); } return(rate); }
public StatusEffect(StatusEffectScriptableObject data, TickTime tickTime, int duration) { this.data = ScriptableObject.Instantiate <StatusEffectScriptableObject>(data); this.tickTime = tickTime; durationRemaining = duration; }
public void Update(TickTime tickTime) { lock (Factory.GameObjectsLock) { Parallel.ForEach(Factory.GameObjects, gameobject => gameobject.Update(tickTime)); } CurrentState.Update(tickTime); }
public void Update(TickTime delta) { //_position += Velocity * delta.GameTimeDelta.TotalSeconds; Transformation = Mat4.Translate(_position) * new Euler(Angle.FromDegrees(45),0,0).ToQuat().ToMat4(); //Console.WriteLine(Transformation); //Transformation *= Mat4.RotateX(Angle.FromDegrees(.5)); //Transformation *= Mat4.RotateY(Angle.FromDegrees(.5)); //Transformation *= Mat4.RotateZ(Angle.FromDegrees(.5)); }
public void WaitForResponse(int timeout, TickTime.Unit unit = TickTime.Unit.ms) { TickTime start = TickTime.Now; while (!TickTime.Timeout(start, timeout, unit) && !Compleated) { Thread.Sleep(100); } }
public TradeEntry(object[] entry) { this.Price = decimal.Parse((string)entry[0]); this.Volume = decimal.Parse((string)entry[1]); this.Ticks = TickTime.FromUnixTimeStamp(double.Parse(entry[2].ToString())); this.buy_sell = (string)entry[3]; this.market_limit = (string)entry[4]; this.miscellaneous = (string)entry[5]; }
public void Update(TickTime tickTime) { if (Parent != null) { //Velocity = Velocity + (Acceleration * tickTime.GameTimeDelta.TotalSeconds); this.Rotation = this._rotation * (this.RotationalVelocity * tickTime.GameTimeDelta.TotalSeconds); this._position = this._position + (this.Velocity * tickTime.GameTimeDelta.TotalSeconds); } }
//TODO: NOT TESTED /// <summary> /// View your past trades. /// </summary> /// <param name="symbol">The pair traded (BTCUSD, LTCUSD, LTCBTC).</param> /// <param name="timestamp">Trades made before this timestamp won't be returned.</param> /// <param name="until">Optional. Trades made after this timestamp won't be returned.</param> /// <param name="limit_trades">Optional. Limit the number of trades returned. Default is 50.</param> /// <param name="reverse">Optional. Return trades in reverse order (the oldest comes first). Default is returning newest trades first.</param> /// <returns>An array of trades:</returns> public ObjPastTrades[] GetPastTrades(ApiProperties.Symbols symbol, TickTime timestamp, TickTime until, int limit_trades, int reverse) { return(GetPastTrades( symbol.GetEnumName(), timestamp.ToUnixTimeStamp(), until.ToUnixTimeStamp(), limit_trades, reverse )); }
//TODO: NOT TESTED /// <summary> /// View all of your balance ledger entries. /// </summary> /// <param name="currency">The currency to look for.</param> /// <param name="since">Optional. Return only the history after this timestamp.</param> /// <param name="until">Optional. Return only the history before this timestamp.</param> /// <param name="limit">Optional. Limit the number of entries to return. Default is 500.</param> /// <param name="wallet">Optional. Return only entries that took place in this wallet. Accepted inputs are: "trading", "exchange", "deposit".</param> /// <returns></returns> public ObjBalanceHistory GetBalanceHistory(ApiProperties.Currency currency, TickTime since, TickTime until, int limit, ApiProperties.WalletName wallet) { return(GetBalanceHistory( currency.GetEnumName(), since.ToUnixTimeStamp(), until.ToUnixTimeStamp(), limit, wallet.GetEnumName() )); }
private void dispatcherTimer_Tick(object sender, EventArgs e) { var vm = ViewModel as SecondViewModel; vm?.GetData(); //Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; //Int32 unixTickTimestamp = (Int32)(TickTime.Subtract(new DateTime(1970, 1, 1))).TotalSeconds; double result = TickTime.Subtract(DateTime.UtcNow).TotalSeconds; double percentResult = result / int.Parse(secText.Text); pbStatus.Value = 100 - (percentResult * 100); if (DateTime.UtcNow >= TickTime) { DispatcherTimer.Stop(); timercontrol.IsEnabled = true; slValue.IsEnabled = true; secText.IsEnabled = true; seriesCheck.IsEnabled = true; ExportToExcel exportToExcel = new ExportToExcel(); bool outResult; exportToExcel.ExportData(vm?.RootRefObjects, seriesChecklist, out outResult); if (outResult) { StopExport.IsEnabled = false; Export.IsEnabled = true; secText.IsEnabled = true; timercontrol.IsEnabled = true; seriesCheck.IsEnabled = true; progressArea.IsEnabled = false; pbStatus.Value = 0; MessageBox.Show("Success!!! Please check your Drive C"); } else { MessageBox.Show("Something went wrong! Please check your Microsoft Office installed?"); StopExport.IsEnabled = false; Export.IsEnabled = true; timercontrol.IsEnabled = true; secText.IsEnabled = true; seriesCheck.IsEnabled = true; progressArea.IsEnabled = false; pbStatus.Value = 0; } } }
/// <summary> /// Determines if /// </summary> /// <param name="DTKey"></param> /// <returns></returns> public bool IsValid(TickTime DTKey) { if (DTKey == TickTime.Default) { return(false); } else { return(true); } }
/// <summary> /// This is synchronised TCP Recive method, received data will be only written into buffer if received bytes contains End Of Message string. /// </summary> /// <param name="iTimeout">Determines, how long in [ms] method can be executed, if iTimeout is lower then 0, method will not be terminated. </param> private void Receive(int timeout = -1) { DateTime DTStart = DateTime.Now; TickTime TTStart = TickTime.Now; bool bTimeout = false; bool bDataFound = false; byte[] baData; string sData = sDataBuffer; string sMessage = null; string sMessageResidue = null; int iRecivedCount; while (!bTimeout && !bDataFound) { if (timeout > 0 && TickTime.Timeout(TTStart, timeout, TickTime.Unit.ms)) { bTimeout = true; } baData = new byte[1024]; iRecivedCount = SLClient.Receive(baData); sData += Encoding.ASCII.GetString(baData, 0, iRecivedCount); sMessage = sData.ExtractTag(TcpAsyncCommon.SOM, TcpAsyncCommon.EOM, out sMessageResidue); if (sMessage == null) { continue; } else { bDataFound = true; } } if (!bDataFound) { sDataBuffer = sData; return; } sDataBuffer = sMessageResidue; sData = sMessage; //sData.Replace(TcpAsyncClient.SOM, ""); //sData.Replace(TcpAsyncClient.EOM, ""); sData.Replace(@"\\", @"\"); DBReceive.Set(sData); }
private void DecodeData() { TickTime TimeOrigin = Data.FirstKey; string data = Data[TimeOrigin]; Data.Remove(TimeOrigin); //Remove data after reading string[] Packets = Asmodat.Abbreviate.String.ToList(data, "\r"); if (Packets == null || Packets.Length <= 0) { return; } for (int i = 0; i < Packets.Length; i++) { string packet = Packets[i]; TimeOrigin += i; if (System.String.IsNullOrEmpty(packet)) { continue; } List <Rate> Rates = this.DecodeRates(packet, ref TimeOrigin); if (Rates.Count <= 0) { Rate Rate = this.ToRateOnChange(packet, ref TimeOrigin); if (Rate != null && Rate.Token >= 0) { Rate.Pair = ForexConfiguration.OrderPair[Rate.Token]; Rate.ChartData.TickTime = TimeOrigin; Rates.Add(Rate); } else { //"UP\\DEAL\\EUR/USD\\1000\\1000\\0\\0\\0\\256044115\\121334263\\1137.75\\1.13775000\\49040.82\\0\\" } } if (ForexRates != null && ForexRates.Loaded) { ForexRates.UpdateDataRates(Rates.ToArray()); } ForexArchive.Update(ServiceConfiguration.TimeFrame.LIVE, Rates); ForexArchive.Updates += Rates.Count; } }
/// <summary> /// /// </summary> /// <param name="text"></param> /// <param name="color"></param> /// <param name="maxLines"></param> /// <param name="deleteMultiplayer">Reduces flicker of scrollbar</param> /// <param name="timeout"></param> public void AppendTextToStart(string text, Color color, int maxLines, double deleteMultiplayer = 2, int timeout = 1000) { try { bool readonlystate = this.ReadOnly; this.ReadOnly = false; TickTime start = TickTime.Now; this.SelectionStart = 0; this.SelectionLength = 0;// text.Length - 1; this.ScrollToCaret(); this.SelectionColor = color; this.SelectedText = text; if (this.Lines.Length >= maxLines) { while (this.Lines.Length >= (maxLines * deleteMultiplayer) && !TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { string rtext = this.Text; int last1 = rtext.IndexOfByCount('\n', -1); int last2 = rtext.IndexOfByCount('\n', -2); if (last1 < 0 || last2 < 0) { Asmodat.Debugging.Output.WriteLine("Not managed outcom in RichTextBox Abbreviate class !"); return; } this.SelectionStart = (int)last2 + 1; this.SelectionLength = ((int)last1 - (int)last2) + 1; this.SelectedText = ""; } } this.ScrollTop(); if (TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { Asmodat.Debugging.Output.WriteLine("Rtbx timeout."); } this.ReadOnly = readonlystate; } catch (Exception ex) { Asmodat.Debugging.Output.WriteException(ex); } }
/// <summary> /// /// </summary> /// <param name="DTime"></param> /// <param name="bIncrement"></param> /// <returns></returns> public string Get(TickTime DTime, bool bIncrement = false) { if (!DDTSBuffer.ContainsKey(DTime)) { return(null); } if (bIncrement) { ++Indexer; } return(DDTSBuffer[DTime]); }
public static void AppendTextToStart(RichTextBox RTBox, string text, Color color, int maxLines, int timeout = 1000) { RTBox.Invoke((MethodInvoker)(() => { bool readonlystate = RTBox.ReadOnly; try { RTBox.ReadOnly = false; RTBox.SelectionStart = 0; RTBox.SelectionLength = 0;// text.Length - 1; RTBox.ScrollToCaret(); RTBox.SelectionColor = color; RTBox.SelectedText = text; TickTime start = TickTime.Now; while (RTBox.Lines.Length >= maxLines && !TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { string rtext = RTBox.Text; int last1 = rtext.IndexOfByCount('\n', -1); int last2 = rtext.IndexOfByCount('\n', -2); if (last1 < 0 || last2 < 0) { Asmodat.Debugging.Output.WriteLine("Not managed outcom in RichTextBox Abbreviate class !"); return; } // throw new Exception("TODO: finish"); RTBox.SelectionStart = (int)last2 + 1; RTBox.SelectionLength = ((int)last1 - (int)last2) + 1; RTBox.SelectedText = ""; } RTBox.SelectionStart = 0; RTBox.SelectionLength = 0; RTBox.ScrollToCaret(); if (TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { Asmodat.Debugging.Output.WriteLine("Rtbx timeout."); } } catch (Exception ex) { Asmodat.Debugging.Output.WriteException(ex); } RTBox.ReadOnly = readonlystate; })); }
private void UpdateRates() { //ProductSetting PS = new ProductSetting(); string packet = GetRateBlotter(); TickTime origin = TickTime.Now; if (System.String.IsNullOrEmpty(packet)) { return; } List <Rate> Rates = this.DecodeRates(packet, ref origin); this.UpdateDataRates(Rates.ToArray()); }
public void Update(TickTime tickTime) { /* Parallel.ForEach(_engine.Factory.GameObjects.Values.Where(o => o is IHasPhysics).Select(o => (IHasPhysics)o), gameobject => { CheckCollision(gameobject); gameobject.Body.Update(tickTime); }); */ /* foreach (var o in _gameObjectFactory.GameObjects.Values.OfType<IHasPhysics>()) { CheckCollision(o); o.Body.Update(tickTime); }*/ }
protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { InitializeTrackingNumber(true); } if (SManager != null && SManager.ExchangeOrder != null) { if (!SManager.ExchangeOrder.TimeoutWarningsExecute.IsDefault && TickTime.Timeout(SManager.ExchangeOrder.TimeoutWarningsExecute, 5, TickTime.Unit.s)) { SManager.ExchangeOrder.TimeoutWarningsExecute = TickTime.Default; AlertsControlExecute.HideWarning(); } } }
public static string NewString() { try { TickTime start = TickTime.Now; string time = TickTime.NowTicks.ToString("X"); string random = AMath.Random(1, 1000000).ToString("X"); string span = start.Span().ToString("X"); return(string.Format("{0}{1}{2}", time, random, span)); } catch (Exception ex) { ex.ToOutput(); return(null); } }
public KeyValuePair <TickTime, string> GetPair(bool increment = false) { if (Indexer < 0) { return(new KeyValuePair <TickTime, string>(TickTime.Default, null)); } TickTime key = this.GetKey(Indexer); string value = this.GetValue(Indexer); var kvp = new KeyValuePair <TickTime, string>(key, value); if (increment) { this.IndexerIcrement(); } return(kvp); }
public void TimrServerTime() { if (!TimeoutServerTime.IsTriggered) { return; } TimeoutServerTime.Forced = true; TickTime time = this.GetServerTime(); if (time.IsDefault) { return; } this.ServerTime = time; TimeoutServerTime.Reset(); }
public static void AppendText(RichTextBox RTBox, string text, Color color, int maxLines, bool scroll = false, int timeout = 1000) { RTBox.Invoke((MethodInvoker)(() => { bool readonlystate = RTBox.ReadOnly; try { RTBox.ReadOnly = false; RTBox.SelectionStart = RTBox.TextLength; RTBox.SelectionLength = 0; RTBox.SelectionColor = color; RTBox.AppendText(text); RTBox.SelectionColor = RTBox.ForeColor; int iSelectionSave = RTBox.SelectionStart; TickTime start = TickTime.Now; while (RTBox.Lines.Length > maxLines && !TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { RTBox.SelectionStart = 0; RTBox.SelectionLength = RTBox.Text.IndexOf("\n", 0) + 1; RTBox.SelectedText = ""; } if (scroll && RTBox.Text != null) { RTBox.SelectionStart = RTBox.Text.Length; RTBox.ScrollToCaret(); } if (TickTime.Timeout(start, timeout, TickTime.Unit.ms)) { Asmodat.Debugging.Output.WriteLine("Rtbx timeout."); } } catch (Exception ex) { Asmodat.Debugging.Output.WriteException(ex); } RTBox.ReadOnly = readonlystate; })); }
public static void Sleep(ref TickTime start, long timeout, TickTime.Unit timeoutUnit = TickTime.Unit.ms) { if (timeoutUnit < TickTime.Unit.ms) { throw new Exception("timeoutUnit is to small, must be greater or equal to ms"); } long end = start.Ticks + ((long)timeoutUnit * timeout); long now = TickTime.NowTicks; if (end <= now) { return; } while (end > now) { Thread.Sleep(1); end = start.Ticks + ((long)timeoutUnit * timeout); now = TickTime.NowTicks; } }
private List <Rate> DecodeRates(string packet, ref TickTime origin) { List <Rate> Rates = new List <Rate>(); string[] DelimitedData = Asmodat.Abbreviate.String.ToList(packet, "$"); if (DelimitedData == null) { return(Rates); } foreach (string data in DelimitedData) { Rate Rate = this.ToRate(data, ref origin); if (Rate != null) { Rates.Add(Rate); } } return(Rates); }
/// <summary> /// Decodes data and sets reciving time if origin != TickTime.MinValue /// </summary> /// <param name="packet"></param> /// <param name="origin"></param> /// <returns></returns> private List <Rate> DecodeRates(string packet, ref TickTime origin) { List <Rate> Rates = new List <Rate>(); string[] DelimitedData = Asmodat.Abbreviate.String.ToList(packet, "$"); if (DelimitedData == null) { return(Rates); } for (int i = 0; i < DelimitedData.Length; i++) { Rate Rate = this.ToRateOnConnect(DelimitedData[i], ref origin); if (Rate != null) { Rates.Add(Rate); } } return(Rates); }
public void Update(TickTime tickTime) { Position += Velocity*tickTime.GameTimeDelta.TotalSeconds; }
public void Update(TickTime tickTime) { }
public void Update(TickTime delta) { }
private void Update(TickTime tickTime) { Parallel.ForEach(Factory.GameObjects, gameobject => gameobject.Value.Update(tickTime)); }
private void Update(TickTime tickTime) { Parallel.ForEach(Factory.GameObjects.Values, gameObject => { var hasPhysics = gameObject as IHasPhysics; if (hasPhysics != null) { hasPhysics.Body.Update(tickTime); } gameObject.Update(tickTime); }); /* foreach (var gameObject in Factory.GameObjects.Values) { var hasPhysics = gameObject as IHasPhysics; if (hasPhysics != null) { hasPhysics.Body.Update(tickTime); } gameObject.Update(tickTime); }*/ }
public void Update(TickTime tickTime) { this.Rotation = this.Rotation * (this.RotationalVelocity * tickTime.GameTimeDelta.TotalSeconds); this.Position = this.Position + (this.Velocity * tickTime.GameTimeDelta.TotalSeconds); }
public void Tick(TickTime tickTime) { var collision = (from o in _physicsObjects from b in _barriers let c = CalculateCollision(b, o.Body, TimeSpan.Zero, tickTime.TickElapsed, 0) where c != null orderby c.CollisionTime select c).FirstOrDefault(); if (collision != null) { UpdateKinematics(collision.CollisionTime); collision.Barrier.ApplyCollision(_eventTriggerer, collision.Body); Tick(new TickTime(tickTime.TickElapsed - collision.CollisionTime, tickTime.TotalElapsed)); return; } UpdateKinematics(tickTime.TickElapsed); _eventTriggerer.Trigger(new Tick()); }
public ICollision CalculateCollision(GameObjectBase gameObject, TickTime tickTime) { if (gameObject.Body.Velocity == Vector2.Zero) return null; if (gameObject is GolfBall) return CalculateCollision((GolfBall) gameObject, tickTime); return null; }
public void Update(TickTime delta) { throw new NotImplementedException(); }
public void LoadEntries(string[] pairs, OHLC.Interval[] intervals) { if (pairs == null || intervals == null || pairs.Length <= 0 || intervals.Length <= 0) { return; } foreach (OHLC.Interval interval in intervals) { foreach (string pair in pairs) { string key = this.GetKey(pair, interval); var entries = Entries.Get(key); TickTime last = new TickTime(0); int minutes = (int)interval; if (entries != null) { if (entries.Last.AddMinutes(minutes) > TickTime.Now) { continue; } last = entries.Last; } else { entries = new ArchiveEntriesJson(); entries.PairName = pair; entries.Interval = interval; entries.Last = last; entries.Entries = new OHLCEntry[0]; } if (last > new TickTime(0).AddMinutes(minutes)) { last = last.AddMinutes(-minutes); } OHLC ohlc = null; try { ohlc = Manager.GetOHLC(pair, interval, last); } catch { continue; } if (ohlc == null) { continue; } var _old = entries.Entries.ToDistinctKeyDictionary(x => x.Time, x => x); var _new = ohlc.Entries.ToDistinctKeyDictionary(x => x.Time, x => x); _old.AddOrUpdate(_new); List <OHLCEntry> list = _old.Values.ToList(); if (list == null || list.Count <= 0) { continue; } entries.Entries = list.ToArray(); entries.Last = list.Last().Time; Entries.Set(key, entries, true); } } }