Beispiel #1
0
        public bool Load()
        {
            if ((RegisterComponent != null) && (UnregisterComponent != null))
            {
                FlushCurrentComponents();

                try
                {
                    XDocument loadData = XDocument.Load("BopscotchLevel.xml");
                    AttemptToLoadPlayerData(loadData.Element("leveldata"));
                    AttemptToLoadRaceData(loadData.Element("leveldata"));

                    BackgroundTexture = loadData.Element("leveldata").Element("background").Attribute("texture").Value;

                    BlockFactory.LoadBlocks(loadData.Element("leveldata").Element("terrain").Element(BlockFactory.Data_Group_Node_Name), RegisterComponent);
                    CollectableFactory.LoadCollectables(loadData.Element("leveldata").Element("terrain").Element(CollectableFactory.Data_Group_Node_Name), RegisterComponent);
                    SignpostFactory.LoadSignposts(loadData.Element("leveldata").Element("terrain").Element(SignpostFactory.Data_Group_Node_Name), RegisterComponent);
                    FlagFactory.LoadFlags(loadData.Element("leveldata").Element("terrain").Element(FlagFactory.Data_Group_Node_Name), RegisterComponent);

                    return(true);
                }
                catch (Exception)
                {
                }
            }

            return(false);
        }
        public void LoadAndInitializeLevel()
        {
            XElement levelData = LoadLevelData();

            if (Data.Profile.PlayingRaceMode)
            {
                RaceLapCount = GetLapsForRace(levelData);
            }
            else
            {
                XElement rankFractionElement = levelData.Element(Rank_Fraction_Data_Element);
                RankACandyFraction = GetCandyFractionForRanking(rankFractionElement, "a", Rank_A_Candy_Fraction);
                RankBCandyFraction = GetCandyFractionForRanking(rankFractionElement, "b", Rank_B_Candy_Fraction);
            }

            WireUpCallElementFactoryCallbacks();

            Map = BlockFactory.CreateLevelBlockMap(levelData.Element(Terrain_Data_Element).Element(BlockFactory.Data_Group_Node_Name));

            CollectableFactory.LoadCollectables(levelData.Element(Terrain_Data_Element).Element(CollectableFactory.Data_Group_Node_Name));
            SignpostFactory.LoadSignposts(levelData.Element(Terrain_Data_Element).Element(SignpostFactory.Data_Group_Node_Name));
            FlagFactory.LoadFlags(levelData.Element(Terrain_Data_Element).Element(FlagFactory.Data_Group_Node_Name));

            Player = CharacterFactory.LoadPlayer(levelData.Element(CharacterFactory.Player_Data_Node_Name));

            FinalizeLevelSetup(levelData);
        }
Beispiel #3
0
        private void RemoveSelectedCheckpointFromSortOrder(CheckpointFlag toRemove)
        {
            List <IGameObject> flags = GameObjects(typeof(CheckpointFlag));

            for (int i = 0; i < flags.Count; i++)
            {
                if (((CheckpointFlag)flags[i]).CheckpointIndex > toRemove.CheckpointIndex)
                {
                    ((CheckpointFlag)flags[i]).CheckpointIndex--;
                }
            }
            FlagFactory.DecrementNextCheckpointIndex();
        }
Beispiel #4
0
        /// <summary>
        /// Occurs when this command is clicked
        /// </summary>
        public override void OnClick()
        {
            IMouseCursor cursor = new MouseCursorClass();

            cursor.SetCursor(2);

            DateTime start = DateTime.Now;

            IMap map = this.MxDocument.FocusMap;
            List <IFeatureLayer> layerList;

            try
            {
                layerList = Umbriel.ArcGIS.Layer.LayerHelper.FindFeatureLayers(map);

                // remove any layers that don't have a feature selection
                Util.NetworkAnalysisHelper.RemoveLayersWithNoSelections(ref layerList);

                // remove any layers that aren't point layers
                Util.NetworkAnalysisHelper.RemoveLayersNonPointLayers(ref layerList);

                System.Diagnostics.Debug.WriteLine("layerList.count=" + layerList.Count.ToString());

                if (layerList.Count.Equals(0))
                {
                    MessageBox.Show("There are no layers with selected points.", "Flag Feature Selection Tool", MessageBoxButtons.OK);
                }
                else
                {
                    FlagFactory factory = new FlagFactory(this.ArcMapApplication);

                    PathAnalyzer analyzer = new PathAnalyzer(factory);
                    analyzer.CountPaths(layerList);

                    TimeSpan elapsedTime = DateTime.Now.Subtract(start);

                    System.Diagnostics.Trace.WriteLine("Flags added in " + elapsedTime.TotalSeconds.ToString() + " seconds.");
                    this.MxDocument.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewForeground, null, null);
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.StackTrace);
                throw;
            }
            finally
            {
                cursor.SetCursor(0);
            }
        }
