Esempio n. 1
0
        public void FindAndApplySeparatorSlots(System.Func <string, bool> slotNamePredicate, bool clearExistingSeparators = true, bool updateStringArray = false)
        {
            if (slotNamePredicate == null)
            {
                return;
            }
            if (!valid)
            {
                return;
            }

            if (clearExistingSeparators)
            {
                separatorSlots.Clear();
            }

            var slots = skeleton.slots;

            foreach (var slot in slots)
            {
                if (slotNamePredicate.Invoke(slot.data.name))
                {
                    separatorSlots.Add(slot);
                }
            }

            if (updateStringArray)
            {
                var detectedSeparatorNames = new List <string>();
                foreach (var slot in skeleton.slots)
                {
                    string slotName = slot.data.name;
                    if (slotNamePredicate.Invoke(slotName))
                    {
                        detectedSeparatorNames.Add(slotName);
                    }
                }
                if (!clearExistingSeparators)
                {
                    string[] originalNames = this.separatorSlotNames;
                    foreach (string originalName in originalNames)
                    {
                        detectedSeparatorNames.Add(originalName);
                    }
                }

                this.separatorSlotNames = detectedSeparatorNames.ToArray();
            }
        }
Esempio n. 2
0
        public static Path FindPath(StatePaintBot paintBot, MapCoordinate start, System.Func <MapCoordinate, bool> condition)
        {
            if (condition.Invoke(start))
            {
                return(new Path(Action.Stay, start, ImmutableList.Create <MapCoordinate>()));
            }

            HashSet <MapCoordinate> otherColouredCoordinates = paintBot.Map.CharacterInfos
                                                               .Where(ci => ci.Id != paintBot.PlayerId)
                                                               .SelectMany(ci => ci.ColouredPositions.Select(paintBot.MapUtils.GetCoordinateFrom))
                                                               .ToHashSet();
            HashSet <MapCoordinate> leaderColouredCoordinates = paintBot.Map.CharacterInfos
                                                                .Where(ci => ci.Id != paintBot.PlayerId && ci.Points >= paintBot.PlayerInfo.Points)
                                                                .SelectMany(ci => ci.ColouredPositions.Select(paintBot.MapUtils.GetCoordinateFrom))
                                                                .ToHashSet();

            ISet <MapCoordinate> visited = new HashSet <MapCoordinate>();
            SimplePriorityQueue <(Path, float), float> toTest = new SimplePriorityQueue <(Path, float), float>();

            toTest.Enqueue((new Path(Action.Stay, start, ImmutableList.Create <MapCoordinate>()), 0.0f), 0.0f);

            while (toTest.Count > 0)
            {
                var((firstStep, from, coordinates), fromSteps) = toTest.Dequeue();
                bool wasInRangeOfOther = IsInRangeOfOther(paintBot, from);
                foreach (Action direction in directions.OrderBy(_ => paintBot.Random.NextDouble()))
                {
                    MapCoordinate to = from.MoveIn(direction);
                    if (!visited.Contains(to) &&
                        !paintBot.Disallowed.Contains(to) &&
                        paintBot.MapUtils.IsMovementPossibleTo(to) &&
                        !IsTooCloseToOther(paintBot, to) &&
                        (wasInRangeOfOther || !IsInRangeOfOther(paintBot, to)))
                    {
                        float cost = 1.0f - paintBot.CalculatePointsAt(to) / 8.0f + 0.125f;
                        Path  path = new Path(firstStep != Action.Stay ? firstStep : direction, to, coordinates.Add(to));
                        if (condition.Invoke(to))
                        {
                            return(path);
                        }
                        visited.Add(to);
                        toTest.Enqueue((path, fromSteps + cost), fromSteps + cost);
                    }
                }
            }

            return(null);
        }
Esempio n. 3
0
        private string GetPartLocation(Transform t)
        {
            var sb = new StringBuilder();

            sb.Insert(0, t.name);

            System.Func <Transform, Transform> repeater = (T) =>
            {
                if (T.parent != null)
                {
                    sb.Insert(0, $"{T.parent.name}/");
                    return(T.parent);
                }

                return(null);
            };

            var parent = t;

            while (parent != null)
            {
                parent = repeater.Invoke(parent);
            }

            return(sb.ToString());
        }
 /// <summary>
 /// Applies a passed function to every member of the IList. Passed in function changes the item itself.
 /// </summary>
 /// <param name="function">Function with a single Item argument and with an Item return type.</param>
 public static void DoOnAll <I>(this IList <I> target, System.Func <I, I> function)
 {
     for (int i = 0; i < target.Count; i++)
     {
         target[i] = function.Invoke(target[i]);
     }
 }
