예제 #1
0
        public LevelManager(int stageWidth, int stageHeight)
        {
            mCollideables = new List<Rectangle>();
            mBoundingBox = new List<Rectangle>();
            mSprites = new List<Sprite>();
            mUnits = new List<Unit>();
            eCurrLevel = CurrentLevel.None;
            mGoal = Rectangle.Empty;

            mInput = new InputManager();
            mInput.Alias("left", Keys.A);
            mInput.Alias("right", Keys.D);
            mInput.Alias("up", Keys.W);
            mInput.Alias("down", Keys.S);
            mInput.Alias("action", Keys.Space);

            StageHeight = stageHeight;
            StageWidth = stageWidth;
        }
예제 #2
0
 void OnTriggerEnter(Collider collider)
 {
     if (CurrentLevel.LevelInitialized())
     {
         if ((collider.tag == "Snow") || (collider.tag == "Ice") ||
             (collider.tag == "Reverse") || (collider.tag == "Straight"))
         {
             SpawnPool pool;
             if (pool_name == "Current Level")
             {
                 pool = PoolManager.Pools[CurrentLevel.GetCurrentLevelPoolName()];
             }
             else
             {
                 pool = PoolManager.Pools[CurrentLevel.GetGeneralPoolName()];
             }
             Quaternion rotation = collider.transform.rotation * Quaternion.Euler(rotation_angle_x, rotation_angle_y, rotation_angle_z);
             pool.Spawn(effect, transform.position, rotation);
         }
     }
 }
예제 #3
0
        // Handle user input and transition to new level if needed
        public void HandleInput(ConsoleKeyInfo key)
        {
            LevelTransition newLevel = null;

            // Different user actions
            switch (key.Key)
            {
            case ConsoleKey.W:
                newLevel = CurrentLevel.MovePlayer(Player, Constants.DIRECTION.NORTH);
                break;

            case ConsoleKey.A:
                newLevel = CurrentLevel.MovePlayer(Player, Constants.DIRECTION.WEST);
                break;

            case ConsoleKey.S:
                newLevel = CurrentLevel.MovePlayer(Player, Constants.DIRECTION.SOUTH);
                break;

            case ConsoleKey.D:
                newLevel = CurrentLevel.MovePlayer(Player, Constants.DIRECTION.EAST);
                break;

            case ConsoleKey.Spacebar:
                Player.Attack(CurrentLevel);
                break;

            case ConsoleKey.Escape:
                DisplayMenu();
                break;

            default:
                break;
            }

            if (newLevel != null)
            {
                TransitionToLevel(newLevel);
            }
        }
 private void _EndOverdrive()
 {
     _State = OverdriveState.Available;
     if (_LastLevelMode == OverdriveMode.Level)
     {
         PrevLevel();
         CurrentLevel.Mode = OverdriveMode.Multiplier;
     }
     else if (_LastLevelMode == OverdriveMode.Multiplier)
     {
         CurrentLevel.Normalize();
         if (CanPrevLevel)
         {
             PrevLevel();
         }
         else
         {
             CurrentLevel.Cripple();
             _State = OverdriveState.Unavailable;
         }
     }
 }
    private void _ApplyOverdrive()
    {
        _LastLevelMode = CurrentLevel.Mode;

        if (_LastLevelMode == OverdriveMode.Level)
        {
            if (CanNextLevel)
            {
                NextLevel();
            }
            else
            {             //Make multiplier if cant step forward
                _LastLevelMode    = OverdriveMode.Multiplier;
                CurrentLevel.Mode = _LastLevelMode;
                CurrentLevel.Overdrive();
            }
        }
        else if (_LastLevelMode == OverdriveMode.Multiplier)
        {
            CurrentLevel.Overdrive();
        }
    }
예제 #6
0
        /// <summary>
        /// Logic update
        /// </summary>
        /// <param name="pDt"></param>
        public static void OnFrameMove()
        {
            // Calc time
            float dt = CalcDt();

            // Calc FPS
            mFPSCounter++;
            mTimeCounter += dt;
            if (mTimeCounter >= 1)
            {
                mFPS         = mFPSCounter;
                mFPSCounter  = 0;
                mTimeCounter = 0;
            }

            mPlayer.OnFrameMove(dt);

            if (CurrentLevel != null)
            {
                CurrentLevel.OnFrameMove(dt);
            }
        }
예제 #7
0
        private void AddPlanets(BackgroundLayer layer)
        {
            List <Texture2D> planets = new List <Texture2D>();

            planets.Add(Content.Load <Texture2D>("Images/sun"));
            planets.Add(Content.Load <Texture2D>("Images/earth"));
            planets.Add(Content.Load <Texture2D>("Images/jupiter"));

            Random        r           = new Random();
            Rectangle     areaSize    = CurrentLevel.Bounds;
            List <Entity> testList    = new List <Entity>();
            const float   minDistance = 1500;

            for (int i = 0; i < 20; i++)
            {
                Planet planet = new Planet(planets[r.Next(planets.Count)], areaSize, CurrentLevel.PhysicsWorld);
                bool   found  = false;
                while (!found)
                {
                    planet.Position = Interpolations.GetRandomRectanglePoint(areaSize, r);
                    int tooClose = 0;
                    foreach (Entity e in testList)
                    {
                        if (Vector2.Distance(planet.Position, e.Position) < minDistance)
                        {
                            tooClose++;
                        }
                    }

                    found = (tooClose == 0);
                }
                planet.Scale          = 2.0f;
                planet.Rotation       = (float)r.NextDouble() * MathHelper.PiOver2;
                planet.PlanetRotation = (float)r.NextDouble() * 0.0005f;
                CurrentLevel.AddEntity(planet, layer, true);
                testList.Add(planet);
            }
        }
    public void SwitchCurrentLevel()
    {
        if (PreviousLevel == null)
        {
            PreviousLevel = CurrentLevel;
        }
        else
        {
            PreviousLevel.SetActive(false);
            CurrentLevel = NextLevel;
        }
        LevelBehaviour levelBehaviour     = CurrentLevel.GetComponent <LevelBehaviour>();
        GameObject     nextLevel          = levelBehaviour.GetPossibleNextLevel();
        LevelBehaviour nextLevelBehaviour = CurrentLevel.GetComponent <LevelBehaviour>();
        Vector3        nextLevelPosition  = levelBehaviour.GetNextLevelPosition(nextLevelBehaviour);

        NextLevel = Instantiate(nextLevel);
        NextLevel.transform.position = nextLevelPosition;

        //////////////////////////////// USING SINGLETON ///////////////////////////////////////
        ScoreBehaviour.Instance.UpdateScore();
        //////////////////////////////// USING SINGLETON ///////////////////////////////////////
    }