Beispiel #5
0
        public void ReinstateDynamicObjects(XElement serializedData)
        {
            WireUpCallElementFactoryCallbacks();

            BlockFactory.ReinstateSerializedBlocks(GetSerializedFactoryData(serializedData, BlockFactory.Serialized_Data_Identifier));
            CollectableFactory.ReinstateSerializedCollectables(GetSerializedFactoryData(serializedData, CollectableFactory.Serialized_Data_Identifier));
            FlagFactory.ReinstateSerializedFlags(GetSerializedFactoryData(serializedData, FlagFactory.Serialized_Data_Identifier));
            SignpostFactory.ReinstateSerializedSignposts(GetSerializedFactoryData(serializedData, SignpostFactory.Signpost_Serialized_Data_Identifier));
            SignpostFactory.ReinstateSerializedRouteMarkers(GetSerializedFactoryData(serializedData, SignpostFactory.Route_Marker_Serialized_Data_Identifier));

            _registerGameObject(new Background());

            Player = CharacterFactory.ReinstatePlayer();
        }
        public void ReinstateDynamicObjects(XElement serializedData)
        {
            WireUpCallElementFactoryCallbacks();

            XElement levelData = LoadLevelData();

            Map = BlockFactory.ReinstateLevelBlockMap(levelData.Element(Terrain_Data_Element).Element(BlockFactory.Data_Group_Node_Name));

            CollectableFactory.ReinstateSerializedCollectables(GetSerializedFactoryData(serializedData, CollectableFactory.Serialized_Data_Identifier));
            FlagFactory.ReinstateSerializedFlags(GetSerializedFactoryData(serializedData, FlagFactory.Serialized_Data_Identifier));
            SignpostFactory.ReinstateSerializedSignposts(GetSerializedFactoryData(serializedData, SignpostFactory.Signpost_Serialized_Data_Identifier));
            SignpostFactory.ReinstateSerializedRouteMarkers(GetSerializedFactoryData(serializedData, SignpostFactory.Route_Marker_Serialized_Data_Identifier));

            Player = CharacterFactory.ReinstatePlayer();

            FinalizeLevelSetup(levelData);
        }
Beispiel #7
0
        public void LoadAndInitializeLevel()
        {
            XElement levelData = LoadLevelData();

            RaceLapCount = (Data.Profile.PlayingRaceMode ? GetLapsForRace(levelData) : 0);

            WireUpCallElementFactoryCallbacks();

            Map = BlockFactory.LoadBlocks(levelData.Element(Terrain_Data_Element).Element(BlockFactory.Data_Group_Node_Name));
            Map.ViewportDimensionsInTiles = new Point(
                (BackgroundDimensions.X / Definitions.Grid_Cell_Pixel_Size) + 1, BackgroundDimensions.Y / Definitions.Grid_Cell_Pixel_Size);

            CollectableFactory.LoadCollectables(levelData.Element(Terrain_Data_Element).Element(CollectableFactory.Data_Group_Node_Name));
            SignpostFactory.LoadSignposts(levelData.Element(Terrain_Data_Element).Element(SignpostFactory.Data_Group_Node_Name));
            FlagFactory.LoadFlags(levelData.Element(Terrain_Data_Element).Element(FlagFactory.Data_Group_Node_Name));

            Player     = CharacterFactory.LoadPlayer(levelData.Element(CharacterFactory.Player_Data_Node_Name));
            Player.Map = Map;

            CreateBackground(levelData.Element(Background_Data_Element));

            _registerGameObject(Map);
        }
