コード例 #1
0
ファイル: Startup.cs プロジェクト: llenroc/PhillyCodeCamp2016
        public void Configuration(IAppBuilder app)
        {
            var mongo   = new MongoConnection();
            var rethink = new RethinkConnection();

            // Configure Web API for self-host.
            HttpConfiguration config = new HttpConfiguration();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );


            app.UseCors(CorsOptions.AllowAll);
            app.MapSignalR();

            app.UseWebApi(config);

            ReqlExpr dbTable = RethinkDB.R.Db("baseball").Table("batterStat");

            var feed = dbTable.Changes()
                       .RunChanges <Batter>(RethinkConnection.Connection);

            var observe = feed.ToObservable();

            observe.SubscribeOn(NewThreadScheduler.Default)
            .Subscribe((Change <Batter> b) =>
            {
                BatterInstance.Instance.UpdateBatterStat(b.NewValue);
            });
        }
コード例 #2
0
        static void Main(string[] args)
        {
            var mongo      = new MongoConnection();
            var rethink    = new RethinkConnection();
            var eventStore = new EventConnection();

            var system   = ActorSystem.Create("baseballStats");
            var topLevel = system.ActorOf(GameEventCoordinator.Create(), "gameCoordinator");

            var handler = new PlayHandler(topLevel);


            ReqlExpr dbTable = RethinkDB.R.Db("baseball").Table("plays");

            var feed = dbTable.Changes()
                       .RunChanges <Play>(RethinkConnection.Connection /*, new { include_initial = true }*/);

            var observe = feed.ToObservable();

            observe.SubscribeOn(CurrentThreadScheduler.Instance)
            .Subscribe((Change <Play> p) =>
            {
                handler.Handle(p.NewValue);
            });



            Console.WriteLine("Hit enter to exit...");
            Console.ReadLine();
        }
