public static IObservable<System.Int32> GetTokenFor(
     this IObservable<System.Reflection.Emit.DynamicILInfo> DynamicILInfoValue,
     IObservable<System.RuntimeFieldHandle> field)
 {
     return Observable.Zip(DynamicILInfoValue, field,
         (DynamicILInfoValueLambda, fieldLambda) => DynamicILInfoValueLambda.GetTokenFor(fieldLambda));
 }
Exemplo n.º 2
0
 public override IObservable<FileSystemEntity> FilterFileSystemEntities(IObservable<FileSystemEntity> source)
 {
     return source.Where(x =>
                             {
                                 return x.CreationTime < _dateTime;
                             });
 }
 public static IObservable<System.Reactive.Unit> SetExceptions(
     this IObservable<System.Reflection.Emit.DynamicILInfo> DynamicILInfoValue,
     IObservable<System.Byte[]> exceptions)
 {
     return ObservableExt.ZipExecute(DynamicILInfoValue, exceptions,
         (DynamicILInfoValueLambda, exceptionsLambda) => DynamicILInfoValueLambda.SetExceptions(exceptionsLambda));
 }
 public static IObservable<System.Int32> GetTokenFor(
     this IObservable<System.Reflection.Emit.DynamicILInfo> DynamicILInfoValue,
     IObservable<System.Reflection.Emit.DynamicMethod> method)
 {
     return Observable.Zip(DynamicILInfoValue, method,
         (DynamicILInfoValueLambda, methodLambda) => DynamicILInfoValueLambda.GetTokenFor(methodLambda));
 }
 public static IObservable<System.Reactive.Unit> SetAt(
     this IObservable<System.Security.SecureString> SecureStringValue, IObservable<System.Int32> index,
     IObservable<System.Char> c)
 {
     return ObservableExt.ZipExecute(SecureStringValue, index, c,
         (SecureStringValueLambda, indexLambda, cLambda) => SecureStringValueLambda.SetAt(indexLambda, cLambda));
 }
 public static IObservable<System.Reactive.Unit> Load(
     this IObservable<System.Runtime.InteropServices.UCOMIMoniker> UCOMIMonikerValue,
     IObservable<System.Runtime.InteropServices.UCOMIStream> pStm)
 {
     return ObservableExt.ZipExecute(UCOMIMonikerValue, pStm,
         (UCOMIMonikerValueLambda, pStmLambda) => UCOMIMonikerValueLambda.Load(pStmLambda));
 }
 public static IObservable<System.Reactive.Unit> set_Value(
     this IObservable<System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri> SoapAnyUriValue,
     IObservable<System.String> value)
 {
     return ObservableExt.ZipExecute(SoapAnyUriValue, value,
         (SoapAnyUriValueLambda, valueLambda) => SoapAnyUriValueLambda.Value = valueLambda);
 }
 public static IObservable<System.Reactive.Unit> Write(this IObservable<System.IO.TextWriter> TextWriterValue,
     IObservable<System.Char[]> buffer, IObservable<System.Int32> index, IObservable<System.Int32> count)
 {
     return ObservableExt.ZipExecute(TextWriterValue, buffer, index, count,
         (TextWriterValueLambda, bufferLambda, indexLambda, countLambda) =>
             TextWriterValueLambda.Write(bufferLambda, indexLambda, countLambda));
 }
 public static IObservable<System.Boolean> HasClaim(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.Predicate<System.Security.Claims.Claim>> match)
 {
     return Observable.Zip(ClaimsPrincipalValue, match,
         (ClaimsPrincipalValueLambda, matchLambda) => ClaimsPrincipalValueLambda.HasClaim(matchLambda));
 }
 public static IObservable<System.Int32> Skip(
     this IObservable<System.Runtime.InteropServices.UCOMIEnumString> UCOMIEnumStringValue,
     IObservable<System.Int32> celt)
 {
     return Observable.Zip(UCOMIEnumStringValue, celt,
         (UCOMIEnumStringValueLambda, celtLambda) => UCOMIEnumStringValueLambda.Skip(celtLambda));
 }
 public static IObservable<System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>> FindAll(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.String> type)
 {
     return Observable.Zip(ClaimsPrincipalValue, type,
         (ClaimsPrincipalValueLambda, typeLambda) => ClaimsPrincipalValueLambda.FindAll(typeLambda));
 }
 public static IObservable<System.Security.Claims.Claim> FindFirst(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.String> type)
 {
     return Observable.Zip(ClaimsPrincipalValue, type,
         (ClaimsPrincipalValueLambda, typeLambda) => ClaimsPrincipalValueLambda.FindFirst(typeLambda));
 }
 public static IObservable<System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>> FindAll(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.Predicate<System.Security.Claims.Claim>> match)
 {
     return Observable.Zip(ClaimsPrincipalValue, match,
         (ClaimsPrincipalValueLambda, matchLambda) => ClaimsPrincipalValueLambda.FindAll(matchLambda));
 }
 public static IObservable<System.Reactive.Unit> AddIdentity(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.Security.Claims.ClaimsIdentity> identity)
 {
     return ObservableExt.ZipExecute(ClaimsPrincipalValue, identity,
         (ClaimsPrincipalValueLambda, identityLambda) => ClaimsPrincipalValueLambda.AddIdentity(identityLambda));
 }
 public static IObservable<System.Reflection.FieldInfo> GetRuntimeField(IObservable<System.Type> type,
     IObservable<System.String> name)
 {
     return Observable.Zip(type, name,
         (typeLambda, nameLambda) =>
             System.Reflection.RuntimeReflectionExtensions.GetRuntimeField(typeLambda, nameLambda));
 }
 public static IObservable<System.Reactive.Unit> FromXml(
     this IObservable<System.Security.PermissionSet> PermissionSetValue,
     IObservable<System.Security.SecurityElement> et)
 {
     return ObservableExt.ZipExecute(PermissionSetValue, et,
         (PermissionSetValueLambda, etLambda) => PermissionSetValueLambda.FromXml(etLambda));
 }
 public static IObservable<System.Byte[]> ConvertPermissionSet(IObservable<System.String> inFormat,
     IObservable<System.Byte[]> inData, IObservable<System.String> outFormat)
 {
     return Observable.Zip(inFormat, inData, outFormat,
         (inFormatLambda, inDataLambda, outFormatLambda) =>
             System.Security.PermissionSet.ConvertPermissionSet(inFormatLambda, inDataLambda, outFormatLambda));
 }