Beispiel #8
0
        public void AddingEntity(StreamReader reader)
        {
            var    line   = reader.ReadLine();
            var    values = line.Split(',');
            Tile   tile   = new Tile();
            string n      = values[0];
            int    x      = Convert.ToInt32(values[1]);
            int    y      = Convert.ToInt32(values[2]);

            tile.Position = Grid.Position(x, y);
            string itemName = "";
            string pipeName = "";
            int    itemNum  = 0;

            if (values.Length > 3 && !string.IsNullOrEmpty(values[3]))
            {
                itemName = values[3];
                itemNum  = Convert.ToInt32(values[4]);
            }
            if (values.Length > 7 && !string.IsNullOrEmpty(values[7]))
            {
                pipeName      = values[5];
                _pipePosition = new Vector2(Convert.ToInt32(values[6]), Convert.ToInt32(values[7]));
            }
            else if (values.Length > 5 && !string.IsNullOrEmpty(values[5]))
            {
                pipeName      = values[3];
                _pipePosition = new Vector2(Convert.ToInt32(values[4]), Convert.ToInt32(values[5]));
            }

            if (n.Equals("Mario"))
            {
                Mario = new MarioEntity(tile.Position, Sounds);
                movingEntities.Add(Mario);
            }
            else if (n.Equals("EnemyPipe"))
            {
                tile.Entity = new EnemyPipeEntity(tile.Position, tiles, movingEntities);
            }
            else if (n.Equals("Pole"))
            {
                tile.Entity = FlagFactory.BuildSprite(tile.Position);
            }
            else if (n.Equals("Boo"))
            {
                tile.Entity = BooFactory.BuildSprite(Mario, tile.Position);
            }
            else if (Enum.TryParse(n, out ItemCreation.ItemType itemType))
            {
                tile.Entity = ItemCreation.BuildItemEntity(itemType, tile.Position, Sounds);
            }
            else if (Enum.TryParse(n, out EnemyFactory.EnemyType enemyType))
            {
                tile.Entity = EnemyFactory.BuildEnemySprite(enemyType, tile.Position, Mario);
                movingEntities.Add(tile.Entity);
            }
            else if (Enum.TryParse(n, out BlockCreation.SceneBlock sceneBlock))
            {
                tile.Entity = BlockCreation.BuildSceneBlock(sceneBlock, tile.Position);
            }
            else if (Enum.TryParse(n, out BlockCreation.Blocks blockType))
            {
                tile.Entity = BlockCreation.BuildBlockEntity(blockType, tile.Position, Sounds);
                if ((tile.Entity is QuestionBlockEntity || tile.Entity is BrickBlockEntity) &&
                    (Enum.TryParse(itemName, out ItemCreation.ItemType item)))   //adding item to question block entity
                {
                    for (int i = 0; i < itemNum; i++)
                    {
                        Entity one = ItemCreation.BuildItemEntity(item, tile.Position, Sounds);
                        tile.Entity.AddItem(one, tiles, movingEntities, Mario);
                    }
                }
                else if (tile.Entity is BridgeBlockEntity && Enum.TryParse(itemName, out ItemCreation.ItemType axe))
                {
                    Entity _axe   = ItemCreation.BuildItemEntity(axe, new Vector2(tile.Position.X + 32, tile.Position.Y - 64), Sounds);
                    Tile   theAxe = new Tile {
                        Entity = _axe
                    };
                    tiles.Add(theAxe);
                    (tile.Entity as BridgeBlockEntity).AxeLink(_axe as AxeEntity);
                    for (int i = 0; i < itemNum; i++)//adding bridge blocks
                    {
                        Entity one = BlockCreation.BuildBlockEntity(BlockCreation.Blocks.BridgeBlock, new Vector2(tile.Position.X - i * 32, tile.Position.Y), Sounds);
                        (one as BridgeBlockEntity).AxeLink(_axe as AxeEntity);
                        tile.Entity.AddItem(one, tiles, movingEntities, Mario);
                    }
                }
                else if (tile.Entity is PipeBlockEntity && Enum.TryParse(itemName, out EnemyFactory.EnemyType enemy) && Enum.TryParse(pipeName, out BlockCreation.Blocks block))
                {
                    Entity plant = EnemyFactory.BuildEnemySprite(enemy, tile.Position, Mario);
                    tile.Entity.AddItem(plant, tiles, movingEntities, Mario);
                    _first        = tile.Entity as PipeBlockEntity;
                    _pipePosition = Grid.Position((int)_pipePosition.X, (int)_pipePosition.Y);
                    Entity second = BlockCreation.BuildBlockEntity(block, _pipePosition, Sounds);
                    Tile   two    = new Tile {
                        Entity = second
                    };
                    _first.SetWarpDestination(second as PipeBlockEntity, Mario);
                    tiles.Add(two);
                    Grid.AddtoGrid(second);
                }
                else if (tile.Entity is PipeBlockEntity && Enum.TryParse(pipeName, out BlockCreation.Blocks pipe))
                {
                    _first        = tile.Entity as PipeBlockEntity;
                    _pipePosition = Grid.Position((int)_pipePosition.X, (int)_pipePosition.Y);
                    Entity second = BlockCreation.BuildBlockEntity(pipe, _pipePosition, Sounds);
                    Tile   two    = new Tile {
                        Entity = second
                    };
                    _first.SetWarpDestination(second as PipeBlockEntity, Mario);
                    tiles.Add(two);
                    Grid.AddtoGrid(second);
                }
            }

            if (tile.Entity != null)
            {
                tiles.Add(tile);
                //Grid.AddtoGrid(tile.Entity);
            }
        }
