public IEnumerable <KeyValuePair <string, string> > get_Baggage(object activityInstance) { // Activity API signature: // public IEnumerable<KeyValuePair<string, string>> Baggage { get; } // invoker = (activityInstance) => ((Activity) activityInstance).Baggage; ValidateType(activityInstance); Func <object, IEnumerable <KeyValuePair <string, string> > > invoker = _cashedDelegates.get_Baggage; if (invoker == null) { ParameterExpression exprActivityInstance = Expression.Parameter(_activityType, "activityInstance"); var exprInvoker = Expression.Lambda <Func <object, IEnumerable <KeyValuePair <string, string> > > >( Expression.Property( Expression.Convert(exprActivityInstance, _activityType), "Baggage"), exprActivityInstance); invoker = exprInvoker.Compile(); invoker = Concurrent.TrySetOrGetValue(ref _cashedDelegates.get_Baggage, invoker); } IEnumerable <KeyValuePair <string, string> > result = invoker(activityInstance); return(result); }
public override void Call(RpcServerContext ctx) { if (RatePerSecond != null) { try { if (RatePerSecond != null) { RatePerSecond.Increment(); Concurrent.Increment(); } Method.Invoke(Service, new object[] { new RpcBatchServerContext(ctx) }); } catch (Exception ex) { ctx.ReturnError(RpcErrorCode.ServerError, ex); } finally { Concurrent.Decrement(); } } else { try { Method.Invoke(Service, new object[] { new RpcBatchServerContext(ctx) }); } catch (Exception ex) { ctx.ReturnError(RpcErrorCode.ServerError, ex); } } }
public string get_Name(object diagnosticListenerInstance) { Func <object, string> invokerDelegate = _cashedDelegates.get_Name; if (invokerDelegate == null) { try { // invokerDelegate = (diagnosticListenerInstance) => ((DiagnosticListener) diagnosticListenerInstance).Name; ParameterExpression exprDiagnosticListenerInstanceParam = Expression.Parameter(typeof(object), "diagnosticListenerInstance"); PropertyInfo propertyInfo = _thisInvoker._diagnosticListenerType.GetProperty("Name", BindingFlags.Instance | BindingFlags.Public); var exprInvoker = Expression.Lambda <Func <object, string> >( Expression.Property( Expression.Convert(exprDiagnosticListenerInstanceParam, _thisInvoker._diagnosticListenerType), propertyInfo), exprDiagnosticListenerInstanceParam); invokerDelegate = exprInvoker.Compile(); invokerDelegate = Concurrent.TrySetOrGetValue(ref _cashedDelegates.get_Name, invokerDelegate); } catch (Exception ex) { throw new DynamicInvocationException(typeof(DynamicInvoker_DiagnosticListener), $"Error while building the invocation delegate for the API \"{nameof(get_Name)}\".", ex); } } string result = invokerDelegate(diagnosticListenerInstance); return(result); }
public IObservable <object> get_AllListeners() { Func <IObservable <object> > invokerDelegate = _cashedDelegates.get_AllListeners; if (invokerDelegate == null) { try { // invokerDelegate = () => DiagnosticListener.AllListeners; PropertyInfo propertyInfo = _thisInvoker._diagnosticListenerType.GetProperty("AllListeners", BindingFlags.Static | BindingFlags.Public); var exprInvoker = Expression.Lambda <Func <IObservable <object> > >( Expression.Property( null, propertyInfo)); invokerDelegate = exprInvoker.Compile(); invokerDelegate = Concurrent.TrySetOrGetValue(ref _cashedDelegates.get_AllListeners, invokerDelegate); } catch (Exception ex) { throw new DynamicInvocationException(typeof(DynamicInvoker_DiagnosticListener), $"Error while building the invocation delegate for the API \"{nameof(get_AllListeners)}\".", ex); } } IObservable <object> result = invokerDelegate(); return(result); }
public object Ctor(string diagnosticSourceName) { Func <string, object> invokerDelegate = _cashedDelegates.Ctor; if (invokerDelegate == null) { try { // invokerDelegate = (diagnosticSourceName) => new DiagnosticListener(diagnosticSourceName); ParameterExpression exprDiagnosticSourceNameParam = Expression.Parameter(typeof(string), "diagnosticSourceName"); ConstructorInfo ctorInfo = _thisInvoker._diagnosticListenerType.GetConstructor(new Type[] { typeof(string) }); var exprInvoker = Expression.Lambda <Func <string, object> >( Expression.New( ctorInfo, exprDiagnosticSourceNameParam), exprDiagnosticSourceNameParam); invokerDelegate = exprInvoker.Compile(); invokerDelegate = Concurrent.TrySetOrGetValue(ref _cashedDelegates.Ctor, invokerDelegate); } catch (Exception ex) { throw new DynamicInvocationException(typeof(DynamicInvoker_DiagnosticListener), $"Error while building the invocation delegate for the API \"{nameof(Ctor)}\".", ex); } } object result = invokerDelegate(diagnosticSourceName); return(result); }
private bool GeneratePaths(List <Concurrent <int, int, int> .CommandResult> i) { var sut = new Concurrent <int, int, int>(() => 1, 5); var correctState = new Concurrent <int, int, int> .CurrentState(true, 1); return(sut.HasValidPath(i, (r, s) => correctState, correctState).Valid); }
public string GetBaggageItem(object activityInstance, string key) { // Activity API signature: // public string GetBaggageItem(string key) // invoker = (activityInstance, key) => ((Activity) activityInstance).GetBaggageItem(key); ValidateType(activityInstance); Func <object, string, string> invoker = _cashedDelegates.GetBaggageItem; if (invoker == null) { ParameterExpression exprActivityInstance = Expression.Parameter(_activityType, "activityInstance"); ParameterExpression exprKey = Expression.Parameter(typeof(string), "key"); var exprInvoker = Expression.Lambda <Func <object, string, string> >( Expression.Call( Expression.Convert(exprActivityInstance, _activityType), "GetBaggageItem", new[] { typeof(string) }, exprKey), exprActivityInstance, exprKey); invoker = exprInvoker.Compile(); invoker = Concurrent.TrySetOrGetValue(ref _cashedDelegates.GetBaggageItem, invoker); } string result = invoker(activityInstance, key); return(result); }
//public object StartNewActivity(string operationName) //{ // invoker = (operationName) => // { // Activity activity = new Activity(operationName); // ActivityStub activityStub = ActivityStub.Wrap(activity); // PreStartInitializationCallback(activityStub); // autoInstrumentationDiagnosticSource.StartActivity(actvitiy, activity); // } //} public void AddBaggage(object activityInstance, string key, string value) { // Activity API signature: // public Activity AddBaggage(string key, string value) // invoker = (activityInstance, key, value) => ((Activity) activityInstance).AddBaggage(key, value); ValidateType(activityInstance); Action <object, string, string> invoker = _cashedDelegates.AddBagage; if (invoker == null) { ParameterExpression exprActivityInstance = Expression.Parameter(_activityType, "activityInstance"); ParameterExpression exprKey = Expression.Parameter(typeof(string), "key"); ParameterExpression exprValue = Expression.Parameter(typeof(string), "value"); var exprInvoker = Expression.Lambda <Action <object, string, string> >( Expression.Call( Expression.Convert(exprActivityInstance, _activityType), "AddBaggage", new[] { typeof(string), typeof(string) }, exprKey, exprValue), exprActivityInstance, exprKey, exprValue); invoker = exprInvoker.Compile(); invoker = Concurrent.TrySetOrGetValue(ref _cashedDelegates.AddBagage, invoker); } invoker(activityInstance, key, value); }
public override void Dispose() { if (_ConcurrentNode != null) { _ConcurrentNode.Dispose(); _ConcurrentNode = null; } }
static int Main(string[] args) { if (args.Length == 0) { Console.WriteLine("[FATAL] Missing required command-line argument: 'limit'"); return(1); } if (!int.TryParse(args[0], out int limit)) { Console.WriteLine("[FATAL] Cannot parse '{0}' as integer", args[0]); return(2); } if (limit < 0) { Console.WriteLine("[FATAL] Expected positive value for argument '{0}', got: {1}", nameof(limit), limit); return(3); } var log = Concurrent <string> .List(); var runners = ( new SieveRunner <EulerSieve>("Euler"), new SieveRunner <EratosthenesSieve>("Eratosthenes") ); var current = new ConcurrentScalar <string, DateTime>(); current.updated += (prev, current) => { if (prev.data != default) { log.Add($"Iesire temporara fir: {prev.data}@{asTimestamp(current.extra)}"); } }; foreach (var runner in runners.iterate <AbstractSieveRunner>()) { runner.begun += (DateTime time, int limit) => { log.Add($"Startfir: {runner.name}@{asTimestamp(time)} Numar natural dat = {limit}"); }; runner.waiting += (DateTime time) => { current[runner.name] = time; }; runner.done += (DateTime time, int result) => { log.Add($"End fir: {runner.name}@{asTimestamp(time)} Numar prim = {result}"); }; runner.execute(limit); } runners.complete <AbstractSieveRunner>(); log.ForEach(Console.WriteLine); return(0); }
public void TestParrel_concurrent_locked() { var concurrentTape = new Concurrent <ITape, int, int>(() => new TapeConcurrentLocking(), 2); concurrentTape .ToProperty(Validate, new Collection <ConcurrentCommand.Command <ITape, int> > { new GetTicketCommand(), new ReadCommand() }, 0) .VerboseCheckThrowOnFailure(); }
/// <summary> /// Get a version of this object suitable for use in a ParallelFor job /// </summary> /// /// <returns> /// A version of this object suitable for use in a ParallelFor job /// </returns> public Concurrent ToConcurrent() { #if ENABLE_UNITY_COLLECTIONS_CHECKS Concurrent concurrent = new Concurrent(m_Buffer, m_Safety); AtomicSafetyHandle.UseSecondaryVersion(ref concurrent.m_Safety); #else Concurrent concurrent = new Concurrent(m_Buffer); #endif return(concurrent); }
public static Concurrent ToConcurrent(this RaceEntity entity) { Concurrent concurrent = new Concurrent(); concurrent.Nom = entity.Concurrent; concurrent.ConcurrentId = Convert.ToInt32(entity.PartitionKey); concurrent.SC = entity.SC; return(concurrent); }
public GameScene() { Concurrent cameraPan; Sequence panZoomSequence = new Sequence(); //m_backpackers[2].Transform.PosX += 100; Party.Initialise(); m_introSequence = new Sequence(); m_introSequence.AddAction(Party.GetMovingOutAnimation()); #region Camera Intro Pan Forward T = 5s m_cameraIntroForwardPan = new MoveToStaticAction(Globals.TheGame, World.cam_Main.Transform, Vector2.Zero, 1); m_cameraIntroForwardPan.Timer.Interval = 5.0f; m_cameraIntroForwardPan.Interpolator = new PSmoothstepInterpolation(); ScaleToAction zoom1 = new ScaleToAction(Globals.TheGame, World.cam_Main.Transform, new Vector2(IntroZoom, IntroZoom), 1); zoom1.Timer.Interval = 3.0f; zoom1.StartScale = new Vector2(WaveZoom, WaveZoom); zoom1.Interpolator = new PSmoothstepInterpolation(); panZoomSequence.AddAction(zoom1); panZoomSequence.AddAction(new DelayAction(Globals.TheGame, 1.0f)); ScaleToAction zoom2 = new ScaleToAction(Globals.TheGame, World.cam_Main.Transform, new Vector2(IntroOnExitZoom, IntroOnExitZoom), 1); zoom2.Timer.Interval = 1.0f; zoom2.StartScale = zoom1.Target; zoom2.Interpolator = new PSmoothstepInterpolation(); panZoomSequence.AddAction(zoom2); cameraPan = new Concurrent(new PastaGameLibrary.Action[] { m_cameraIntroForwardPan, panZoomSequence }); m_introSequence.AddAction(cameraPan); m_introSequence.AddAction(new DelayAction(Globals.TheGame, 0.5f)); #endregion #region Camera pan backwards T = 3s m_cameraIntroBackwardsPan = new MoveToStaticAction(Globals.TheGame, World.cam_Main.Transform, Vector2.Zero, 1); m_cameraIntroBackwardsPan.Timer.Interval = 3.0f; m_cameraIntroBackwardsPan.Interpolator = new PSmoothstepInterpolation(); zoom1 = new ScaleToAction(Globals.TheGame, World.cam_Main.Transform, new Vector2(1.0f, 1.0f), 1); zoom1.Timer.Interval = 1.0f; zoom1.StartScale = zoom2.Target; zoom1.Interpolator = new PSmoothstepInterpolation(); cameraPan = new Concurrent(new PastaGameLibrary.Action[] { m_cameraIntroBackwardsPan, zoom1 }); m_introSequence.AddAction(cameraPan); #endregion }
public override int GetHashCode() { unchecked { var hashCode = Server.GetHashCode(); hashCode = (hashCode * 397) ^ Concurrent.GetHashCode(); hashCode = (hashCode * 397) ^ CpuGroups.GetHashCode(); hashCode = (hashCode * 397) ^ Force.GetHashCode(); hashCode = (hashCode * 397) ^ AllowVeryLargeObjects.GetHashCode(); return(hashCode); } }
private static PackagedAssemblyLookup GetPackagedAssemblies() { PackagedAssemblyLookup packagedAssemblies = s_packagedAssemblies; if (packagedAssemblies == null) { packagedAssemblies = ReadPackagedAssembliesFromDisk(); packagedAssemblies = Concurrent.TrySetOrGetValue(ref s_packagedAssemblies, packagedAssemblies); } return(packagedAssemblies); }
protected R AddInDatabases <R, T>(Func <DBItemContext, IEnumerable <Row> > AddRow) where T : DBItemWorkerBaseResultItem, new() where R : DBItemWorkerBaseResult, new() { var result = new R { Session = DBItems[0].Session }; int c = 0; int l = DBItems.Length; var progress = new Log(); var concurrent = new Concurrent(); concurrent.ForEach(DBItems, dbitem => { var dbic = new DBItemContext(dbitem); try { dbic.Init(loginLock); var rows = AddRow(dbic); dbic.Session.Save(); lock (result.SyncRoot) { foreach (var row in rows) { result.Items.Add(new T() { Session = dbic.DBItem.Session, DBItem = dbic.DBItem, Row = row }); } } } catch (Exception ex) { lock (result.SyncRoot) { result.Items.Add(new T() { Session = dbic.DBItem.Session, DBItem = dbic.DBItem, Exception = ex }); } } finally { dbic.Dispose(); } progress.Write(new Percent(c++, l)); }); return(result); }
public static CompetitorEntity ToCompetitorEntity(this Concurrent concurrent) { CompetitorEntity competitorEntity = new CompetitorEntity(); competitorEntity.Victoires = concurrent.Victoires; competitorEntity.SC = concurrent.SC; competitorEntity.Nom = concurrent.Nom; competitorEntity.Entraineur = concurrent.Entraineur.Nom; competitorEntity.Defaites = concurrent.Defaites; return(competitorEntity); }
public void DegenerateCaseComplates() { const int generationSize = 17; var gen = AlwaysTrueCommandResult(generationSize).Sample(1, 1).First(); gen.Add(new Concurrent <bool, bool, bool> .CommandResult(new Concurrent <bool, bool, bool> .ClientCommand(2, new BoolIdentity()), false)); var sut = new Concurrent <bool, bool, bool>(() => true, 2); var result = sut.HasValidPath(gen, MatchTheResult, new Concurrent <bool, bool, bool> .CurrentState(true, true)); Assert.False(result.Valid); }
private Concurrent <ITape, int, int> .CurrentState Validate(Concurrent <ITape, int, int> .CommandResult cmdResult, Concurrent <ITape, int, int> .CurrentState state) { var model = state.Model; var newModel = cmdResult.ClientCommand.Command switch { GetTicketCommand _ => model + 1, ReadCommand _ => model, _ => throw new Exception("Bad command processed") }; return(new Concurrent <ITape, int, int> .CurrentState(cmdResult.Result == newModel, newModel)); }
public void TestParrel_concurrent_buggy_std() { var t = Configuration.QuickThrowOnFailure; t.Replay = FsCheck.Random.StdGen.NewStdGen(1867961639, 296867728); var concurrentTape = new Concurrent <ITape, int, int>(() => new TapeConcurrentBug(), 2); concurrentTape .ToProperty(Validate, new Collection <ConcurrentCommand.Command <ITape, int> > { new GetTicketCommand(), new ReadCommand() }, 0) .Check(t); }
public bool IsEnabled(object diagnosticSourceInstance, string eventName, object arg1, object arg2) { Func <object, string, object, object, bool> invokerDelegate = _cashedDelegates.IsEnabled; if (invokerDelegate == null) { try { // invokerDelegate = (diagnosticSourceInstance, eventName, arg1, arg2) => // ((Diagnosticource) diagnosticSourceInstance).Subscribe(eventName, arg1, arg2); ParameterExpression exprDiagnosticSourceInstanceParam = Expression.Parameter(typeof(object), "diagnosticSourceInstance"); ParameterExpression exprEventNameParam = Expression.Parameter(typeof(string), "eventName"); ParameterExpression exprArg1Param = Expression.Parameter(typeof(object), "arg1"); ParameterExpression exprArg2Param = Expression.Parameter(typeof(object), "arg2"); MethodInfo methodInfo = _thisInvoker._diagnosticSourceType.GetMethod("IsEnabled", BindingFlags.Instance | BindingFlags.Public, binder: null, new Type[] { typeof(string), typeof(object), typeof(object) }, modifiers: null); var exprInvoker = Expression.Lambda <Func <object, string, object, object, bool> >( Expression.Call( Expression.Convert(exprDiagnosticSourceInstanceParam, _thisInvoker._diagnosticSourceType), methodInfo, exprEventNameParam, exprArg1Param, exprArg2Param), exprDiagnosticSourceInstanceParam, exprEventNameParam, exprArg1Param, exprArg2Param); invokerDelegate = exprInvoker.Compile(); invokerDelegate = Concurrent.TrySetOrGetValue(ref _cashedDelegates.IsEnabled, invokerDelegate); } catch (Exception ex) { throw new DynamicInvocationException(typeof(DynamicInvoker_DiagnosticSource), $"Error while building the invocation delegate for the API \"{nameof(IsEnabled)}\".", ex); } } bool result = invokerDelegate(diagnosticSourceInstance, eventName, arg1, arg2); return(result); }
public IDisposable Subscribe(object diagnosticListenerInstance, IObserver <KeyValuePair <string, object> > eventObserver, Func <string, object, object, bool> isEventEnabledFilter) { Func <object, IObserver <KeyValuePair <string, object> >, Func <string, object, object, bool>, IDisposable> invokerDelegate = _cashedDelegates.Subscribe; if (invokerDelegate == null) { try { // invokerDelegate = (diagnosticListenerInstance, eventObserver, isEventEnabledFilter) => // ((DiagnosticListener) diagnosticListenerInstance).Subscribe(eventObserver, isEventEnabledFilter); ParameterExpression exprDiagnosticListenerInstanceParam = Expression.Parameter(typeof(object), "diagnosticListenerInstance"); ParameterExpression exprEventObserverParam = Expression.Parameter(typeof(IObserver <KeyValuePair <string, object> >), "eventObserver"); ParameterExpression exprIsEventEnabledFilterParam = Expression.Parameter(typeof(Func <string, object, object, bool>), "isEventEnabledFilter"); MethodInfo methodInfo = _thisInvoker._diagnosticListenerType.GetMethod("Subscribe", BindingFlags.Instance | BindingFlags.Public, binder: null, new Type[] { typeof(IObserver <KeyValuePair <string, object> >), typeof(Func <string, object, object, bool>) }, modifiers: null); var exprInvoker = Expression.Lambda <Func <object, IObserver <KeyValuePair <string, object> >, Func <string, object, object, bool>, IDisposable> >( Expression.Call( Expression.Convert(exprDiagnosticListenerInstanceParam, _thisInvoker._diagnosticListenerType), methodInfo, exprEventObserverParam, exprIsEventEnabledFilterParam), exprDiagnosticListenerInstanceParam, exprEventObserverParam, exprIsEventEnabledFilterParam); invokerDelegate = exprInvoker.Compile(); invokerDelegate = Concurrent.TrySetOrGetValue(ref _cashedDelegates.Subscribe, invokerDelegate); } catch (Exception ex) { throw new DynamicInvocationException(typeof(DynamicInvoker_DiagnosticListener), $"Error while building the invocation delegate for the API \"{nameof(Subscribe)}\".", ex); } } IDisposable result = invokerDelegate(diagnosticListenerInstance, eventObserver, isEventEnabledFilter); return(result); }
public TestingSession(string assemblyName, string assemblyPath, string methodDeclaringClass, string methodName, int schedulingSeed, int timeoutMs = Constants.SessionTimeoutMs, int maxDecisions = Constants.SessionMaxDecisions) { this.Meta = new SessionInfo(IdGen.Generate().ToString(), assemblyName, assemblyPath, methodDeclaringClass, methodName, schedulingSeed, timeoutMs, maxDecisions); this.records = new List <SessionRecord>(); // initialize run-time objects // this._onComplete = record => { }; // empty onComplete handler this.stateLock = new object(); this.traceFile = File.AppendText(this.traceFilePath); this.logFile = File.AppendText(this.logFilePath); this.IsFinished = new Concurrent <bool>(); this.Reset(); }
public DetailCourseViewModel GetDetailCourseViewModel(int idCourse) { DetailCourseViewModel vm = new DetailCourseViewModel(); List <RaceEntity> entities = _unitOfWork.RaceRepository.GetRaceDetail(idCourse); vm.Course = entities.First().ToCourse(); foreach (RaceEntity entity in entities) { Concurrent concurrent = entity.ToConcurrent(); vm.Concurrents.Add(concurrent); } return(vm); }
/// <summary>Adds an item to the collection.</summary> /// <param name="item">Item to be added.</param> public void Add(T item) { GrowingCollectionSegment <T> currHead = Volatile.Read(ref _dataHead); bool added = currHead.TryAdd(item); while (!added) { var newHead = new GrowingCollectionSegment <T>(currHead); Concurrent.CompareExchangeResult(ref _dataHead, newHead, currHead); GrowingCollectionSegment <T> updatedHead = Interlocked.CompareExchange(ref _dataHead, newHead, currHead); added = updatedHead.TryAdd(item); } }
[Obsolete] public Concurrent ToConcurrent() { var concurrent = new Concurrent { m_StageCollection = m_StageCollection, m_Pipelines = m_Pipelines, m_StageList = m_StageList, m_SendStageNeedsUpdateWrite = m_SendStageNeedsUpdateRead.ToConcurrent(), sizePerConnection = sizePerConnection, sendBuffer = m_SendBuffer, sharedBuffer = m_SharedBuffer, m_timestamp = m_timestamp }; return(concurrent); }
public static Concurrent ToConcurrent(this CompetitorEntity entity) { Concurrent concurrent = new Concurrent(); concurrent.Nom = entity.Nom; concurrent.ConcurrentId = Convert.ToInt32(entity.PartitionKey); concurrent.Defaites = entity.Defaites; concurrent.Entraineur = new Entraineur() { Nom = entity.Entraineur }; concurrent.SC = entity.SC; concurrent.Victoires = entity.Victoires; return(concurrent); }
static void InitialiseMovingOutAnimation() { #region Backpacker 0 Sequence waveAnimation_0 = new Sequence(); MoveToStaticAction walkMove_0 = new MoveToStaticAction(Globals.TheGame, Backpackers[0].Transform, new Vector2(MeetingPoint, 0), 1); walkMove_0.Timer.Interval = 0.5f; SpriteSheetAnimation walkAnim_0 = new SpriteSheetAnimation(Backpackers[0].Sprite, 0, 1, 0.1f, 5); waveAnimation_0.AddAction(new Concurrent(new PastaGameLibrary.Action[] { walkMove_0, walkAnim_0 })); waveAnimation_0.AddAction(new SpriteSheetAnimation(Backpackers[0].Sprite, 0, 0, 0.5f, 1)); waveAnimation_0.AddAction(new SpriteSheetAnimation(Backpackers[0].Sprite, 2, 3, 0.2f, 4)); waveAnimation_0.AddAction(new SpriteSheetAnimation(Backpackers[0].Sprite, 0, 0, 0.1f, 1)); #endregion #region Backpacker 1 Sequence waveAnimation_1 = new Sequence(); MoveToStaticAction walkMove_1 = new MoveToStaticAction(Globals.TheGame, Backpackers[1].Transform, new Vector2(MeetingPoint - 40, 0), 1); walkMove_1.Timer.Interval = 0.5f; SpriteSheetAnimation walkAnim_1 = new SpriteSheetAnimation(Backpackers[1].Sprite, 0, 1, 0.1f, 5); waveAnimation_1.AddAction(new DelayAction(Globals.TheGame, 0.2f)); waveAnimation_1.AddAction(new Concurrent(new PastaGameLibrary.Action[] { walkMove_1, walkAnim_1 })); waveAnimation_1.AddAction(new SpriteSheetAnimation(Backpackers[1].Sprite, 0, 0, 0.5f, 1)); waveAnimation_1.AddAction(new SpriteSheetAnimation(Backpackers[1].Sprite, 2, 3, 0.1f, 5)); waveAnimation_1.AddAction(new SpriteSheetAnimation(Backpackers[1].Sprite, 0, 0, 0.1f, 1)); #endregion #region Backpacker 2 Sequence waveAnimation_2 = new Sequence(); MoveToStaticAction walkMove_2 = new MoveToStaticAction(Globals.TheGame, Backpackers[2].Transform, new Vector2(MeetingPoint - 80, 0), 1); walkMove_2.Timer.Interval = 0.5f; SpriteSheetAnimation walkAnim_2 = new SpriteSheetAnimation(Backpackers[2].Sprite, 0, 1, 0.1f, 5); waveAnimation_2.AddAction(new DelayAction(Globals.TheGame, 0.4f)); waveAnimation_2.AddAction(new Concurrent(new PastaGameLibrary.Action[] { walkMove_2, walkAnim_2 })); waveAnimation_2.AddAction(new SpriteSheetAnimation(Backpackers[2].Sprite, 2, 3, 0.2f, 3)); waveAnimation_2.AddAction(new SpriteSheetAnimation(Backpackers[2].Sprite, 0, 0, 0.1f, 1)); #endregion s_movingOutAnimation = new Concurrent(new PastaGameLibrary.Action[] { waveAnimation_0, waveAnimation_1, waveAnimation_2 }); }
public void ShinkerProperties() { var config = Configuration.QuickThrowOnFailure; var sut = new Concurrent <int, int, int>(() => 1, 3); var generator = Arb.From(sut.Generator(new Collection <ConcurrentCommand.Command <int, int> > { new IntSutIdentity() }), sut.Shrinker); Prop.ForAll(generator, testCase => { var uniqeClients = MakeClientsUniqe(testCase); var shrunken = sut.Shrinker(uniqeClients).ToList(); var flatClients = Flatten(uniqeClients); return(AllShunkenClientsElementOfOriginal(shrunken, flatClients) .And(OnlyOneElementOfOriginalNotInShrunken(shrunken, flatClients))); }).Check(config); }