Exemplo n.º 18
0
        public override void checkColision(IObservable o)
        {
            bool colision_detected = false;
            foreach(AGhost ghost in _ghosts.ghost_list)
            {
                if (ghost.pos_logic.x == _pacman.pos_logic.x && ghost.pos_logic.y == _pacman.pos_logic.y)
                {
                    if (ghost.mode == GhostMode.Frightened)
                    {
                        notifyObservers();
                        //GhostModeControler.Instance.eyesStart(ghost);  
                        ghost.changeMode(GhostMode.Eyes);
                        break;
                    }
                    else
                    {
                        if (ghost.mode != GhostMode.Eyes)
                        {
                            Console.Write("Zabity przez: " + ghost.name + "\n");
                            GameControler.Instance.lifeLost();
                            colision_detected = true;
                            break;
                        }
                    }
                }
            }

            if (!colision_detected && next_controler != null)
            {
                next_controler.checkColision(o);
            }
        }
 public static IObservable<System.Reactive.Unit> Invoke(
     this IObservable<System.Threading.SendOrPostCallback> SendOrPostCallbackValue,
     IObservable<System.Object> state)
 {
     return ObservableExt.ZipExecute(SendOrPostCallbackValue, state,
         (SendOrPostCallbackValueLambda, stateLambda) => SendOrPostCallbackValueLambda.Invoke(stateLambda));
 }
 public static IObservable<System.Security.IPermission> AddPermission(
     this IObservable<System.Security.PermissionSet> PermissionSetValue,
     IObservable<System.Security.IPermission> perm)
 {
     return Observable.Zip(PermissionSetValue, perm,
         (PermissionSetValueLambda, permLambda) => PermissionSetValueLambda.AddPermission(permLambda));
 }
 public static IObservable<System.Security.SecurityElement> ToXml(
     this IObservable<System.Security.Policy.GacMembershipCondition> GacMembershipConditionValue,
     IObservable<System.Security.Policy.PolicyLevel> level)
 {
     return Observable.Zip(GacMembershipConditionValue, level,
         (GacMembershipConditionValueLambda, levelLambda) => GacMembershipConditionValueLambda.ToXml(levelLambda));
 }
 public static IObservable<System.Reactive.Unit> EndInvoke(
     this IObservable<System.Threading.SendOrPostCallback> SendOrPostCallbackValue,
     IObservable<System.IAsyncResult> result)
 {
     return ObservableExt.ZipExecute(SendOrPostCallbackValue, result,
         (SendOrPostCallbackValueLambda, resultLambda) => SendOrPostCallbackValueLambda.EndInvoke(resultLambda));
 }
 public static IObservable<System.Boolean> Equals(
     this IObservable<System.Security.Policy.GacMembershipCondition> GacMembershipConditionValue,
     IObservable<System.Object> o)
 {
     return Observable.Zip(GacMembershipConditionValue, o,
         (GacMembershipConditionValueLambda, oLambda) => GacMembershipConditionValueLambda.Equals(oLambda));
 }
 public static IObservable<System.Reactive.Unit> FromXml(
     this IObservable<System.Security.Policy.GacMembershipCondition> GacMembershipConditionValue,
     IObservable<System.Security.SecurityElement> e)
 {
     return ObservableExt.ZipExecute(GacMembershipConditionValue, e,
         (GacMembershipConditionValueLambda, eLambda) => GacMembershipConditionValueLambda.FromXml(eLambda));
 }
 public static IObservable<System.Byte[]> GetDeploymentManifestBytes(
     IObservable<System.ActivationContext> appInfo)
 {
     return Observable.Select(appInfo,
         (appInfoLambda) =>
             System.Deployment.Internal.InternalActivationContextHelper.GetDeploymentManifestBytes(appInfoLambda));
 }
 public static IObservable<System.Reactive.Unit> set_Name(
     this IObservable<System.Diagnostics.Tracing.EventDataAttribute> EventDataAttributeValue,
     IObservable<System.String> value)
 {
     return ObservableExt.ZipExecute(EventDataAttributeValue, value,
         (EventDataAttributeValueLambda, valueLambda) => EventDataAttributeValueLambda.Name = valueLambda);
 }
 public static IObservable<int> Read(this IObservable<System.IO.StringReader> StringReaderValue,
     IObservable<System.Char[]> buffer, IObservable<System.Int32> index, IObservable<System.Int32> count)
 {
     return Observable.Zip(StringReaderValue, buffer, index, count,
         (StringReaderValueLambda, bufferLambda, indexLambda, countLambda) =>
             StringReaderValueLambda.Read(bufferLambda, indexLambda, countLambda));
 }
 public static IObservable<System.Reactive.Unit> set_Order(
     this IObservable<System.Runtime.Remoting.Metadata.SoapFieldAttribute> SoapFieldAttributeValue,
     IObservable<System.Int32> value)
 {
     return ObservableExt.ZipExecute(SoapFieldAttributeValue, value,
         (SoapFieldAttributeValueLambda, valueLambda) => SoapFieldAttributeValueLambda.Order = valueLambda);
 }