예제 #9
0
    public void TestLevel()
    {
        /// We need to...
        /// Clear the current UI
        /// switch to a widget with a stop test button
        GameObject    commandPalette = GameObject.Find("Command Palette");
        LevelEditorUI levelEditorUI  = GameObject.FindObjectOfType <LevelEditorUI>();

        if (CurrentLevel.levelData.LevelReady())
        {
            CurrentLevel.LoadPaddle();
            CurrentLevel.LoadSpawner();
            CurrentLevel.StartSpawner();
            CurrentLevel.levelData.GatherKeys();
            commandPalette.SetActive(false);
            levelEditorUI.HideAllCommands();
            CurrentLevel.StartPlaceableAnimations();
        }
        else
        {
            Debug.Log("No spawner in level");
        }
    }
예제 #10
0
        protected override void SetChildrenProperties()
        {
            regularBackground.Location = Location;
            regularBackground.Size     = Size;

            detailsBackground.Location = Location;
            detailsBackground.Size     = Size;

            skillIcon.Location    = new Point2D(Location.X + 5, Location.Y + 5);
            skillIcon.ContentFile = SkillIcon;

            currentLevelText.Text     = CurrentLevel.ToString();
            currentLevelText.Location = new Point2D(Location.X + 32, Location.Y + 4);

            baseLevelText.Text     = BaseLevel.ToString();
            baseLevelText.Location = new Point2D(Location.X + 44, Location.Y + 16);

            detailsText.Location = Location;
            detailsText.Size     = Size;
            detailsText.Text     = $"Xp:{Environment.NewLine}{Experience}";

            base.SetChildrenProperties();
        }
예제 #11
0
        public override void Draw()
        {
            Game.Graphics.GraphicsDevice.Clear(BGColor);

            if (!Player.Dead)
            {
                Game.SpriteBatch.Begin(Game.Camera, samplerState: SamplerState.PointClamp);
                CurrentLevel.Draw();
                Player.Draw();
                Particles.Effects.Draw();
                Game.SpriteBatch.End();
            }

            Game.SpriteBatch.Begin(samplerState: SamplerState.PointClamp);
            Game.SpriteBatch.Draw(Helper.SquareTexture, topRect, Color.Black * 0.5f);
            Player.DrawHUD();

            if (!Paused)
            {
                pauseButton.Draw();
            }

            if (Paused)
            {
                pausePopUp.Draw();
            }

            if (Player.Dead)
            {
                Game.SpriteBatch.Draw(Helper.SquareTexture, new Rectangle(0, 0, Game.Screen.X, Game.Screen.Y), Color.Black * 0.5f);
                restartPopUp.Draw();
            }
            ;

            Game.SpriteBatch.End();
        }
예제 #12
0
        public string this[string columnName]
        {
            get
            {
                if (columnName == "FirstName")
                {
                    return(string.IsNullOrEmpty(this.FirstName) ? "Required value" : null);
                }
                if (columnName == "LastName")
                {
                    return(string.IsNullOrEmpty(this.LastName) ? "Required value" : null);
                }
                if (columnName == "Program")
                {
                    return(string.IsNullOrEmpty(Program.ToString()) ? "Required value" : null);
                }
                if (columnName == "CurrentSemester")
                {
                    return(string.IsNullOrEmpty(CurrentSemester.ToString()) ? "Required value" : null);
                }
                if (columnName == "CurrentLevel")
                {
                    return(string.IsNullOrEmpty(CurrentLevel.ToString())? "Required value" : null);
                }
                if (columnName == "Email")
                {
                    return(string.IsNullOrEmpty(Email) ? "Required value" : null);
                }
                if (columnName == "Agreed")
                {
                    return(Agreed ? null : "Required value");
                }

                return(null);
            }
        }
예제 #13
0
파일: Game.cs 프로젝트: ITCareer-Lom/code
 public bool NextMove() /* TEST преминаваме на следващ ход, ако можем
                         * (т.е.ако не сме убити, ако не сме завършили и т.н.), иначе прекъсва цикъла*/
 {
     if (MyHero.Health <= 0)
     {
         State = GameState.GameOver;
     }
     else if (CurrentLevel.IsCompleted(MyHero) && LastLevel())
     {
         State = GameState.GameCompleted;
     }
     else if (CurrentLevel.IsCompleted(MyHero) && !LastLevel())
     {
         State = GameState.LevelCompleted;
     }
     else if (State == GameState.Playing)
     {
         MoveNo++;
         CanSelectMove = !CanSelectMove;
         OpponentSelection();
         return(true);
     }
     return(false);
 }
예제 #14
0
        public static ParseResult <GedcomHeader> Parse(GedcomLine first, ILineProvider lineProvider)
        {
            CurrentLevel currentLevel = CurrentLevel.None;

            var header = new GedcomHeader();

            GedcomLine line = default;
            string     currentRawLine;

            while ((currentRawLine = lineProvider.ReadLine()) != null)
            {
                line = ParserHelper.ParseLine(currentRawLine);

                if (line.Level == 0)
                {
                    break;
                }

                if (line.Level == 1)
                {
                    switch (line.GetTagOrRef())
                    {
                    case "SOUR":
                        currentLevel = CurrentLevel.Sour;
                        break;

                    case "GEDC":
                        currentLevel = CurrentLevel.Gedc;
                        break;

                    case "CHAR":
                        header.GedcomCharacterSet = line.GetLineContent();
                        break;
                    }
                }
                else if (line.Level == 2)
                {
                    if (currentLevel == CurrentLevel.Sour)
                    {
                        switch (line.GetTagOrRef())
                        {
                        case "NAME":
                            header.SourceName = line.GetLineContent();
                            break;

                        case "VERS":
                            header.SourceVers = line.GetLineContent();
                            break;

                        case "CORP":
                            header.SourceCorp = line.GetLineContent();
                            break;
                        }
                    }
                    else if (currentLevel == CurrentLevel.Gedc)
                    {
                        if (line.GetTagOrRef() == "VERS")
                        {
                            header.GedcomVers = line.GetLineContent();
                        }
                    }
                }
            }

            return(ParseResult.Create(header, line));
        }