Esempio n. 5
0
        public static int GetRandomIndex <T>(ref List <int> thresholds, List <T> list, System.Func <T, int> callback)
        {
            if (thresholds == null)
            {
                thresholds = new List <int>(list.Count);
            }
            else
            {
                thresholds.Clear();
            }

            var maxRate = 0;

            foreach (var key in list)
            {
                maxRate += callback.Invoke(key);
                thresholds.Add(maxRate);
            }

            var rate = Random.Range(0, maxRate);

            var index = 0;

            for (; index < thresholds.Count; ++index)
            {
                if (rate < thresholds[index])
                {
                    break;
                }
            }
            return(index);
        }
Esempio n. 6
0
        /// Creates a (or reuses a previously created) Screenshot instance
        private static T WithInstance <T>(bool cache, System.Func <Screenshot, T> func)
        {
            Screenshot screenshot = null;
            GameObject entity     = null;

            if (cache)
            {
                screenshot = cachedInstance;
                if (screenshot != null && !screenshot.isActiveAndEnabled)
                {
                    screenshot = null;
                }
            }

            if (screenshot == null)
            {
                // create and entity to hold our screenshot component
                entity     = new GameObject("Screenshot Instance");
                screenshot = entity.AddComponent <Screenshot>();
                if (cache)
                {
                    cachedInstance = screenshot;
                }
            }

            var result = func.Invoke(screenshot);

            if (!cache)
            {
                Destroy(entity);                     // cleanup
            }
            return(result);
        }
Esempio n. 7
0
        public static void Main(string[] args)
        {
            string a = supplier.Invoke();

            consumer.Invoke("a");
            string b = function.Invoke("b");
        }
Esempio n. 8
0
        private static Transform[] GetChildBy(Transform parent, System.Func <Transform, bool> comp)
        {
            List <Transform> returnContainer = new List <Transform>();

            LinkedList <Transform> queue = new LinkedList <Transform>();

            queue.AddLast(parent);

            while (queue.Count > 0)
            {
                var current = queue.First.Value;
                queue.RemoveFirst();

                for (int i = 0; i < current.childCount; i++)
                {
                    var child = current.GetChild(i);

                    if (comp.Invoke(child))
                    {
                        returnContainer.Add(child);
                    }

                    if (child.childCount > 0)
                    {
                        queue.AddLast(child);
                    }
                }
            }

            return(returnContainer.ToArray());
        }
        static StackObject *Invoke_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 4);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            System.Int32 @arg3 = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            System.Int32 @arg2 = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
            System.Int32 @arg1 = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 4);
            System.Func <System.Int32, System.Int32, System.Int32, System.Boolean> instance_of_this_method = (System.Func <System.Int32, System.Int32, System.Int32, System.Boolean>) typeof(System.Func <System.Int32, System.Int32, System.Int32, System.Boolean>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 8);
            __intp.Free(ptr_of_this_method);

            var result_of_this_method = instance_of_this_method.Invoke(@arg1, @arg2, @arg3);

            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value      = result_of_this_method ? 1 : 0;
            return(__ret + 1);
        }
Esempio n. 10
0
        public List <SpriteRenderer> Display()
        {
            int[]        arr    = new int[9];
            List <PosXY> dPosXY = new List <PosXY>()
            {
                new PosXY(-1, -1), new PosXY(0, -1), new PosXY(1, -1), new PosXY(-1, 0),
                new PosXY(0, 0), new PosXY(1, 0), new PosXY(-1, 1), new PosXY(0, 1), new PosXY(1, 1)
            };

            Tile tile = block.Tile;

            for (int i = 0; i < dPosXY.Count; i++)
            {
                PosXY dp = dPosXY[i] + tile.PosXY;

                Tile tempTile = tile.Board.GetTile(dp.x, dp.y);

                if (OnCheckType?.Invoke(tempTile) ?? false)
                {
                    arr[i] = 1;
                }
                else
                {
                    arr[i] = 0;
                }
            }

            return(SetupBorder(arr));
        }