コード例 #3
0
    public void OnGUI()
    {
        Event     currentEvent     = Event.current;
        EventType currentEventType = currentEvent.type;

        _view = BeginScrollView(
            _view,
            false,
            false,
            GUIStyle.none,
            GUI.skin.verticalScrollbar,
            GUI.skin.scrollView,
            GUILayout.Width(EditorGUIUtility.currentViewWidth),
            GUILayout.ExpandHeight(true));

        if (currentEventType == EventType.DragUpdated)
        {
            // Indicate that we don't accept drags ourselves
            DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
        }

        using (var h = new HorizontalScope())
        {
            _connectionString = TextField(_connectionString);
            if (GUILayout.Button("Connect"))
            {
                EditorPrefs.SetString("RethinkDB.URL", _connectionString);
                _queryStatus = RethinkConnection.RethinkConnect(_databaseCache, _connectionString);
            }
        }
        using (var h = new HorizontalScope())
        {
            if (GUILayout.Button("Connect All"))
            {
                EditorPrefs.SetString("RethinkDB.URL", _connectionString);
                _queryStatus = RethinkConnection.RethinkConnect(_databaseCache, _connectionString, true, false);
            }

            if (GUILayout.Button("Save"))
            {
                _databaseCache.Save(new DirectoryInfo(Application.dataPath).Parent.FullName);
            }
        }

        using (new HorizontalScope())
        {
            if (GUILayout.Button("Delete Orphaned Blueprints"))
            {
                int count = 0;
                foreach (var blueprintData in _databaseCache.GetAll <BlueprintData>().ToArray())
                {
                    if (_databaseCache.Get(blueprintData.Item) == null)
                    {
                        _databaseCache.Delete(blueprintData);
                        count++;
                    }
                }
                Debug.Log($"Deleted {count} orphaned blueprints!");
            }
        }

        if (_queryStatus != null && _queryStatus.RetrievedItems < _queryStatus.GalaxyEntries + _queryStatus.ItemsEntries)
        {
            var progressRect = GetControlRect(false, 20);
            EditorGUI.ProgressBar(progressRect, (float)_queryStatus.RetrievedItems / (_queryStatus.GalaxyEntries + _queryStatus.ItemsEntries), "Sync Progress");
        }
        // else
        // {
        //     if(_itemBlueprints == null)
        //         _itemBlueprints = _databaseCache.GetAll<ItemData>()
        //             .Select(itemData => new {itemData, blueprints = _databaseCache.GetAll<BlueprintData>()
        //                 .Where(blueprintData => blueprintData.Item == itemData.ID)
        //                 .Select(bp => bp.ID)
        //                 .ToList()})
        //             .ToDictionary(x => x.itemData.ID, x => x.blueprints);
        // }
        GUILayout.Space(5);

        // if(GUILayout.Button("Log Cache Count"))
        //     Debug.Log($"Cache contains {_databaseCache.AllEntries.Count()} elements");

        using (var h = new HorizontalScope(ListItemStyle))
        {
            _itemsFoldout = Foldout(_itemsFoldout, "Items", true);
        }
        if (_itemsFoldout)
        {
            var items = _databaseCache.AllEntries.Where(item => item is ItemData).Cast <ItemData>().ToArray();
            for (var i = 0; i < _itemTypes.Length; i++)
            {
                using (var h = new HorizontalScope(ListItemStyle))
                {
                    GUILayout.Space(10);
                    _itemTypeFoldouts[i] = Foldout(_itemTypeFoldouts[i],
                                                   ((NameAttribute)_itemTypes[i].GetCustomAttribute(typeof(NameAttribute)))?.Name ?? FormatTypeName(_itemTypes[i].Name),
                                                   true);
                }
                if (_itemTypeFoldouts[i])
                {
                    var typedItems = items.Where(e => e.GetType() == _itemTypes[i]).OrderBy(item => item.Name);
                    IEnumerable <IGrouping <string, ItemData> > itemGroups = new List <IGrouping <string, ItemData> >();
                    if (_itemTypes[i] == typeof(SimpleCommodityData))
                    {
                        itemGroups = typedItems.GroupBy(item => Enum.GetName(typeof(SimpleCommodityCategory), (item as SimpleCommodityData).Category));
                    }
                    else if (_itemTypes[i] == typeof(CompoundCommodityData))
                    {
                        itemGroups = typedItems.GroupBy(item => Enum.GetName(typeof(CompoundCommodityCategory), (item as CompoundCommodityData).Category));
                    }
                    else if (_itemTypes[i] == typeof(GearData))
                    {
                        itemGroups = typedItems.GroupBy(item => Enum.GetName(typeof(HardpointType), (item as GearData).Hardpoint));
                    }
                    else if (_itemTypes[i] == typeof(HullData))
                    {
                        itemGroups = typedItems.GroupBy(item => Enum.GetName(typeof(HullType), (item as HullData).HullType));
                    }

                    foreach (var itemGroup in itemGroups)
                    {
                        using (var h = new HorizontalScope(ListItemStyle))
                        {
                            GUILayout.Space(20);
                            if (Foldout(_itemGroupFoldouts.Contains(itemGroup.Key), FormatTypeName(itemGroup.Key), true))
                            {
                                _itemGroupFoldouts.Add(itemGroup.Key);
                            }
                            else
                            {
                                _itemGroupFoldouts.Remove(itemGroup.Key);
                            }
                        }

                        if (_itemGroupFoldouts.Contains(itemGroup.Key))
                        {
                            foreach (var item in itemGroup)
                            {
                                var style    = ListItemStyle;
                                var selected = SelectedItem == item.ID;
                                using (new HorizontalScope(selected?SelectedStyle:style))
                                {
                                    using (var h = new HorizontalScope())
                                    {
                                        if (h.rect.Contains(currentEvent.mousePosition))
                                        {
                                            if (currentEventType == EventType.MouseDrag)
                                            {
                                                DragAndDrop.PrepareStartDrag();
                                                DragAndDrop.SetGenericData("Item", item.ID);
                                                DragAndDrop.StartDrag("Database Item");
                                            }
                                            else if (currentEventType == EventType.MouseUp)
                                            {
                                                Select(item);
                                            }
                                        }

                                        GUILayout.Space(30);
                                        GUILayout.Label(item.Name, selected ? EditorStyles.whiteLabel : GUI.skin.label);
                                    }

                                    using (var h = new HorizontalScope(GUILayout.Width(15)))
                                    {
                                        if (GUI.Button(h.rect, GUIContent.none, GUIStyle.none))
                                        {
                                            if (_itemBlueprintFoldouts.Contains(item.ID))
                                            {
                                                _itemBlueprintFoldouts.Remove(item.ID);
                                            }
                                            else
                                            {
                                                _itemBlueprintFoldouts.Add(item.ID);
                                            }
                                        }
                                        GUILayout.Label(_itemBlueprints[item.ID].Count.ToString());
                                        var rect = GetControlRect(false, GUILayout.Width(EditorGUIUtility.singleLineHeight));
                                        if (Event.current.type == EventType.Repaint)
                                        {
                                            var controlId = GUIUtility.GetControlID(1337, FocusType.Keyboard, position);
                                            EditorStyles.foldout.Draw(rect, GUIContent.none, controlId, _itemBlueprintFoldouts.Contains(item.ID));
                                        }
                                    }
                                }

                                if (_itemBlueprintFoldouts.Contains(item.ID))
                                {
                                    foreach (var blueprintData in _itemBlueprints[item.ID]
                                             .Select(id => _databaseCache.Get <BlueprintData>(id))
                                             .OrderBy(bp => bp.Quality))
                                    {
                                        var blueprintStyle    = ListItemStyle;
                                        var blueprintSelected = SelectedItem == blueprintData.ID;
                                        using (var h = new HorizontalScope(blueprintSelected ? SelectedStyle : blueprintStyle))
                                        {
                                            if (h.rect.Contains(currentEvent.mousePosition))
                                            {
                                                if (currentEventType == EventType.MouseDrag)
                                                {
                                                    DragAndDrop.PrepareStartDrag();
                                                    DragAndDrop.SetGenericData("Item", blueprintData.ID);
                                                    DragAndDrop.StartDrag("Database Item");
                                                }
                                                else if (currentEventType == EventType.MouseUp)
                                                {
                                                    Select(blueprintData);
                                                }
                                            }

                                            GUILayout.Space(40);
                                            GUILayout.Label(blueprintData.Name,
                                                            blueprintSelected ? EditorStyles.whiteLabel : GUI.skin.label);
                                        }
                                    }

                                    using (var h = new HorizontalScope(ListItemStyle))
                                    {
                                        if (GUI.Button(h.rect, GUIContent.none, GUIStyle.none))
                                        {
                                            var blueprint = new BlueprintData
                                            {
                                                Item = item.ID,
                                                Name = item.Name
                                            };
                                            _databaseCache.Add(blueprint);
                                            Select(blueprint);
                                        }
                                        GUILayout.Space(40);
                                        GUILayout.Label("New Blueprint");
                                        var rect = GetControlRect(false, GUILayout.Width(EditorGUIUtility.singleLineHeight));
                                        GUI.DrawTexture(rect, Icons.Instance.plus, ScaleMode.StretchToFill, true, 1, LabelColor,
                                                        0, 0);
                                    }
                                }
                            }

                            using (var h = new HorizontalScope(ListItemStyle))
                            {
                                if (GUI.Button(h.rect, GUIContent.none, GUIStyle.none))
                                {
                                    CreateItem(_itemTypes[i], newItem =>
                                    {
                                        if (newItem is SimpleCommodityData simpleCommodityData)
                                        {
                                            simpleCommodityData.Category =
                                                (SimpleCommodityCategory)Enum.Parse(typeof(SimpleCommodityCategory),
                                                                                    itemGroup.Key);
                                            simpleCommodityData.Name = $"New {itemGroup.Key}";
                                        }
                                        else if (newItem is CompoundCommodityData compoundCommodityData)
                                        {
                                            compoundCommodityData.Category =
                                                (CompoundCommodityCategory)Enum.Parse(
                                                    typeof(CompoundCommodityCategory), itemGroup.Key);
                                            compoundCommodityData.Name = $"New {itemGroup.Key}";
                                        }
                                        else if (newItem is GearData gearData)
                                        {
                                            gearData.Hardpoint =
                                                (HardpointType)Enum.Parse(typeof(HardpointType), itemGroup.Key);
                                            gearData.Name = $"New {itemGroup.Key}";
                                        }
                                        else if (newItem is HullData hullData)
                                        {
                                            hullData.HullType = (HullType)Enum.Parse(typeof(HullType), itemGroup.Key);
                                            hullData.Name     = $"New {itemGroup.Key}";
                                        }
                                    });
                                }
                                GUILayout.Space(30);
                                GUILayout.Label("New " + itemGroup.Key);
                                var rect = GetControlRect(false, GUILayout.Width(EditorGUIUtility.singleLineHeight));
                                GUI.DrawTexture(rect, Icons.Instance.plus, ScaleMode.StretchToFill, true, 1, LabelColor, 0, 0);
                            }
                        }
                    }

                    if (!itemGroups.Any())
                    {
                        using (var h = new HorizontalScope(ListItemStyle))
                        {
                            if (GUI.Button(h.rect, GUIContent.none, GUIStyle.none))
                            {
                                CreateItem(_itemTypes[i]);
                            }
                            GUILayout.Space(20);
                            GUILayout.Label("New " + _itemTypes[i].Name);
                            var rect = GetControlRect(false, GUILayout.Width(EditorGUIUtility.singleLineHeight));
                            GUI.DrawTexture(rect, Icons.Instance.plus, ScaleMode.StretchToFill, true, 1, LabelColor, 0, 0);
                        }
                    }
                }
            }
        }

        var entries = _databaseCache.AllEntries.Where(item => !(item is ItemData)).ToArray();

        for (var i = 0; i < _entryTypes.Length; i++)
        {
            using (var h = new HorizontalScope(ListItemStyle))
            {
                _entryFoldouts[i] = Foldout(_entryFoldouts[i],
                                            ((NameAttribute)_entryTypes[i].GetCustomAttribute(typeof(NameAttribute)))?.Name ?? FormatTypeName(_entryTypes[i].Name),
                                            true);
            }

            if (_entryFoldouts[i])
            {
                int index = 0;
                foreach (var entry in entries.Where(e => e.GetType() == _entryTypes[i]).OrderBy(entry => entry is INamedEntry namedEntry ? namedEntry.EntryName : entry.ID.ToString()))
                {
                    index++;
                    var style    = ListItemStyle;
                    var selected = SelectedItem == entry.ID;
                    using (var h = new HorizontalScope(selected?SelectedStyle:style))
                    {
                        if (h.rect.Contains(currentEvent.mousePosition))
                        {
                            if (currentEventType == EventType.MouseDrag)
                            {
                                DragAndDrop.PrepareStartDrag();
                                DragAndDrop.SetGenericData("Item", entry.ID);
                                DragAndDrop.StartDrag("Database Item");
                            }
                            else if (currentEventType == EventType.MouseUp)
                            {
                                Select(entry);
                            }
                        }
                        GUILayout.Space(10);
                        GUILayout.Label((entry as INamedEntry)?.EntryName ?? index.ToString(), selected ? EditorStyles.whiteLabel : GUI.skin.label);
                    }
                }

                using (var h = new HorizontalScope(ListItemStyle))
                {
                    if (GUI.Button(h.rect, GUIContent.none, GUIStyle.none))
                    {
                        CreateItem(_entryTypes[i]);
                    }
                    GUILayout.Space(10);
                    GUILayout.Label("New " + _entryTypes[i].Name);
                    var rect = GetControlRect(false, GUILayout.Width(EditorGUIUtility.singleLineHeight));
                    GUI.DrawTexture(rect, Icons.Instance.plus, ScaleMode.StretchToFill, true, 1, LabelColor, 0, 0);
                }
            }
        }

        EndScrollView();
    }