예제 #15
0
 public void ReloadLevel()
 {
     SceneManager.LoadScene(CurrentLevel.ToString());
 }
예제 #16
0
 internal List <Puzzle> GetPuzzles()
 {
     return(PlayingRandom ? CurrentLevel.GetRandomPuzzles(CurrentLevel.NumPuzzles) : LevelManager.Instance.GetPuzzles(CurrentLevel));
 }
예제 #17
0
 public virtual void Reset()
 {
     CurrentLevel.Reset();
 }
예제 #18
0
 public string GetName()
 {
     return(string.Format("{0} - {1}", FullName, CurrentLevel.GetClass()));
 }
예제 #19
0
        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            int version = writer.SetVersion(1);

            UID.Serialize(writer);

            switch (version)
            {
            case 1:
            {
                writer.Write(SpawnTownGates);
                writer.Write(TownGates.Count);
                if (TownGates.Count > 0)
                {
                    foreach (Moongate gate in TownGates)
                    {
                        writer.Write(gate);
                    }
                }

                goto case 0;
            }

            case 0:
            {
                writer.Write(InvasionName);
                writer.Write(RegionName);
                writer.Write(DateStarted);
                writer.Write((int)Status);
                writer.Write(_CoreTicks);
                writer.Write(CurrentLevelKills);

                writer.Write(Invaders.Count);

                if (Invaders.Count > 0)
                {
                    foreach (Mobile invader in Invaders)
                    {
                        writer.Write(invader);
                    }
                }

                writer.Write(Levels.Count);

                if (Levels.Count > 0)
                {
                    foreach (Level level in Levels)
                    {
                        level.Serialize(writer);
                    }
                }

                writer.Write(ParticipantsScores.Count);

                if (ParticipantsScores.Count > 0)
                {
                    foreach (KeyValuePair <PlayerMobile, int> score in ParticipantsScores)
                    {
                        writer.Write(score.Key);
                        writer.Write(score.Value);
                    }
                }

                CurrentLevel.Serialize(writer);
            }
            break;
            }
        }