Exemplo n.º 29
0
        public OpenGLInputObservable(GameWindow window)
        {
            gameWindow = window;

            IObservable<IInput> downEvents =
                from evt in Observable.FromEventPattern<KeyboardKeyEventArgs>(window, "KeyDown")
                let keyInput = GLKeyInput.FromArgs(evt.EventArgs, false)
                where keyInput != null
                select keyInput;

            IObservable<IInput> upEvents =
                from evt in Observable.FromEventPattern<KeyboardKeyEventArgs>(window, "KeyUp")
                let keyInput = GLKeyInput.FromArgs(evt.EventArgs, true)
                where keyInput != null
                select keyInput;

            IObservable<IInput> mouseMoveEvents =
                from evt in Observable.FromEventPattern<MouseMoveEventArgs>(window, "MouseMove")
                from mouseInput in GLMouseInput.FromArgs(evt.EventArgs, gameWindow.Width, gameWindow.Height)
                select mouseInput;

            IObservable<IInput> mouseDownEvents =
                from evt in Observable.FromEventPattern<MouseButtonEventArgs>(window, "MouseDown")
                select GLMouseClickInput.FromArgs(evt.EventArgs, false);

            IObservable<IInput> mouseUpEvents =
                from evt in Observable.FromEventPattern<MouseButtonEventArgs>(window, "MouseUp")
                select GLMouseClickInput.FromArgs(evt.EventArgs, true);

            InputEvents = downEvents.Merge(upEvents).Merge(mouseMoveEvents).Merge(mouseDownEvents).Merge(mouseUpEvents);

            window.MouseMove += (sender, e) => Cursor.Position = new Point(window.Width / 2, window.Height / 2); // keep mouse centered (bc fps)
        }
 public static IObservable<System.DateTime> AddWeeks(
     this IObservable<System.Globalization.Calendar> CalendarValue, IObservable<System.DateTime> time,
     IObservable<System.Int32> weeks)
 {
     return Observable.Zip(CalendarValue, time, weeks,
         (CalendarValueLambda, timeLambda, weeksLambda) => CalendarValueLambda.AddWeeks(timeLambda, weeksLambda));
 }
Exemplo n.º 31
0
        public StockPropertyChanged(IObservable <bool> observable)
        {
            var a = observable;

            a.Subscribe(a => { flag = !flag; this.RaisePropertyChanged(nameof(GroupProperty)); });
        }
Exemplo n.º 32
0
 public Synchronize(IObservable <TSource> source)
 {
     _source = source;
 }
Exemplo n.º 33
0
 public static IObservable <string> FilterString(this IObservable <Pv2ParamValueAndTypePair> src,
                                                 Pv2StringParamType type)
 {
     return(src.Filter <Pv2StringParamType, Pv2StringParamValue, string>(type));
 }
Exemplo n.º 34
0
 public Synchronize(IObservable <TSource> source, object gate)
 {
     _source = source;
     _gate   = gate;
 }