Esempio n. 11
0
        public T Spawn <T, TState>(TState state, System.Func <TState, T> constructor, System.Action <T> destructor = null) where T : class
        {
            if (Pools.isActive == false)
            {
                var instance = constructor.Invoke(state);
                PoolInternalBaseThread.CallOnSpawn(instance, null);
                return(instance);
            }

            var type = typeof(T);

            if (this.pool.TryGetValue(type, out var pool) == true)
            {
                return((T)pool.Spawn());
            }

            pool = new PoolInternalThread <T, TState>(type, state, constructor, destructor);
            if (this.pool.TryAdd(type, pool) == true)
            {
                return((T)pool.Spawn());
            }

            if (this.pool.TryGetValue(type, out pool) == true)
            {
                return((T)pool.Spawn());
            }

            throw new System.Exception("Spawn failed");
        }
Esempio n. 12
0
        protected internal override void CopyScriptableObjects(System.Func <ScriptableObject, ScriptableObject> replaceSerializableObject)
        {
            connection = replaceSerializableObject.Invoke(connection) as NodeOutput;
            // Multiple connections
//			for (int conCnt = 0; conCnt < connections.Count; conCnt++)
//				connections[conCnt] = replaceSerializableObject.Invoke (connections[conCnt]) as NodeOutput;
        }
Esempio n. 13
0
 public static void Assert(bool assertion, System.Func <string> errorMessage, Object context = null)
 {
     if (!assertion)
     {
         Error(errorMessage.Invoke(), context);
     }
 }
Esempio n. 14
0
        private void SetAllQuadsColor(System.Func <int, int, int, Color, Color> func)
        {
            var voxels = Data.Voxels[CurrentModelIndex];

            int len = ContainerTF.childCount;

            for (int i = 0; i < len; i++)
            {
                var voxelTF = ContainerTF.GetChild(i);
                int vLen    = voxelTF.childCount;
                var pos     = voxelTF.localPosition;

                int x = Mathf.Clamp(Mathf.RoundToInt(pos.x), 0, ModelSize.x - 1);
                int y = Mathf.Clamp(Mathf.RoundToInt(pos.y), 0, ModelSize.y - 1);
                int z = Mathf.Clamp(Mathf.RoundToInt(pos.z), 0, ModelSize.z - 1);

                var color = func.Invoke(x, y, z, Data.GetColorFromPalette(voxels[x, y, z]));

                // Color
                bool alpha = color.a < 0.5f;
                color.a = 1f;
                for (int j = 0; j < vLen; j++)
                {
                    var quadTF = voxelTF.GetChild(j);
                    if (!quadTF.gameObject.activeSelf)
                    {
                        continue;
                    }
                    var dir = GetQuadDirection(quadTF);
                    SetQuadToAlpha(quadTF, alpha);
                    var mat = quadTF.GetComponent <MeshRenderer>().sharedMaterial;
                    mat.SetColor(COLOR_SHADER_ID, GetVoxelTintColor(color, dir));
                }
            }
        }
Esempio n. 15
0
                private void ExecuteError(int errcode, string errmessage)
                {
                    try
                    {
                        System.Diagnostics.Debug.WriteLine("GeoLocation.ExecuteError");

                        System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue> _func = _funcError as System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue>;
                        Jint.Native.Function.ScriptFunctionInstance JintScript = _func.Target as Jint.Native.Function.ScriptFunctionInstance;
                        Jint.Engine _JintEngine = JintScript.Engine;

                        JsValue   A = new JsValue(1);
                        JsValue[] B = new Jint.Native.JsValue[1];

                        Jint.Native.Json.JsonParser _jsp = new Jint.Native.Json.JsonParser(_JintEngine);
                        String FormatString = "{{\"code\":{0}, \"message\":\"{1}\"}}";
                        String Error        = String.Format(FormatString, errcode, errmessage);
                        B[0] = _jsp.Parse(Error);

                        _func.Invoke(A, B);
                    }
                    catch (Exception exp)
                    {
                        System.Diagnostics.Debug.WriteLine("Exception" + exp.Message);
                    }
                }