Beispiel #9
0
        private void CompleteMouseAction()
        {
            if (_activeModalBox != null)
            {
                CheckAndHandleModalAction();
            }
            else if (_controlPanel.Contains(_inputHandler.MousePosition))
            {
                CheckAndHandleCommandChange();
            }
            else if (_selected == null)
            {
                switch (_controlPanel.ActiveOption)
                {
                case "Player":
                    _player.WorldPosition = SnapToGrid(_inputHandler.MousePosition + _cameraController.WorldPosition - new Vector2(Definitions.CellSizeInPixels / 2.0f));
                    _player.Visible       = true;
                    break;

                case "Blocks":
                    if (ModalBoxSelectionCanBePlaced("block-selector"))
                    {
                        AddTerrainObject(BlockFactory.CreateBlockFromTextureName(SelectorValue("block-selector")), _inputHandler.MousePosition);
                    }
                    break;

                case "Candies":
                    if (ModalBoxSelectionCanBePlaced("candy-selector"))
                    {
                        AddTerrainObject(CollectableFactory.CreateCandyFromTextureName(SelectorValue("candy-selector")), _inputHandler.MousePosition);
                    }
                    break;

                case "Signs":
                    if (ModalBoxSelectionCanBePlaced("sign-selector"))
                    {
                        AddTerrainObject(SignpostFactory.CreateSignpostFromTextureName(SelectorValue("sign-selector")), _inputHandler.MousePosition);
                    }
                    break;

                case "Flags":
                    if (ModalBoxSelectionCanBePlaced("flag-selector"))
                    {
                        AddTerrainObject(FlagFactory.CreateFlagFromTextureName(SelectorValue("flag-selector")), _inputHandler.MousePosition);
                    }
                    break;

                case "Enemies":
                    if (EnemySelectionCanBePlaced())
                    {
                        AddEnemy(EnemyFactory.CreateEnemyFromTextureName(SelectorValue("enemy-selector")), _inputHandler.MousePosition);
                    }
                    break;

                case "Route":
                    if (ModalBoxSelectionCanBePlaced("route-selector"))
                    {
                        AddTerrainObject(SignpostFactory.CreateRouteMarkerFromTextureName(SelectorValue("route-selector")), _inputHandler.MousePosition);
                    }
                    break;
                }
            }
            else if (_selected is ObjectBase)
            {
                if (!SnapDraggedObjectToGrid())
                {
                    _selected.ReturningToPreviousLocation = true; _selected.Selected = false; _selected = null;
                }
            }
        }