/// <summary> /// Initializes a new instance of the <see cref="Mt4AccountAllOf" /> class. /// </summary> /// <param name="reality">reality.</param> /// <param name="login">Corseponding Account.</param> /// <param name="currency">currency.</param> /// <param name="leverage">Leverage multiplier.</param> public Mt4AccountAllOf(Reality reality = default(Reality), int login = default(int), string currency = default(string), int leverage = default(int)) { this.Reality = reality; this.Login = login; this.Currency = currency; this.Leverage = leverage; }
/// <summary> /// Initializes a new instance of the <see cref="InlineObject3" /> class. /// </summary> /// <param name="login">Corseponding Account (required).</param> /// <param name="reality">reality (required).</param> /// <param name="timeFrom">Milliseconds since unix epoch (required).</param> /// <param name="timeTo">timeTo (required).</param> public InlineObject3(int login = default(int), Reality reality = default(Reality), decimal timeFrom = default(decimal), decimal timeTo = default(decimal)) { // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for InlineObject3 and cannot be null"); } else { this.Login = login; } this.Reality = reality; // to ensure "timeFrom" is required (not null) if (timeFrom == null) { throw new InvalidDataException("timeFrom is a required property for InlineObject3 and cannot be null"); } else { this.TimeFrom = timeFrom; } // to ensure "timeTo" is required (not null) if (timeTo == null) { throw new InvalidDataException("timeTo is a required property for InlineObject3 and cannot be null"); } else { this.TimeTo = timeTo; } }
public Spectre(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu) : base(owner, abilitySleeper, orbwalkSleeper, menu) { this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> > { { AbilityId.spectre_spectral_dagger, x => this.dagger = new NukeAbility(x) }, { AbilityId.spectre_reality, x => this.reality = new Reality(x) }, { AbilityId.spectre_haunt, x => this.haunt = new Haunt(x) }, { (AbilityId)7851, x => this.shadowStep = new TargetableAbility(x) }, { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) }, { AbilityId.item_diffusal_blade, x => this.diffusal = new DebuffAbility(x) }, { AbilityId.item_abyssal_blade, x => this.abyssal = new DisableAbility(x) }, { AbilityId.item_manta, x => this.manta = new BuffAbility(x) }, { AbilityId.item_spirit_vessel, x => this.vessel = new DebuffAbility(x) }, { AbilityId.item_urn_of_shadows, x => this.urn = new DebuffAbility(x) }, { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) }, { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) }, { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) }, { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) }, { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) }, }; this.MoveComboAbilities.Add(AbilityId.spectre_spectral_dagger, x => this.daggerMove = new DaggerMove(x)); }
/// <summary> /// Initializes a new instance of the <see cref="InlineObject1" /> class. /// </summary> /// <param name="login">Corseponding Account.</param> /// <param name="reality">reality.</param> /// <param name="id">Position id..</param> /// <param name="takeProfit">takeProfit.</param> /// <param name="stopLoss">stopLoss.</param> public InlineObject1(int login = default(int), Reality reality = default(Reality), decimal id = default(decimal), decimal takeProfit = default(decimal), decimal stopLoss = default(decimal)) { this.Login = login; this.Reality = reality; this.Id = id; this.TakeProfit = takeProfit; this.StopLoss = stopLoss; }
public ActionResult Post([FromBody] Reality reality) { if (ModelState.IsValid) { this._context.Reality.Add(reality); this._context.SaveChanges(); return(Created($"api/peliculas/{reality.Reality_Id}", reality)); } // System.Console.WriteLine("11"); return(BadRequest()); }
public GameState(GameMode mode) { reality = new Reality(); if (mode == GameMode.New) { reality.Day = 1; reality.Season = Season.spring; reality.Hour = 7; reality.Minute = 0; } }
protected override async Task KillStealAsync(CancellationToken token) { if (Game.IsPaused || !this.Owner.IsAlive || !AbilityExtensions.CanBeCasted(this.SpectralDagger)) { await Task.Delay(125, token); return; } var killstealTarget = EntityManager <Hero> .Entities.FirstOrDefault( x => x.IsAlive && x.Team != this.Owner.Team && AbilityExtensions.CanBeCasted(this.SpectralDagger) && AbilityExtensions.CanHit(this.SpectralDagger, x) && !x.IsIllusion && x.Health < SpectralDaggerDamage(this.SpectralDagger.Level - 1, x)); var hauntIllusions = EntityManager <Unit> .Entities.Where(x => x.Name == this.Owner.Name && x.IsAlive && x.IsIllusion && !x.IsInvulnerable() && x.IsAlly(this.Owner) && x.HasModifier("modifier_spectre_haunt")).ToList(); if (killstealTarget != null) { if (hauntIllusions.Count != 0) { if (Reality.UseAbility(killstealTarget.NetworkPosition)) { var castDelay = AbilityExtensions.GetCastDelay(this.Reality, this.Owner, killstealTarget); await this.AwaitKillstealDelay((int)castDelay + 20, token); } } else if (AbilityExtensions.CanBeCasted(this.Haunt) && KillstealWithUlti && this.Owner.Distance2D(killstealTarget) > this.SpectralDagger.CastRange) { if (this.Haunt.UseAbility()) { var castDelay = AbilityExtensions.GetCastDelay(this.Haunt, this.Owner, killstealTarget); await this.AwaitKillstealDelay((int)castDelay + 20, token); this.Reality.UseAbility(killstealTarget.NetworkPosition); } } if (killstealTarget.Distance2D(this.Owner) <= this.SpectralDagger.CastRange) { if (this.SpectralDagger.UseAbility(killstealTarget)) { var castDelay = AbilityExtensions.GetCastDelay(this.SpectralDagger, this.Owner, killstealTarget); await this.AwaitKillstealDelay((int)castDelay, token); } } } await Task.Delay(125, token); }
void OnTriggerStay2D(Collider2D obj) { switch (obj.tag) { case "RED_X": reality = Reality.RED_X; break; case "YELLOW_Y": reality = Reality.YELLOW_Y; break; case "BLUE_Z": reality = Reality.BLUE_Z; break; } }
/// <summary> /// Initializes a new instance of the <see cref="InlineObject2" /> class. /// </summary> /// <param name="login">Corseponding Account (required).</param> /// <param name="reality">reality (required).</param> public InlineObject2(int login = default(int), Reality reality = default(Reality)) { // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for InlineObject2 and cannot be null"); } else { this.Login = login; } this.Reality = reality; }
/// <summary> /// Initializes a new instance of the <see cref="OpenMarketOrderModel" /> class. /// </summary> /// <param name="reality">reality (required).</param> /// <param name="login">Corseponding Account (required).</param> /// <param name="symbol">symbol (required).</param> /// <param name="side">side (required).</param> /// <param name="volume">volume (required).</param> /// <param name="isFIFO">FIFO requests closes opposite positions before opening new one. NonFIFO order will open new position regardles if client owns opposite position. (required).</param> /// <param name="takeProfit">takeProfit.</param> /// <param name="stopLoss">stopLoss.</param> /// <param name="requestId">Client defined requestId. Server wiil populate this id in response and trade events..</param> public OpenMarketOrderModel(Reality reality = default(Reality), int login = default(int), string symbol = default(string), Side side = default(Side), double volume = default(double), bool isFIFO = default(bool), double takeProfit = default(double), double stopLoss = default(double), string requestId = default(string)) { this.Reality = reality; // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for OpenMarketOrderModel and cannot be null"); } else { this.Login = login; } // to ensure "symbol" is required (not null) if (symbol == null) { throw new InvalidDataException("symbol is a required property for OpenMarketOrderModel and cannot be null"); } else { this.Symbol = symbol; } this.Side = side; // to ensure "volume" is required (not null) if (volume == null) { throw new InvalidDataException("volume is a required property for OpenMarketOrderModel and cannot be null"); } else { this.Volume = volume; } // to ensure "isFIFO" is required (not null) if (isFIFO == null) { throw new InvalidDataException("isFIFO is a required property for OpenMarketOrderModel and cannot be null"); } else { this.IsFIFO = isFIFO; } this.TakeProfit = takeProfit; this.StopLoss = stopLoss; this.RequestId = requestId; }
public ActionResult Put(int id, [FromBody] Reality reality) { var target = this._context.Reality.FirstOrDefault(p => p.Reality_Id == id); if (target == null) { return(NotFound()); } else if (!ModelState.IsValid) { return(BadRequest()); } else { this._context.Entry(target).CurrentValues.SetValues(reality); this._context.SaveChanges(); return(Ok()); } }
/// <summary> /// Initializes a new instance of the <see cref="PendingOrder" /> class. /// </summary> /// <param name="id">Id of this position. (required).</param> /// <param name="symbol">Instrument symbol (ticker) (required).</param> /// <param name="reality">reality (required).</param> /// <param name="login">Corseponding Account (required).</param> /// <param name="side">side (required).</param> /// <param name="volume">volume (required).</param> /// <param name="takeProfit">takeProfit.</param> /// <param name="stopLoss">stopLoss.</param> /// <param name="comment">comment.</param> /// <param name="closeTime">Epoch milisesonds. This field indicates that position is already closed..</param> /// <param name="activationPrice">price at which this order executes at market (required).</param> /// <param name="direction">direction (required).</param> /// <param name="createTime">Unix time in miliseconds. (required).</param> /// <param name="expiryTime">Miliseconds since eopch, when this order ewill be automaticly removed..</param> public PendingOrder(decimal id = default(decimal), string symbol = default(string), Reality reality = default(Reality), int login = default(int), Side side = default(Side), double volume = default(double), double takeProfit = default(double), double stopLoss = default(double), string comment = default(string), decimal closeTime = default(decimal), decimal activationPrice = default(decimal), Direction direction = default(Direction), decimal createTime = default(decimal), decimal expiryTime = default(decimal)) { // to ensure "id" is required (not null) if (id == null) { throw new InvalidDataException("id is a required property for PendingOrder and cannot be null"); } else { this.Id = id; } // to ensure "symbol" is required (not null) if (symbol == null) { throw new InvalidDataException("symbol is a required property for PendingOrder and cannot be null"); } else { this.Symbol = symbol; } this.Reality = reality; // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for PendingOrder and cannot be null"); } else { this.Login = login; } this.Side = side; // to ensure "volume" is required (not null) if (volume == null) { throw new InvalidDataException("volume is a required property for PendingOrder and cannot be null"); } else { this.Volume = volume; } // to ensure "activationPrice" is required (not null) if (activationPrice == null) { throw new InvalidDataException("activationPrice is a required property for PendingOrder and cannot be null"); } else { this.ActivationPrice = activationPrice; } this.Direction = direction; // to ensure "createTime" is required (not null) if (createTime == null) { throw new InvalidDataException("createTime is a required property for PendingOrder and cannot be null"); } else { this.CreateTime = createTime; } this.TakeProfit = takeProfit; this.StopLoss = stopLoss; this.Comment = comment; this.CloseTime = closeTime; this.ExpiryTime = expiryTime; }
/// <summary> /// Initializes a new instance of the <see cref="MarketOrder" /> class. /// </summary> /// <param name="id">Id of this position. (required).</param> /// <param name="symbol">Instrument symbol (ticker) (required).</param> /// <param name="reality">reality (required).</param> /// <param name="login">Corseponding Account (required).</param> /// <param name="side">side (required).</param> /// <param name="volume">volume (required).</param> /// <param name="takeProfit">takeProfit.</param> /// <param name="stopLoss">stopLoss.</param> /// <param name="comment">comment.</param> /// <param name="closeTime">Epoch milisesonds. This field indicates that position is already closed..</param> /// <param name="openTime">unixtimestamp in miliseconds (required).</param> /// <param name="openPrice">openPrice (required).</param> /// <param name="margin">Balance blocked for this position. (required).</param> /// <param name="profit">current profit/loss from this position. (required).</param> /// <param name="swaps">Overnight maintence of this position. (required).</param> /// <param name="openConversionRate">Convertion rate from position currency to account currency (required).</param> /// <param name="closeConversionRate">closeConversionRate.</param> public MarketOrder(decimal id = default(decimal), string symbol = default(string), Reality reality = default(Reality), int login = default(int), Side side = default(Side), double volume = default(double), double takeProfit = default(double), double stopLoss = default(double), string comment = default(string), decimal closeTime = default(decimal), decimal openTime = default(decimal), decimal openPrice = default(decimal), double margin = default(double), double profit = default(double), double swaps = default(double), double openConversionRate = default(double), double closeConversionRate = default(double)) { // to ensure "id" is required (not null) if (id == null) { throw new InvalidDataException("id is a required property for MarketOrder and cannot be null"); } else { this.Id = id; } // to ensure "symbol" is required (not null) if (symbol == null) { throw new InvalidDataException("symbol is a required property for MarketOrder and cannot be null"); } else { this.Symbol = symbol; } this.Reality = reality; // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for MarketOrder and cannot be null"); } else { this.Login = login; } this.Side = side; // to ensure "volume" is required (not null) if (volume == null) { throw new InvalidDataException("volume is a required property for MarketOrder and cannot be null"); } else { this.Volume = volume; } // to ensure "openTime" is required (not null) if (openTime == null) { throw new InvalidDataException("openTime is a required property for MarketOrder and cannot be null"); } else { this.OpenTime = openTime; } // to ensure "openPrice" is required (not null) if (openPrice == null) { throw new InvalidDataException("openPrice is a required property for MarketOrder and cannot be null"); } else { this.OpenPrice = openPrice; } // to ensure "margin" is required (not null) if (margin == null) { throw new InvalidDataException("margin is a required property for MarketOrder and cannot be null"); } else { this.Margin = margin; } // to ensure "profit" is required (not null) if (profit == null) { throw new InvalidDataException("profit is a required property for MarketOrder and cannot be null"); } else { this.Profit = profit; } // to ensure "swaps" is required (not null) if (swaps == null) { throw new InvalidDataException("swaps is a required property for MarketOrder and cannot be null"); } else { this.Swaps = swaps; } // to ensure "openConversionRate" is required (not null) if (openConversionRate == null) { throw new InvalidDataException("openConversionRate is a required property for MarketOrder and cannot be null"); } else { this.OpenConversionRate = openConversionRate; } this.TakeProfit = takeProfit; this.StopLoss = stopLoss; this.Comment = comment; this.CloseTime = closeTime; this.CloseConversionRate = closeConversionRate; }
/// <summary> /// Get status of an account This Request is limmited. It can not be called more than once per 5 minutes. Client shall store and track account status returned with trade execution report. /// </summary> /// <exception cref="SimpleFx.Client.Generated.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="reality"></param> /// <param name="account"></param> /// <returns>Task of ApiResponse (InlineResponse2003)</returns> public async System.Threading.Tasks.Task <SimpleFx.Client.Generated.Client.ApiResponse <InlineResponse2003> > V3AccountsGetAccountAsyncWithHttpInfo(Reality reality, int account) { // verify the required parameter 'reality' is set if (reality == null) { throw new SimpleFx.Client.Generated.Client.ApiException(400, "Missing required parameter 'reality' when calling AccountsApi->V3AccountsGetAccount"); } // verify the required parameter 'account' is set if (account == null) { throw new SimpleFx.Client.Generated.Client.ApiException(400, "Missing required parameter 'account' when calling AccountsApi->V3AccountsGetAccount"); } SimpleFx.Client.Generated.Client.RequestOptions localVarRequestOptions = new SimpleFx.Client.Generated.Client.RequestOptions(); String[] _contentTypes = new String[] { }; // to determine the Accept header String[] _accepts = new String[] { "application/json" }; foreach (var _contentType in _contentTypes) { localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType); } foreach (var _accept in _accepts) { localVarRequestOptions.HeaderParameters.Add("Accept", _accept); } if (reality != null) { localVarRequestOptions.PathParameters.Add("reality", SimpleFx.Client.Generated.Client.ClientUtils.ParameterToString(reality)); // path parameter } if (account != null) { localVarRequestOptions.PathParameters.Add("account", SimpleFx.Client.Generated.Client.ClientUtils.ParameterToString(account)); // path parameter } // authentication (bearerAuth) required // http basic authentication required if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password)) { localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + SimpleFx.Client.Generated.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password)); } // make the HTTP request var localVarResponse = await this.AsynchronousClient.GetAsync <InlineResponse2003>("/api/v3/accounts/{reality}/{account}", localVarRequestOptions, this.Configuration); if (this.ExceptionFactory != null) { Exception _exception = this.ExceptionFactory("V3AccountsGetAccount", localVarResponse); if (_exception != null) { throw _exception; } } return(localVarResponse); }
/// <summary> /// Get status of an account This Request is limmited. It can not be called more than once per 5 minutes. Client shall store and track account status returned with trade execution report. /// </summary> /// <exception cref="SimpleFx.Client.Generated.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="reality"></param> /// <param name="account"></param> /// <returns>Task of InlineResponse2003</returns> public async System.Threading.Tasks.Task <InlineResponse2003> V3AccountsGetAccountAsync(Reality reality, int account) { SimpleFx.Client.Generated.Client.ApiResponse <InlineResponse2003> localVarResponse = await V3AccountsGetAccountAsyncWithHttpInfo(reality, account); return(localVarResponse.Data); }
/// <summary> /// Get status of an account This Request is limmited. It can not be called more than once per 5 minutes. Client shall store and track account status returned with trade execution report. /// </summary> /// <exception cref="SimpleFx.Client.Generated.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="reality"></param> /// <param name="account"></param> /// <returns>InlineResponse2003</returns> public InlineResponse2003 V3AccountsGetAccount(Reality reality, int account) { SimpleFx.Client.Generated.Client.ApiResponse <InlineResponse2003> localVarResponse = V3AccountsGetAccountWithHttpInfo(reality, account); return(localVarResponse.Data); }
/// <summary> /// Initializes a new instance of the <see cref="OrderBase" /> class. /// </summary> /// <param name="id">Id of this position. (required).</param> /// <param name="symbol">Instrument symbol (ticker) (required).</param> /// <param name="reality">reality (required).</param> /// <param name="login">Corseponding Account (required).</param> /// <param name="side">side (required).</param> /// <param name="volume">volume (required).</param> /// <param name="takeProfit">takeProfit.</param> /// <param name="stopLoss">stopLoss.</param> /// <param name="comment">comment.</param> /// <param name="closeTime">Epoch milisesonds. This field indicates that position is already closed..</param> public OrderBase(decimal id = default(decimal), string symbol = default(string), Reality reality = default(Reality), int login = default(int), Side side = default(Side), double volume = default(double), double takeProfit = default(double), double stopLoss = default(double), string comment = default(string), decimal closeTime = default(decimal)) { // to ensure "id" is required (not null) if (id == null) { throw new InvalidDataException("id is a required property for OrderBase and cannot be null"); } else { this.Id = id; } // to ensure "symbol" is required (not null) if (symbol == null) { throw new InvalidDataException("symbol is a required property for OrderBase and cannot be null"); } else { this.Symbol = symbol; } this.Reality = reality; // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for OrderBase and cannot be null"); } else { this.Login = login; } this.Side = side; // to ensure "volume" is required (not null) if (volume == null) { throw new InvalidDataException("volume is a required property for OrderBase and cannot be null"); } else { this.Volume = volume; } this.TakeProfit = takeProfit; this.StopLoss = stopLoss; this.Comment = comment; this.CloseTime = closeTime; }
/// <summary> /// Initializes a new instance of the <see cref="Mt4Account" /> class. /// </summary> /// <param name="balance">Current account balance. (required).</param> /// <param name="equity">Balance + profit of opened positions. Depends on current market price. (required).</param> /// <param name="margin">Amount blocked for opened positions. (required).</param> /// <param name="freeMargin">Equity - margin, amount free for opening new positions. (required).</param> /// <param name="marginLevel">Margin level in percentage. Margin level of 100 mean all positions are covered, but there is no free margin for new positions. (required).</param> /// <param name="reality">reality (required).</param> /// <param name="login">Corseponding Account (required).</param> /// <param name="currency">currency.</param> /// <param name="leverage">Leverage multiplier (required).</param> public Mt4Account(decimal balance = default(decimal), decimal equity = default(decimal), decimal margin = default(decimal), decimal freeMargin = default(decimal), double marginLevel = default(double), Reality reality = default(Reality), int login = default(int), string currency = default(string), int leverage = default(int)) { // to ensure "balance" is required (not null) if (balance == null) { throw new InvalidDataException("balance is a required property for Mt4Account and cannot be null"); } else { this.Balance = balance; } // to ensure "equity" is required (not null) if (equity == null) { throw new InvalidDataException("equity is a required property for Mt4Account and cannot be null"); } else { this.Equity = equity; } // to ensure "margin" is required (not null) if (margin == null) { throw new InvalidDataException("margin is a required property for Mt4Account and cannot be null"); } else { this.Margin = margin; } // to ensure "freeMargin" is required (not null) if (freeMargin == null) { throw new InvalidDataException("freeMargin is a required property for Mt4Account and cannot be null"); } else { this.FreeMargin = freeMargin; } // to ensure "marginLevel" is required (not null) if (marginLevel == null) { throw new InvalidDataException("marginLevel is a required property for Mt4Account and cannot be null"); } else { this.MarginLevel = marginLevel; } this.Reality = reality; // to ensure "login" is required (not null) if (login == null) { throw new InvalidDataException("login is a required property for Mt4Account and cannot be null"); } else { this.Login = login; } // to ensure "leverage" is required (not null) if (leverage == null) { throw new InvalidDataException("leverage is a required property for Mt4Account and cannot be null"); } else { this.Leverage = leverage; } this.Currency = currency; }
internal static void BroadcastMessage(Reality.Communication.ServerMessage serverMessage, bool p) { throw new NotImplementedException(); }