Esempio n. 16
0
                private void ExecuteSuccess(Geoposition _pos)
                {
                    try
                    {
                        System.Diagnostics.Debug.WriteLine("GeoLocation.ExecuteSuccess");

                        System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue> _func = _funcSuccess as System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue>;
                        Jint.Native.Function.ScriptFunctionInstance JintScript = _func.Target as Jint.Native.Function.ScriptFunctionInstance;
                        Jint.Engine _JintEngine = JintScript.Engine;

                        JsValue   A = new JsValue(1);
                        JsValue[] B = new JsValue[1];

                        Jint.Native.Json.JsonParser _jsp = new Jint.Native.Json.JsonParser(_JintEngine);
                        String FormatString = "{{\"coords\":{{\"latitude\":{0}, \"longitude\":{1}}}}}";
                        String Coordinates  = String.Format(FormatString, _pos.Coordinate.Latitude, _pos.Coordinate.Longitude);
                        B[0] = _jsp.Parse(Coordinates);

                        _func.Invoke(A, B);
                    }
                    catch (Jint.Runtime.JavaScriptException exc)
                    {
                        System.Diagnostics.Debug.WriteLine("JavaScriptException" + exc.Message + " " + exc.LineNumber);
                    }
                    catch (Exception e)
                    {
                        System.Diagnostics.Debug.WriteLine("Exception" + e.Message);

                        ExecuteError(e.HResult, e.Message);
                    }
                }
        public IAsyncResult <T1> Cast <T1>(System.Func <T, T1> payloadMapper)
        {
            var to = new AsyncResult <T1>(this.Error);

            to.Resolve(payloadMapper.Invoke(this.Payload));
            return(to);
        }
Esempio n. 18
0
        public void Ready()
        {
            try
            {
                if (!_Pebble.EventListeners.ContainsKey("ready"))
                {
                    return;
                }

                var jsfunction = _Pebble.EventListeners["ready"];

                System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue> _func = jsfunction as System.Func <Jint.Native.JsValue, Jint.Native.JsValue[], Jint.Native.JsValue>;

                Jint.Native.JsValue   A = new JsValue(1);
                Jint.Native.JsValue[] B = new Jint.Native.JsValue[1];

                Jint.Native.Json.JsonParser _jsp = new Jint.Native.Json.JsonParser(_JintEngine);
                B[0] = _jsp.Parse("{}");

                Jint.Native.JsValue C = _func.Invoke(A, B);
            }
            catch (Jint.Runtime.JavaScriptException exp)
            {
                String Exception = String.Format("{0}" + Environment.NewLine + "Line: {1}" + Environment.NewLine + "Source: {2}",
                                                 exp.Message,
                                                 exp.LineNumber,
                                                 _JavascriptLines[exp.LineNumber - 1]);

                throw new System.Exception(Exception);
            }
            catch (Exception exp)
            {
                throw exp;
            }
        }
Esempio n. 19
0
 /// <summary>
 /// Process every items from this list and returns an array of the results.
 /// </summary>
 /// <param name="input">The list to process</param>
 /// <param name="conversion">The function that will convert this list's elements</param>
 /// <typeparam name="I">The source list's element type</typeparam>
 /// <typeparam name="O">The destination array's element type</typeparam>
 /// <returns></returns>
 public static O[] Map<I, O>(this List<I> input, System.Func<I, O> conversion)
 {
     O[] output = new O[input.Count];
     for (int i=0; i<input.Count; i++)
         output[i] = conversion.Invoke(input[i]);
     return output;
 }
        static StackObject *Invoke_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 4);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            System.Int16 @arg3 = (short)ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            System.Single @arg2 = *(float *)&ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
            System.Int32 @arg1 = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 4);
            System.Func <System.Int32, System.Single, System.Int16, System.Double> instance_of_this_method = (System.Func <System.Int32, System.Single, System.Int16, System.Double>) typeof(System.Func <System.Int32, System.Single, System.Int16, System.Double>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            var result_of_this_method = instance_of_this_method.Invoke(@arg1, @arg2, @arg3);

            __ret->ObjectType        = ObjectTypes.Double;
            *(double *)&__ret->Value = result_of_this_method;
            return(__ret + 1);
        }
        public static T FindReferenceChildren <T>(GameObject root, System.Func <T, bool> callback = null)
        {
            var result = default(T);

            if (root != null)
            {
                var list = ListPool <T> .Get();

                root.GetComponentsInChildren <T>(true, list);
                if (list.Count > 0)
                {
                    if (callback != null)
                    {
                        for (int i = 0; i < list.Count; ++i)
                        {
                            if (callback.Invoke(list[i]) == true)
                            {
                                result = list[i];
                                break;
                            }
                        }
                    }
                    else
                    {
                        result = list[0];
                    }
                }
                ListPool <T> .Release(list);
            }

            return(result);
        }