예제 #20
0
        private void SaveInternal(eSaveMode xiSaveMode, string xiFilename)
        {
            if (RootChunk == null)
            {
                MessageBox.Show("Can't save: no file is open");
                return;
            }

            string lExceptionWhen = "saving file";

            try
            {
                long lPreviousSize = -1;

                if (xiSaveMode == eSaveMode.Binary && File.Exists(xiFilename))
                {
                    lPreviousSize = new FileInfo(xiFilename).Length;
                }

                using (FileStream fs = File.Create(xiFilename))
                {
                    lExceptionWhen = "serialising the file";
                    if (xiSaveMode == eSaveMode.Binary)
                    {
                        if (RootChunk is VersionList)
                        {
                            CurrentLevel.Serialise(fs);
                        }
                        else
                        {
                            RootChunk.Serialise(fs);
                        }
                    }
                    else if (xiSaveMode == eSaveMode.Xml)
                    {
                        XmlSerializer xs = new XmlSerializer(typeof(Chunk));

                        if (RootChunk is VersionList)
                        {
                            xs.Serialize(fs, CurrentLevel);
                        }
                        else
                        {
                            xs.Serialize(fs, RootChunk);
                        }
                    }
                    else if (xiSaveMode == eSaveMode.Mmv)
                    {
                        if (RootChunk is VersionList)
                        {
                            VersionList lVersionList = (VersionList)RootChunk;
                            lVersionList.AddLevel(CurrentLevel);

                            RecursiveAddChunkNode(ChunkTreeView.Nodes[0].Nodes, 1, lVersionList.GetLastVersion());
                        }
                        else if (RootChunk is Level)
                        {
                            VersionList lVersionList = new VersionList(
                                (Level)RootChunk,
                                Path.GetFileNameWithoutExtension(xiFilename),
                                null);
                            RootChunk = lVersionList;
                        }
                        RootChunk.Serialise(fs);
                    }
                }

                if (lPreviousSize != -1 && lPreviousSize != new FileInfo(xiFilename).Length)
                {
                    MessageBox.Show("WARNING: The size of your level has changed. Please check it's not too large, and check MMEd for bugs that have allowed the size to change.",
                                    "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            catch (Exception err)
            {
                Trace.WriteLine(err);
                MessageBox.Show(string.Format("Exception occurred while {0}: {1}", lExceptionWhen, err.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            mLocalSettings.LastSavedFile = xiFilename;
            mLocalSettings.LastSavedMode = xiSaveMode;
            mCurrentFile     = xiFilename;
            mCurrentFileMode = xiSaveMode;
        }
예제 #21
0
        static void Draw_Tiles()
        {
            for (int y = 0; y < Level.GRIDH; y++)
            {
                for (int x = 0; x < Level.GRIDW; x++)
                {
                    int      imageIndex = -1;                           //Open floor image
                    Color    imageColor = Color.White;
                    Tile     thisTile   = CurrentLevel.tileArray[x, y]; //Shorthand for this tile
                    Creature player     = CurrentLevel.creatures[0];    //Shorthand for the player creature

                    if (CurrentLevel.levelType == "forest")
                    {
                        imageColor = Color.LightGreen; //Grassy forest floor
                    }

                    if (thisTile.lastSeenImage > 0)          //If we've seen it
                    {
                        imageIndex = thisTile.lastSeenImage; //Draw the remembered tile
                        imageColor = Color.DimGray;          //But washed out
                    }

                    bool LOS = ((CurrentLevel.LineOfSight(player.pos, new Point2D(x, y))) || iCanSeeForever);

                    if (LOS && player.blind <= 0) //If in line of sight and not blind
                    {
                        imageIndex = 46;          //Open floor tile
                        if (CurrentLevel.tileArray[x, y].isWall)
                        {
                            imageIndex = 219; //Wall image
                            imageColor = Color.Tan;
                        }

                        if (CurrentLevel.tileArray[x, y].fixtureLibrary.Count > 0)
                        {
                            int  topIndex    = CurrentLevel.tileArray[x, y].fixtureLibrary.Count - 1;
                            bool visibleTrap = true;

                            if (CurrentLevel.tileArray[x, y].fixtureLibrary[topIndex] is Trap)
                            {
                                Trap t = (Trap)CurrentLevel.tileArray[x, y].fixtureLibrary[topIndex];
                                if (t.visible)
                                {
                                    visibleTrap = true;
                                }
                                else
                                {
                                    visibleTrap = false;
                                }
                            }

                            if (visibleTrap)
                            {
                                imageIndex = CurrentLevel.tileArray[x, y].fixtureLibrary[topIndex].imageIndex;
                                imageColor = CurrentLevel.tileArray[x, y].fixtureLibrary[topIndex].color;
                            }
                            //else
                            //{
                            //    imageIndex = 0; //Open floor image
                            //    imageColor = Color.White;
                            //}
                        }
                    }

                    if (CurrentLevel.tileArray[x, y].itemList.Count > 0 &&                        //If there's an item here
                        (CurrentLevel.creatures[0].detectItem > 0 || (LOS && player.blind <= 0))) //If detecting items or can see them
                    {
                        int topIndex = CurrentLevel.tileArray[x, y].itemList.Count - 1;
                        if (CurrentLevel.tileArray[x, y].itemList[topIndex] != null)
                        {
                            imageIndex = CurrentLevel.tileArray[x, y].itemList[topIndex].itemImage; //Top item image
                            imageColor = CurrentLevel.tileArray[x, y].itemList[topIndex].color;
                        }
                    }

                    foreach (Creature c in CurrentLevel.creatures)
                    {
                        if (c.pos == new Point2D(x, y) && //If there's a creature here
                            ((LOS && player.blind <= 0 && (c.invisibility <= 0 || player.seeInvisible > 0)) ||
                             player.detectMonster > 0))   //And we can see or detect it
                        {
                            imageIndex = c.creatureImage;
                            imageColor = c.color;
                        }
                    }

                    if (imageIndex >= 0 && imageIndex < 256)                     //If existent
                    {
                        CurrentLevel.tileArray[x, y].lastSeenImage = imageIndex; //Remember image
                        DrawImage(imageIndex, new Point2D(x * TILEWIDTH, y * TILEHEIGHT),
                                  imageColor);                                   //Draw this tile's stuff
                    }

                    if (player.pos == new Point2D(x, y))                    //PC should always be drawn
                    {
                        imageIndex = player.creatureImage;
                        imageColor = player.color;
                        DrawImage(imageIndex, new Point2D(x * TILEWIDTH, y * TILEHEIGHT),
                                  imageColor); //Draw this tile's stuff
                    }
                    //int smellTotal = 0;
                    //foreach (int s in currentLevel.tileArray[x, y].scentMagnitude)
                    //{
                    //    smellTotal += s;
                    //}
                    //DrawText(veraSmall, smellTotal.ToString(), new Vector2(x * TILEWIDTH, y * TILEHEIGHT), Color.Red);
                }
            }
        }
예제 #22
0
 public InGameScreen(ContentManager content, EventHandler theScreenEvent, Game1 game)
     : base(theScreenEvent)
 {
     mPauseBackground = content.Load<Texture2D>("Images/PausedYes");
     _game = game;
     this.content = content;
     playerLifeFont = content.Load<SpriteFont>(@"Fonts/General");
     scoreFont = content.Load<SpriteFont>(@"Fonts/SpriteFont1");
     scoreOverlay = content.Load<Texture2D>(@"Images/Score");
     playerHealthBar = content.Load<Texture2D>(@"Images/Healthbar");
     gameOver = content.Load<Texture2D>(@"Images/GameOver");
     difficulty = Difficulty.easy;
     level = CurrentLevel.level1;
 }
예제 #23
0
 //Changes the level. Used in cheats.
 public string ChangeLevel()
 {
     if (currentLevel != null)
     {
         switch (level)
         {
             case CurrentLevel.level2:
                 currentLevel = new Level2(content, _game);
                 return "The level was changed to level 2";
             case CurrentLevel.level3:
                 break;
             case CurrentLevel.bonusLevel:
                 break;
             default:
                 break;
         }
     }
     var wrongLevel = (int)level;
     level -= 1;
     return string.Format("There is no level initiated or level {0} does not exist.", wrongLevel); // Currently not used as i have no way to display messages.
 }
예제 #24
0
 public void DrawLevel(GameTime gameTime, SpriteBatch spriteBatch, Camera camera)
 {
     CurrentLevel.Draw(gameTime, spriteBatch, camera);
 }
예제 #25
0
        static void Draw_GetPos()
        {
            Draw_Main();
            SdlGfx.boxColor(screen, 5, 533, 895, (short)(windowSizeY * 0.992), Color.Black.ToArgb());
            SdlGfx.rectangleColor(screen, 5, 533, 895, (short)(windowSizeY * 0.992), Color.White.ToArgb());

            DrawImage(88, new Point2D(cursorPos.X * TILEWIDTH, cursorPos.Y * TILEHEIGHT), Color.Yellow); //Draw Cursor

            #region Description
            int            m        = 535;
            Queue <string> messages = new Queue <string>();
            Tile           thisTile = CurrentLevel.tileArray[cursorPos.X, cursorPos.Y];

            if (CurrentLevel.LineOfSight(CurrentLevel.creatures[0].pos, cursorPos)) //If it can be seen
            {
                foreach (Creature c in CurrentLevel.creatures)
                {
                    if (c.pos == cursorPos) //If creature is at this position
                    {
                        messages.Enqueue("There is a " + c.name + " here.");
                    }
                }

                if (thisTile.itemList.Count > 0)
                {
                    messages.Enqueue("There is a " + thisTile.itemList[0].name + " here.");
                }

                if (thisTile.fixtureLibrary.Count > 0)
                {
                    if (thisTile.fixtureLibrary[0] is Trap)
                    {
                        Trap t = (Trap)thisTile.fixtureLibrary[0];
                        if (t.visible)
                        {
                            messages.Enqueue("There is a " + thisTile.fixtureLibrary[0].type + " here.");
                        }
                    }
                    else
                    {
                        messages.Enqueue("There is a " + thisTile.fixtureLibrary[0].type + " here.");
                    }
                }

                if (thisTile.isWall)
                {
                    messages.Enqueue("This is a " + thisTile.material.name + " wall.");
                }
            }
            else
            {
                messages.Enqueue("You cannot see to there at the moment");
            }

            while (messages.Count >= 14)
            {
                messages.Dequeue(); //Don't let there be more than fourteen in the queue
            }

            if (messages.Count <= 0)
            {
                messages.Enqueue("There is nothing noteworthy here.");
            }

            foreach (string message in messages.Reverse())
            {
                m -= 15; //Skip up 15 pixels
                DrawText(veraSmall, message, new Point2D(10, m), Color.White);
            }

            messages.Clear();
            #endregion
        }
예제 #26
0
        protected override void UpdatePosition()
        {
            var potentialX = X + _changeX;
            var potentialY = Y + _changeY;
            var trajectory = GetTrajectory(potentialX, potentialY);

            // Apply collision logic to tiles
            var intersecting = from tile in CurrentLevel.CurrentScreen.Tiles
                               from wall in tile.Boundary
                               let intersection = Geometry.GetIntersection(trajectory, wall)
                                                  where intersection != null
                                                  let distance = Geometry.GetDistance(new Point(potentialX, potentialY), intersection)
                                                                 orderby distance
                                                                 select new { Tile = tile, Wall = wall, intersection, distance };
            var closest = intersecting.FirstOrDefault();

            if (closest != null)
            {
                var wall = closest.Wall;
                var tile = closest.Tile;

                if (Math.Abs(wall.X1 - wall.X2) < FloatTolerance)                                  // vertical wall
                {
                    if (X < wall.X1 && tile.Boundary.All(w => w.X1 >= wall.X1 && w.X2 >= wall.X1)) // ball --> wall
                    {
                        X = wall.X1 - BallRadius;
                    }
                    else if (tile.Boundary.All(w => w.X1 <= wall.X1 && w.X2 <= wall.X1)) // wall <-- ball
                    {
                        X = wall.X1 + BallRadius;
                    }

                    _changeX    = 0;
                    _collisionX = true;
                    _collisionY = false;
                }
                else if (Math.Abs(wall.Y1 - wall.Y2) < FloatTolerance)                             // horizontal wall
                {
                    if (Y < wall.Y1 && tile.Boundary.All(w => w.Y1 >= wall.Y1 && w.Y2 >= wall.Y1)) // ball ^^ wall
                    {
                        Y = wall.Y1 - BallRadius;
                    }
                    else if (tile.Boundary.All(w => w.Y1 <= wall.Y1 && w.Y2 <= wall.Y1))
                    {
                        Y = wall.Y1 + BallRadius;
                    }

                    _changeY    = 0;
                    _collisionX = false;
                    _collisionY = true;
                }
                else // diagonal wall
                {
                    if (wall.Y1 > wall.Y2) // diagonal \
                    {
                        if (tile.Boundary.All(w => w.X1 <= wall.X2 && w.X2 <= wall.X2)) // bottom-left filled in
                        {
                            X += BallRadius;
                            Y += BallRadius;
                        }
                        else // top-right filled in
                        {
                            X -= BallRadius;
                            Y -= BallRadius;
                        }
                    }
                    else if (wall.Y1 < wall.Y2)                                         // diagonal /
                    {
                        if (tile.Boundary.All(w => w.X1 <= wall.X1 && w.X2 <= wall.X1)) // top-left filled in
                        {
                            X += BallRadius;
                            Y -= BallRadius;
                        }
                        else // bottom-right filled in
                        {
                            X -= BallRadius;
                            Y += BallRadius;
                        }
                    }

                    _changeX    = 0;
                    _changeY    = 0;
                    _collisionX = true;
                    _collisionY = true;
                }
            }
            else
            {
                _collisionX = false;
                _collisionY = false;
            }

            // If no collision, move ball normally
            if (!_collisionX)
            {
                X = potentialX;
            }

            if (!_collisionY)
            {
                Y = potentialY;
            }
            else
            {
                _changeX /= Friction;
            }

            // Apply gravity
            if (Math.Abs(_changeY) > 1 || Y < CurrentLevel.ScreenHeight - BallRadius)
            {
                _changeY -= _gravity;
            }

            // If edge of screen hit, switch screens and continue
            Side?side     = null;
            Line boundary = null;

            if (Y >= CurrentLevel.ScreenHeight)
            {
                side     = Side.Top;
                boundary = new Line(0, CurrentLevel.ScreenHeight, CurrentLevel.ScreenWidth, CurrentLevel.ScreenHeight);
            }
            else if (Y <= 0)
            {
                side     = Side.Bottom;
                boundary = new Line(0, 0, CurrentLevel.ScreenWidth, 0);
            }
            else if (X >= CurrentLevel.ScreenWidth)
            {
                side     = Side.Right;
                boundary = new Line(CurrentLevel.ScreenWidth, 0, CurrentLevel.ScreenWidth, CurrentLevel.ScreenHeight);
            }
            else if (X <= 0)
            {
                side     = Side.Left;
                boundary = new Line(0, 0, 0, CurrentLevel.ScreenHeight);
            }

            if (side.HasValue)
            {
                var intersection = Geometry.GetIntersection(trajectory, boundary);
                CurrentLevel.MoveBallToScreen(side.Value);
                CurrentLevel.InitialisePlayerPosition(side.Value, intersection, this);
            }
        }
예제 #27
0
 /// <summary>
 /// Назначить следующий уровень
 /// </summary>
 public void ChangeNewLevel()
 {
     CurrentLevel.Set(CurrentLevel + 1);
 }
예제 #28
0
 public void TickCommands(Timer timer)
 {
     timer.Tick += (sender, args) => CurrentLevel.Move();
     timer.Tick += (sender, args) => CurrentLevel.TransformGameStat(CurrentGameInfo);
     timer.Tick += (sender, args) => Invalidate();
 }
예제 #29
0
        ///========================================================================
        /// Method : publishToolStripMenuItem_Click
        ///
        /// <summary>
        ///     The Publish operation
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        ///========================================================================
        private void publishToolStripMenuItem_Click(object sender, EventArgs e)
        {
            PublishForm lForm = new PublishForm(this);

            if (RootChunk is VersionList)
            {
                //=====================================================================
                // Use the properties saved on the VersionList as defaults
                //=====================================================================
                VersionList lVersionList = (VersionList)RootChunk;

                if (lVersionList.CDFilename != null && lVersionList.CDFilename != "")
                {
                    lForm.CourseDropDown.SelectedItem = MMCD.Courses.Find(new Predicate <MMCD.Course>(
                                                                              delegate(MMCD.Course xiCourse) { return(xiCourse.FileName == lVersionList.CDFilename); }));
                }

                if (lVersionList.BinaryFilename != null && lVersionList.BinaryFilename != "")
                {
                    lForm.BinaryFileTextBox.Text = lVersionList.BinaryFilename;
                }

                if (lVersionList.CourseName != null && lVersionList.CourseName != "")
                {
                    lForm.NameTextBox.Text = lVersionList.CourseName;
                }
            }

            if (lForm.ShowDialog() == DialogResult.OK)
            {
                FileInfo lBinaryFile = new FileInfo(lForm.BinaryFileTextBox.Text);

                //=====================================================================
                // If we want to keep backups, make one now
                //=====================================================================
                if (lForm.BackupsCheckBox.Checked && lBinaryFile.Exists)
                {
                    string lBackupExtension = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss.bak");
                    string lBackupPath      = Path.Combine(Path.GetDirectoryName(lForm.BinaryFileTextBox.Text), "Backups");

                    if (!Directory.Exists(lBackupPath))
                    {
                        Directory.CreateDirectory(lBackupPath);
                    }

                    string lBackupFile = Path.Combine(lBackupPath,
                                                      Path.GetFileNameWithoutExtension(lForm.BinaryFileTextBox.Text) + "." + lBackupExtension);
                    lBinaryFile.CopyTo(lBackupFile);

                    //===================================================================
                    // Remove any outdated backups
                    //===================================================================
                    FileInfo[] lAllBackups = Array.ConvertAll <string, FileInfo>(Directory.GetFiles(lBackupPath,
                                                                                                    Path.GetFileNameWithoutExtension(lForm.BinaryFileTextBox.Text) + ".*.bak"),
                                                                                 new Converter <string, FileInfo>(delegate(string xiFilename)
                    {
                        return(new FileInfo(xiFilename));
                    }));
                    Utils.ArrayStableSort(lAllBackups, x => x.CreationTime);

                    for (int ii = (int)lForm.BackupCountUpDown.Value; ii < lAllBackups.Length; ii++)
                    {
                        lAllBackups[ii].Delete();
                    }
                }

                //=====================================================================
                // Save the binary file
                //=====================================================================
                using (FileStream lFileStream = lBinaryFile.Create())
                {
                    CurrentLevel.Serialise(lFileStream);
                }

                if (lForm.UpdateCDImageCheckBox.Checked)
                {
                    //===================================================================
                    // Update the CD image
                    //===================================================================
                    FileInfo    lCDFile     = new FileInfo(lForm.CDImageTextBox.Text);
                    CDImage     lImage      = new CDImage(lCDFile);
                    MMCD.Course lCourse     = (MMCD.Course)lForm.CourseDropDown.SelectedItem;
                    byte[]      lBinaryData = new byte[lCourse.CDLength];

                    lBinaryFile.Refresh();
                    if (lBinaryFile.Length != lCourse.CDLength)
                    {
                        MessageBox.Show("File is the wrong length! It will be padded with zeros or truncated to fit on the CD.", "Publish Course", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    }

                    using (FileStream lFileStream = lBinaryFile.OpenRead())
                    {
                        lFileStream.Read(lBinaryData, 0, (int)Math.Min(lBinaryData.Length, lBinaryFile.Length));
                    }

                    lImage.Replace(lBinaryData, lCourse.CDOffset);
                    lImage.WriteFile(lCDFile);

                    byte[] lCourseNameForCD = Encoding.ASCII.GetBytes(lCourse.GetCDCourseName(lForm.NameTextBox.Text));

                    foreach (long lNameOffset in lCourse.NameOffsets)
                    {
                        lImage.Replace(lCourseNameForCD, lNameOffset);
                        lImage.WriteFile(lCDFile);
                    }
                }

                if (RootChunk is VersionList)
                {
                    //===================================================================
                    // Update the properties saved on the VersionList
                    //===================================================================
                    VersionList lVersionList = (VersionList)RootChunk;
                    lVersionList.BinaryFilename = lForm.BinaryFileTextBox.Text;

                    if (lForm.UpdateCDImageCheckBox.Checked)
                    {
                        lVersionList.CDFilename = ((MMCD.Course)lForm.CourseDropDown.SelectedItem).FileName;
                        lVersionList.CourseName = lForm.NameTextBox.Text;
                    }

                    //===================================================================
                    // Save the VersionList
                    //===================================================================
                    if (mCurrentFile != null)
                    {
                        SaveInternal(mCurrentFileMode, mCurrentFile);
                    }
                }
            }
        }
예제 #30
0
        /// <summary>
        /// Permite al juego ejecutar lógica para, por ejemplo, actualizar el mundo,
        /// buscar colisiones, recopilar entradas y reproducir audio.
        /// </summary>
        /// <param name="gameTime">Proporciona una instantánea de los valores de tiempo.</param>
        protected override void Update(GameTime gameTime)
        {
            ButtonState bs = GamePad.GetState(PlayerIndex.One).Buttons.Back;

            var touch = TouchPanel.GetState().FirstOrDefault();

            bool pressed  = touch.State == TouchLocationState.Pressed;
            bool released = touch.State == TouchLocationState.Released;

            // About transitions ---------------------------->
            if (fadingScreen < 255)
            {
                fadingScreen += rateFade;
            }

            switch (STATE)
            {
                #region MENU
            case GameState.MENU:
            {
                if (bs == ButtonState.Pressed)
                {
                    GameSettings.Save(CurrentProgress);
                    Exit();
                }
                else if (touch.State == TouchLocationState.Pressed)
                {
                    if (recPlay.Contains((int)touch.Position.X, (int)touch.Position.Y))
                    {
                        STATE = GameState.WORLD;
                        LockExchangeScreens = true;
                    }
                    else if (recSettings.Contains((int)touch.Position.X, (int)touch.Position.Y))
                    {
                        CurrentProgress.LevelsPuntuations = new Dictionary <int, int>();
                        CurrentProgress.CurrentLevel      = 1;
                        GameSettings.SetCurrentProgress(CurrentProgress);
                        STATE       = GameState.WORLD;
                        PathTexture = Content.Load <Texture2D>("Path/Camino1");
                    }
                    else if (recAbout.Contains((int)touch.Position.X, (int)touch.Position.Y))
                    {
                    }
                }
                DrawMenu(gameTime);
                break;
            }

                #endregion
                #region WORLD
            case GameState.WORLD:
            {
                if (bs == ButtonState.Pressed)
                {
                    STATE = GameState.MENU;
                    break;
                }
                else
                {
                    if (released)
                    {
                        if (!LockExchangeScreens)
                        {
                            dragging = false;
                            if (!tooDragNoClick)
                            {
                                int l = cacheLevelsPositions.Count();

                                for (int i = 0; i < CurrentProgress.CurrentLevel; i++)
                                {
                                    if (i < LAST_LEVEL)
                                    {
                                        if (cacheLevelsPositions[i].Contains((int)touch.Position.X,
                                                                             (int)(touch.Position.Y + touchLocation)))
                                        {
                                            STATE = GameState.LEVEL;
                                            LoadLevel(i + 1);
                                        }
                                    }
                                }
                            }
                            tooDragNoClick = false;
                        }
                        LockExchangeScreens = false;
                    }
                    else if (pressed)
                    {
                        onDrag   = true;
                        dragging = true;
                    }

                    if (onDrag)
                    {
                        touchWorld = touch;
                        onDrag     = false;
                    }
                    if (dragging)
                    {
                        float difference = (touch.Position.Y - touchWorld.Position.Y);
                        touchLocation -= difference;
                        if (touchLocation > MAX_POS_START_WORLD_MAP_Y)
                        {
                            touchLocation = MAX_POS_START_WORLD_MAP_Y;
                        }
                        else if (touchLocation < 0)
                        {
                            touchLocation = 0;
                        }
                        touchWorld = touch;
                        if (Math.Abs(difference) > 1)
                        {
                            tooDragNoClick = true;
                        }
                    }

                    DrawWorld(gameTime);
                    break;
                }
            }

                #endregion
                #region LEVEL
            case GameState.LEVEL:
            {
                if (bs == ButtonState.Pressed)
                {
                    STATE = GameState.WORLD;
                }
                else if (touch.State == TouchLocationState.Pressed)
                {
                    int pushX = ((int)touch.Position.X - ScreenDistanceX) / CurrentLevel.SizeSquare,
                        pushY = ((int)touch.Position.Y - ScreenDistanceY) / CurrentLevel.SizeSquare;

                    var tappedPoint = new Point
                    {
                        X = (int)touch.Position.X,
                        Y = (int)touch.Position.Y
                    };

                    if ((pushX >= 0) && (pushX < CurrentLevel.X) && (pushY >= 0) && (pushY < CurrentLevel.Y))
                    {
                        SquareExploding = CurrentLevel.squares[pushX, pushY];
                        if (ItemPushed != -1)
                        {
                            if ((ItemPushed == 0) && (SquareExploding.Content < 2))
                            {
                                transitionStatus = 4;
                                soundEffect.Play();
                                SquareExploding.RecentChanged = true;
                                SquareExploding.Switch();
                                CurrentLevel.moves++;
                                CurrentProgress.GameItems[ItemPushed].Substract();
                                ItemPushed = -1;

                                if (CurrentLevel.IsLevelCompleted(1))
                                {
                                    ActionsWhenLevelCompleted();
                                }
                            }
                            else if (ItemPushed == 1)
                            {
                                transitionStatus = 4;
                                soundEffect.Play();
                                var squareList = CurrentLevel.Get5X5AreaSquares(pushX, pushY);
                                ExplodeSquareList(squareList, false);
                                CurrentProgress.GameItems[ItemPushed].Substract();
                                ItemPushed = -1;

                                if (CurrentLevel.IsLevelCompleted(1))
                                {
                                    ActionsWhenLevelCompleted();
                                }
                            }
                            else if (ItemPushed == 5)
                            {
                                dragginItemThunder = true;
                            }
                        }
                        else
                        {
                            if (SquareExploding.Content < 2)
                            {
                                transitionStatus = 4;

                                var squareList = CurrentLevel.GetSquareAndAdjacent(pushX, pushY);

                                ExplodeSquareList(squareList, true);
                            }
                        }
                    }
                    if (RecItemsContainer.Contains(tappedPoint))
                    {
                        var relativePushed = (tappedPoint.X - startXItems) / 80;
                        ItemPushed = (ItemPushed != relativePushed) &&
                                     (CurrentProgress.GameItems[relativePushed].Amount > 0)
                                    ? relativePushed
                                    : -1;
                    }
                    else if (recReset.Contains(tappedPoint))
                    {
                        CurrentLevel = SetCurrentLevel(Levels.Level[CurrentLevel.LevelNumber]);
                    }
                    else if (StarsRectangle.Contains(tappedPoint))
                    {
                        if (ItemPushed == 2)
                        {
                            if (CurrentLevel.ONE_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = 0;
                            }
                            else if (CurrentLevel.TWO_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.ONE_STAR / 2;
                            }
                            else if (CurrentLevel.TWO_STAR == CurrentLevel.moves)
                            {
                                CurrentLevel.moves = 0;
                            }
                            else if (CurrentLevel.THREE_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.TWO_STAR / 2;
                            }
                            else if (CurrentLevel.THREE_STAR == CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.ONE_STAR;
                            }
                            CurrentProgress.GameItems[ItemPushed].Substract();
                            ItemPushed = -1;
                        }
                        else if (ItemPushed == 3)
                        {
                            if (CurrentLevel.ONE_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = 0;
                            }
                            else if (CurrentLevel.TWO_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.ONE_STAR;
                            }
                            else if (CurrentLevel.TWO_STAR == CurrentLevel.moves)
                            {
                                CurrentLevel.moves = 0;
                            }
                            else if (CurrentLevel.THREE_STAR > CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.TWO_STAR;
                            }
                            else if (CurrentLevel.THREE_STAR == CurrentLevel.moves)
                            {
                                CurrentLevel.moves = CurrentLevel.ONE_STAR;
                            }
                            CurrentProgress.GameItems[ItemPushed].Substract();
                            ItemPushed = -1;
                        }
                    }
                }
                if (transitionStatus > 0)
                {
                    transitionStatus--;
                }
                else
                {
                    SquareExploding = null;
                    SquaresAdjacent = EmptySquares;
                }
                DrawLevel(gameTime);
                break;
            }

                #endregion
                #region ENDLEVEL
            case GameState.ENDLEVEL:
            {
                if (bs == ButtonState.Pressed || touch.State == TouchLocationState.Released)
                {
                    if (ScreenChange)
                    {
                        ScreenChange = false;
                    }
                    else
                    {
                        if (!gameOver)
                        {
                            if (CurrentProgress.CurrentLevel < CurrentLevel.LevelNumber)
                            {
                                TotalMoves += CurrentLevel.moves;
                                var next = CurrentLevel.LevelNumber + 1;
                                SetCurrentLevel(Levels.Level[next]);
                            }
                        }
                        STATE    = GameState.WORLD;
                        gameOver = false;
                        drawEnd  = false;
                    }
                }
                else
                {
                }
                DrawLevel(gameTime);
                break;
            }
            }
            #endregion
            base.Update(gameTime);
        }
예제 #31
0
 public virtual void HandleInput(InputHelper inputHelper)
 {
     CurrentLevel.HandleInput(inputHelper);
 }
예제 #32
0
 public virtual void Draw(GameTime gameTime, SpriteBatch spriteBatch)
 {
     CurrentLevel.Draw(gameTime, spriteBatch);
 }
예제 #33
0
        public IEnumerator LoadLevel(string levelName, LevelData levelData)
        {
            if (CurrentLevel != null)
            {
                CurrentLevel.Clean();
                CurrentLevel = null;
            }

            CurrentLevel = new Level()
            {
                GoalDescription       = levelData.GoalDescription,
                Max4VBatteries        = levelData.Max4VBatteries,
                Max9VBatteries        = levelData.Max9VBatteries,
                MaxBulbs              = levelData.MaxBulbs,
                MaxBuzzers            = levelData.MaxBuzzers,
                MaxMotors             = levelData.MaxMotors,
                MaxSwitches           = levelData.MaxSwitches,
                MaxWire               = levelData.MaxWireAvailable,
                CanBridge             = levelData.CanBridge,
                CanSnap               = levelData.CanSnap,
                CanBranch             = levelData.CanBranch,
                SuccessByShortCircuit = levelData.SuccessByShortCircuit
            };

            var characterController = ApplicationController.Instance.CharacterController;

            characterController.ClearAllCharacters();

            var wireController = ApplicationController.Instance.WireController;

            wireController.ClearAllWirePieces();

            _grid = FindObjectOfType <BulbGrid>();
            _grid.LoadSaveData(levelData.Grid);

            yield return(null);

            characterController.LoadCharacters <BatteryCharacter, BatteryCharacterData>(levelData.Batteries);
            characterController.LoadCharacters <LightBulbCharacter, LightBulbCharacterData>(levelData.LightBulbs);
            characterController.LoadCharacters <ObstructionCharacter, ObstructionCharacterData>(levelData.Obstructions);
            characterController.LoadCharacters <MotorCharacter, MotorCharacterData>(levelData.Motors);
            characterController.LoadCharacters <BuzzerCharacter, BuzzerCharacterData>(levelData.Buzzers);
            characterController.LoadCharacters <SwitchCharacter, SwitchCharacterData>(levelData.Switches);

            characterController.UpdateAllCharacters();

            wireController.LoadSaveData(levelData.WirePieces);

            _grid.FillZoomGrid();

            if (GameState.CurrentState == GameStates.Game)
            {
                var instructionPopup = InstructionsPopup.Instance;
                instructionPopup.SetDescription(levelData.GoalDescription);
                instructionPopup.TogglePopup(true);
            }

            if (OnLevelLoaded != null)
            {
                OnLevelLoaded(levelName, levelData);
            }

            _grid.SetGridMode(BulbGrid.GridMode.DrawWire);

            Debug.LogFormat("{0} | Loaded level: {1}", this, levelName);
        }
예제 #34
0
 public static void SetNextLevel(string NextLevel)
 {
     currentLevel = (CurrentLevel)Enum.Parse(typeof(CurrentLevel), NextLevel);
     LevelHasChanged = true;
 }