Esempio n. 22
0
            /// <summary>
            /// Graphs a function on screen
            /// Warning: Produces GC allocs due to the lambda function.
            /// </summary>
            /// <param name="graphRect">Rect on screen</param>
            /// <param name="unitRect">A rect that defines a size of a unit of graph compared to pixels.
            /// E.g. a 0,0,1,1 unitRect will have it's lower left corner at 0,0 with unit size of 1 pixel. </param>
            /// <param name="func">A function that takes an 'x' and returns a 'y'</param>
            public static void Graph(Rect graphRect, Rect unitRect, System.Func <float, float> func)
            {
                if (!Drawer.Exists)
                {
                    return;
                }

                float prev = 0;

                for (int i = 0; i < graphRect.width; i++)
                {
                    float input = -unitRect.x / unitRect.width + (i / unitRect.width); // z +
                    float v0    = unitRect.y + func.Invoke(input) * unitRect.height;

                    v0 = Mathf.Clamp(v0,
                                     0,
                                     graphRect.height);

                    int screeny1 = (int)(graphRect.y + v0);
                    int screeny2 = (int)(graphRect.y + prev);

                    Line(
                        (int)graphRect.x + i, screeny1,
                        (int)graphRect.x + i + 1, screeny2);

                    prev = v0;
                }
            }
Esempio n. 23
0
        public void GetReward(string surfacingId, ShowResult showResult, System.Func <AdsData> callAdsData)
        {
            switch (showResult)
            {
            case ShowResult.Finished:
                Debug.Log($"Get Reward");
                GetReward();
                break;

            case ShowResult.Skipped:
                Debug.Log($"Skip Reward");
                GetReward();
                break;

            case ShowResult.Failed: Debug.LogWarning("The ad did not finish due to an error."); break;

            default: break;
            }
            void GetReward()
            {
                AdsDetail _adsDetai = callAdsData.Invoke().SetAdsDetail(surfacingId);

                Debug.Log($"_currencyDetail: {_adsDetai.currencyReward.eCurrency} --- {_adsDetai.currencyReward.unit} --- {AdsController.presentEAdsReward}");
                AdsController.callBackPresentAdsBtn?.Invoke(_adsDetai);
            }
        }
Esempio n. 24
0
        public override Assembly Resolve(System.Reflection.MetadataLoadContext context, AssemblyName assemblyName)
        {
            Debug.Assert(assemblyName != null);

            Assembly assembly = func.Invoke(context, assemblyName);

            return(assembly);
        }
Esempio n. 25
0
        public static System.ValueTuple <TimeSpan, GenericCollections.List <T> > MeasureTime <T>(System.Func <GenericCollections.IEnumerable <T> > action)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            var       result    = action.Invoke().ToList();

            stopwatch.Stop();
            return(System.ValueTuple.Create(stopwatch.Elapsed, result));
        }
Esempio n. 26
0
 private static IEnumerator Waiter_INTERNAL(System.Func <bool> waitFor, System.Action callback)
 {
     while (waitFor.Invoke() == false)
     {
         yield return(null);
     }
     callback.Invoke();
 }
Esempio n. 27
0
 public bool MoveNext()
 {
     if (m_Predicate == null)
     {
         return(false);
     }
     return(m_Predicate.Invoke());
 }
Esempio n. 28
0
 public void OnTriggerEnter(Collider other)
 {
     if (_checkTrigger.Invoke(other.gameObject))
     {
         _callBack.Invoke();
         Destroy(this.gameObject);
     }
 }
Esempio n. 29
0
 /// <summary>
 /// Threadsafe Invocation of <see cref="System.Action">delegate code</see> returning a value.
 /// </summary>
 /// <typeparam name="T">System.Type: The System.Type of the return value.</typeparam>
 /// <param name="value">The <see cref="System.Windows.Application">Application</see> Current instance.</param>
 /// <param name="action">System.Func(T): The <see cref="System.Action">delegate code</see>(<see cref="System.Func{TResult}">Func<![CDATA[<T>]]></see>) to execute and return.</param>
 /// <returns>T: The value returned from the delegate as T.</returns>
 public static T Invoke <T>(this System.Windows.Application value, System.Func <T> action)
 {
     if (value == null || value.Dispatcher == null)
     {
         return(action.Invoke());
     }
     return(value.Dispatcher.Invoke <T>(action));
 }
Esempio n. 30
0
 bool IsCombatOver()
 {
     if (onResultJudge != null)
     {
         return(onResultJudge.Invoke() != 0);
     }
     return(false);
 }