Inheritance: AcademyPopcorn.Block
        /* Legend:
            G - gift block
            X - gift (the block that is dropped after G is hit)
            E - the exploding block
            * - TrailObject (used by the meteorite ball or after explosion of ExplodingBlock)
            @ - bullet fired by the racket
            % - ExplosionBlockResult blocks
         */
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // build ceiling and left wall for the scene
            for (int i = 0; i < endCol; i++)
            {
                Block ceilingBlock = new IndestructibleBlock(new MatrixCoords(0, i));
                Block leftWallBlock = new IndestructibleBlock(new MatrixCoords(i, 0));

                engine.AddObject(ceilingBlock);
                engine.AddObject(leftWallBlock);
            }

            // build right wall for the scene
            for (int i = 0; i < WorldRows; i++)
            {
                Block rightWallBlock = new IndestructibleBlock(new MatrixCoords(i, endCol - 1));
                engine.AddObject(rightWallBlock);
            }

            // meteorite or unstoppable ball test
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // test trail object with random MatrixCoords and lifetime = 15 turns
            GameObject trailObj = new TrailObject(new MatrixCoords(WorldRows - 6, WorldCols - 12), 15);
            engine.AddObject(trailObj);

            // add a gift block
            Block giftBlock = new GiftBlock(new MatrixCoords(WorldRows - 11, WorldCols - 20));
            engine.AddObject(giftBlock);

            //add unpassable block with random coords
            Block unpassable = new UnpassableBlock(new MatrixCoords(WorldRows - 15, WorldCols - 10));
            engine.AddObject(unpassable);

            // add exploding block and ordinary blocks around it
            Block explodingBlock = new ExplodingBlock(new MatrixCoords(WorldRows - 12, WorldCols - 35));
            Block leftToExploding = new Block(explodingBlock.TopLeft + new MatrixCoords(0, -1));
            Block rightToExploding = new Block(explodingBlock.TopLeft + new MatrixCoords(0, 1));
            engine.AddObject(explodingBlock);
            engine.AddObject(leftToExploding);
            engine.AddObject(rightToExploding);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = 0; i < endCol + 2; i++)
            {
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(startRow - 1, i)));
            }

            for (int i = startRow; i < 32; i++)
            {
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(i, 0)));
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(i, endCol + 1)));
            }

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                          new MatrixCoords(-1, 1), -1);

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol + 10; i < endCol - 5; i++)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow + 5, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol + 12; i < endCol - 7; i += 3)
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow + 3, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol; i < endCol; i += 3)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow + 8, i));

                engine.AddObject(currBlock);
            }

            UnstopableBall theBall = new UnstopableBall(new MatrixCoords(WorldRows / 2, 0),
                                                        new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //Task 1
            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock indBlock = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(indBlock);

                indBlock = new IndestructibleBlock(new MatrixCoords(i, 0));
                engine.AddObject(indBlock);
            }

            for (int i = 1; i < WorldCols - 1; i++)
            {
                IndestructibleBlock indBlock = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(indBlock);
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;
            Random rnd = new Random();

            for (int i = startCol; i < endCol; i++)
            {

                if (rnd.Next(startCol, WorldCols*2)> endCol)
                {
                    Block currBlock = new Block(new MatrixCoords(startRow, i));
                    engine.AddObject(currBlock);
                }
                else if (rnd.Next(startCol, WorldCols * 3) > endCol)
                {
                    ExplodingBlock boomBlock = new ExplodingBlock(new MatrixCoords(startRow, i));

                    engine.AddObject(boomBlock);
                }
                else if (rnd.Next(startCol, WorldCols * 4) > endCol)
                {
                    GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow, i));

                    engine.AddObject(giftBlock);
                }
                else
                {
                    UnpassableBlock unpBlock = new UnpassableBlock(new MatrixCoords(startRow, i));
                    engine.AddObject(unpBlock);
                }

            }

            MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
            Racket newtheRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength + 1);
            engine.AddObject(newtheRacket);
            // Add side wallsя
            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock leftWallBlock = new IndestructibleBlock(new MatrixCoords(row, 0));
                engine.AddObject(leftWallBlock);
                IndestructibleBlock rightWallBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(rightWallBlock);
            }
            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock roof = new IndestructibleBlock(new MatrixCoords(0, col));
                engine.AddObject(roof);
            }
        }
Example #5
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;
            for (int col = 0; col <WorldCols; col++)
            {
                IndestructibleBlock wallLeftBlock = new IndestructibleBlock(new MatrixCoords(0,col));
                engine.AddObject(wallLeftBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                if (i == 7) //the seventh block is the first block, being hit by the ball
                {
                    currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                }
                else if (i == endCol-3) //you'll have to wait a little bit to see hit that block with the gift
                {
                    currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                }
                engine.AddObject(currBlock);

            }
            //Add side walls
            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock wallLeftBlock = new IndestructibleBlock(new MatrixCoords(row, 0));
                engine.AddObject(wallLeftBlock);
                IndestructibleBlock wallRightBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(wallRightBlock);
            }
            //trail object
            char[,] signOfTrail={{'*'}};
            TrailObject trail=new TrailObject(new MatrixCoords(13,13),signOfTrail,10);
            engine.AddObject(trail);

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //testing the meteorite ball
            MeteoriteBall secondBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(secondBall);
            //engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

               // adding an unpassable block and an unstoppable ball
            for (int i = 10; i < WorldRows; i++)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords(i, 8)));
            }

            engine.AddObject(new UnstoppableBall(new MatrixCoords(WorldRows - 1, WorldCols / 2 + 1), new MatrixCoords(-1, 1)));
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock indBlock = new IndestructibleBlock(new MatrixCoords(0, i));

                engine.AddObject(indBlock);
            }

            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock indBlock = new IndestructibleBlock(new MatrixCoords(i, 0));

                engine.AddObject(indBlock);
            }

            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock indBlock = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(indBlock);
            }

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            //engine.AddObject(theBall);

            //Ball theMeteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            //engine.AddObject(theMeteoriteBall);

            Ball theUnsBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(theUnsBall);

            UnpassableBlock theUnpasBlock = new UnpassableBlock(new MatrixCoords(WorldRows - 19, WorldCols - 21));

            engine.AddObject(theUnpasBlock);

            GiftBlock theGiftBlock = new GiftBlock(new MatrixCoords(5, 7));

            engine.AddObject(theGiftBlock);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                if (i == 3)
                {
                    ExplodingBlock expBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                    engine.AddObject(expBlock);
                    continue;
                }
                if (i == 2)
                {
                    GiftBlock giftblock = new GiftBlock(new MatrixCoords(startRow, i));
                    engine.AddObject(giftblock);
                    continue;
                }
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

               // Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
               //     new MatrixCoords(-1, 1));
            //MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            for (int i = startRow; i < Console.BufferHeight; i++)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords(i, startCol - 1)));
            }
            for (int i = startRow; i < Console.BufferHeight; i++)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords(i, WorldCols - 2)));
            }
            for (int i = startCol-1; i < WorldCols-1; i++)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords(startRow - 1, i)));
            }
            Random rnd = new Random();
            for (int i = 0; i < 5; i++)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords((rnd.Next(0, WorldCols)), (rnd.Next(0, WorldRows)))));
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // Task 1
            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock leftWall = new IndestructibleBlock(new MatrixCoords(i, 0));
                engine.AddObject(leftWall);
                IndestructibleBlock rightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(rightWall);
            }

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(ceiling);
            }

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // Task 5, 6, 7
            MeteoriteBall meteor = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(meteor);

            // Task 8, 9
            UnstoppableBall unstoppable = new UnstoppableBall(new MatrixCoords(4, 4), new MatrixCoords(1, 1));

            engine.AddObject(unstoppable);
            UnpassableBlock unpassable = new UnpassableBlock(new MatrixCoords(9, 9));

            engine.AddObject(unpassable);
            // Task 10
            ExplodingBlock explodeBlock = new ExplodingBlock(new MatrixCoords(8, 8));

            engine.AddObject(explodeBlock);

            // Task 11, 12
            GiftBlock gift = new GiftBlock(new MatrixCoords(10, 10));

            engine.AddObject(gift);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i), new [,] {{'#'}});

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 1, i), new[,] { { '#' } });

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 2, i), new[,] { { '#' } });

                engine.AddObject(currBlock);
            }

            Racket someRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            engine.AddObject(someRacket);

            for (int row = 3; row < WorldRows; row++)
            {
                UnpassableBlock leftWall = new UnpassableBlock(new MatrixCoords(row, 1));
                engine.AddObject(leftWall);
                UnpassableBlock rightWall = new UnpassableBlock(new MatrixCoords(row, endCol));
                engine.AddObject(rightWall);
            }
            for (int col = 1; col <= endCol; col++)
            {
                IndestructibleBlock topWall = new IndestructibleBlock(new MatrixCoords(startRow - 1, col));
                engine.AddObject(topWall);
            }

            //MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(7, 7), new MatrixCoords(1, 1));
            //engine.AddObject(meteoriteBall);

            UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(7, 7), new MatrixCoords(1, 1));
            engine.AddObject(unstoppableBall);

            ExplodingBlock explodingBlock = new ExplodingBlock(new MatrixCoords(startRow + 3, 15));
            engine.AddObject(explodingBlock);

            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow + 3, endCol - 1));
            engine.AddObject(giftBlock);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            //Problem One - Create ceiling wall
            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock ceilBlock = new IndestructibleBlock(new MatrixCoords(0, i));

                engine.AddObject(ceilBlock);
            }

            //Problem One - Create side walls
            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock leftBlock = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock rightBlock = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(leftBlock);
                engine.AddObject(rightBlock);
            }

            for (int i = startCol; i < endCol; i++)
            {
                //Problem Nine - Test UnpassableBlock
                //UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow, i));

                //Problem Ten - Test ExplodingBlock
                //ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));

                //Problem Twelve - Test GiftBlock
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            //Problem Seven - Test MeteoriteBall
            //MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //Problem Nine - Test UnstoppableBall
            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            //Problem Thirteen - Test ShootingRacket
            ShootingRacket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        private static void AddGiftBlocks(Engine engine)
        {
            int startRow = 6;
            int startCol = 10;
            int endCol = 19;

            for (int col = startCol; col < endCol; col++)
            {
                var currBlock = new GiftBlock(new MatrixCoords(startRow, col), new FireGift());

                engine.AddObject(currBlock);
            }
        }
        private static void AddGiftBlocks(Engine engine)
        {
            int startRow = 6;
            int startCol = 10;
            int endCol   = 19;

            for (int col = startCol; col < endCol; col++)
            {
                var currBlock = new GiftBlock(new MatrixCoords(startRow, col), new FireGift());

                engine.AddObject(currBlock);
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int endRow = WorldRows;
            int startCol = 2;
            int endCol = WorldCols - 2;


            //Task 1: Implementing Game field with adding a "for cycle" for rows
            //Task 10: Using UnpassableBlock 
            for (int row = startRow; row < endRow; row++)
            {
                for (int col = startCol; col < endCol; col++)
                {
                    if (row == startRow)
                    {
                        UnpassableBlock unpassable = new UnpassableBlock(new MatrixCoords(row, col));
                        engine.AddObject(unpassable);
                    }
                    if (row != startRow && (col == startCol || col == endCol - 1))
                    {
                        UnpassableBlock unpassable = new UnpassableBlock(new MatrixCoords(row, col));
                        engine.AddObject(unpassable);
                    }
                    else if (row <= startRow + 5 && row != startRow)
                    {
                        //Task12: Implementing GiftBlock.cs 
                        GiftBlock currBlock = new GiftBlock(new MatrixCoords(row, col));
                        engine.AddObject(currBlock);
                    }
                }

            }

            // Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 10),
            //     new MatrixCoords(-1, 1));

            //Task7: Implementing Meteorit Ball 
            //MeteoritBall meteoritBall = new MeteoritBall(new MatrixCoords(WorldRows / 2, 10), new MatrixCoords(-1, 1));

            //Task9: Implement Unstoppable ball
            UnstoppableBall ultimateBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 10), new MatrixCoords(-1, 1));

            engine.AddObject(ultimateBall);

            //TODO - Task 13: Implementing Shooting Ability
            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            engine.AddObject(theRacket);


        }
Example #14
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock;
                if (i == 7)
                {
                    currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                }
                else if (i == endCol - 3)
                {
                    currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                }
                else
                {
                    currBlock = new Block(new MatrixCoords(startRow, i));
                }

                engine.AddObject(currBlock);
            }

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(theBall);
            // Task7: Test MeteoriteBall
            //Ball theMeteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            //engine.AddObject(theMeteoriteBall);

            #region
            // Task9 Test UnstoppableBall

            /*Ball theUnstopableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
             * engine.AddObject(theUnstopableBall);
             *
             * for (int i = 2; i < WorldCols/2; i+=4)
             * {
             *  engine.AddObject(new UnpassableBlock(new MatrixCoords(4, i)));
             * }*/
            #endregion

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            engine.AddObject(theRacket);
            //Task3
            Racket newtheRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength + 1);
            engine.AddObject(newtheRacket);
        }
Example #15
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol; i < endCol; i++)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow - 2, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol; i < endCol; i+=2)
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow + 1, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i += 2)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow + 2, i));

                engine.AddObject(currBlock);
            }
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            UnstoppableBall unstoppable = new UnstoppableBall(new MatrixCoords(WorldRows / 2+4, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);
            engine.AddObject(unstoppable);

            ShoothingRacket theRacket = new ShoothingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //TrailObject test = new TrailObject(3, new MatrixCoords(5, 5), new char[1, 1]{{'H'}});
            //engine.AddObject(test);

            //walls
            InitializeWalls(engine);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // Task 1
            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock leftWall = new IndestructibleBlock(new MatrixCoords(i, 0));
                engine.AddObject(leftWall);
                IndestructibleBlock rightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(rightWall);
            }

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(ceiling);
            }

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // Task 5, 6, 7
            MeteoriteBall meteor = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            engine.AddObject(meteor);

            // Task 8, 9
            UnstoppableBall unstoppable = new UnstoppableBall(new MatrixCoords(4,4), new MatrixCoords(1, 1));
            engine.AddObject(unstoppable);
            UnpassableBlock unpassable = new UnpassableBlock(new MatrixCoords(9, 9));
            engine.AddObject(unpassable);
            // Task 10
            ExplodingBlock explodeBlock = new ExplodingBlock( new MatrixCoords(8,8));
            engine.AddObject(explodeBlock);

            // Task 11, 12
            GiftBlock gift = new GiftBlock(new MatrixCoords(10, 10));
            engine.AddObject(gift);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            engine.AddObject(new TailObject(new MatrixCoords(10, 5), new char[1,1] {{'%'}}, 5));

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock2 = new Block(new MatrixCoords(startRow + 1, i));
                engine.AddObject(currBlock2);
                ExplodingBlock currBlock3 = new ExplodingBlock(new MatrixCoords(startRow + 2, i));
                engine.AddObject(currBlock3);
                GiftBlock currBlock4 = new GiftBlock(new MatrixCoords(startRow + 3, i));
                engine.AddObject(currBlock4);

            }

            for (int i = startCol - 1; i <= endCol; i++)
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(startRow, i));
                engine.AddObject(currBlock);
            }

            for (int i = startRow; i <= WorldRows; i++)
            {
                IndestructibleBlock currBlock1 = new IndestructibleBlock(new MatrixCoords(i, startCol - 1));
                IndestructibleBlock currBlock2 = new IndestructibleBlock(new MatrixCoords(i, endCol      ));
                engine.AddObject(currBlock1);
                engine.AddObject(currBlock2);
            }

            //MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));


            engine.AddObject(theBall);

            Gift gift = new Gift(new MatrixCoords(8, 20));
            engine.AddObject(gift);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                ExplodingBlock expBlock = new ExplodingBlock(new MatrixCoords(startRow + 2,i));
                Block someMoreBlock = new Block(new MatrixCoords(startRow + 1, i));
                engine.AddObject(currBlock);
                engine.AddObject(expBlock);
                engine.AddObject(someMoreBlock);
            }

            MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1),3);

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //add sides
            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock leftIndestructibleBlock = new IndestructibleBlock(new MatrixCoords(row,0));
                engine.AddObject(leftIndestructibleBlock);
                IndestructibleBlock rightIndestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols-1));
                engine.AddObject(rightIndestructibleBlock);
            }
            //add roof
            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock topIndestructibleBlock = new IndestructibleBlock(new MatrixCoords(0,col));
                engine.AddObject(topIndestructibleBlock);
            }

            Gift gift = new Gift(new MatrixCoords(0,10));
            engine.AddObject(gift);

            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(7,33));
            engine.AddObject(giftBlock);
        }
Example #19
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            //task one
            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock ceilBlock = new IndestructibleBlock(new MatrixCoords(0, i));

                engine.AddObject(ceilBlock);
            }

            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock leftBlock = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock rightBlock = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(leftBlock);
                engine.AddObject(rightBlock);
            }
            //

            //nineth task
            //tenth task
            //twelfth task
            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            //seventh task
            //nineth task
            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            //thirdteenth task
            ShootingRacket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                
                // task 10
                if (i == 7)
                {
                    currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                }

                //task 12
                else if (i == endCol - 3)
                {
                    currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                }

                engine.AddObject(currBlock);
            }

            /* 07. Test the MeteoriteBall by replacing the normal ball in the AcademyPopcornMain.cs file.*/
            /* Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            */
            Ball theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2 + 1, 0), new MatrixCoords(-1, 1));
            engine.AddObject(theBall);

            // 09. Test the UnpassableBlock and the UnstoppableBall by adding them to the engine in AcademyPopcornMain.cs file
           /* Ball theUnstopableBall = new UnstopableBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            engine.AddObject(theUnstopableBall);

            for (int i = 2; i < WorldCols / 2; i += 4)
            {
                engine.AddObject(new UnpassableBlocks(new MatrixCoords(4, i)));
            }
            */
            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                //ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow + 1, i));
                // engine.AddObject(currBlock);
                engine.AddObject(giftBlock);
            }
            // upper wall
            for (int col = 0; col < WorldCols; col++)
            {
                UnpassableBlocks block = new UnpassableBlocks(new MatrixCoords(0, col));
                engine.AddObject(block);
            }

            // left and right wall
            for (int row = 1; row < WorldRows; row++)
            {
                UnpassableBlocks leftblock  = new UnpassableBlocks(new MatrixCoords(row, 0));
                UnpassableBlocks rIghtblock = new UnpassableBlocks(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(leftblock);
                engine.AddObject(rIghtblock);
            }

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                          new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket  = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            Racket theRacket1 = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength + 3);

            engine.AddObject(theRacket);
            engine.AddObject(theRacket1);
            //    Gift gift = new Gift(new MatrixCoords(0, 5));
            //    engine.AddObject(gift);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;
            
            for (int i = startCol; i < endCol; i++)
            {
                //ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow + 1, i));
                // engine.AddObject(currBlock);
                engine.AddObject(giftBlock);
            }
            // upper wall
            for (int col = 0; col < WorldCols; col++)
            {
                UnpassableBlocks block = new UnpassableBlocks(new MatrixCoords(0, col));
                engine.AddObject(block);
            }

            // left and right wall 
            for (int row = 1; row < WorldRows; row++)
            {
                UnpassableBlocks leftblock = new UnpassableBlocks(new MatrixCoords(row, 0));
                UnpassableBlocks rIghtblock = new UnpassableBlocks(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(leftblock);
                engine.AddObject(rIghtblock);
            }

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            Racket theRacket1 = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength + 3);
            engine.AddObject(theRacket);
            engine.AddObject(theRacket1);
            //    Gift gift = new Gift(new MatrixCoords(0, 5));
            //    engine.AddObject(gift);
        }
Example #23
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            //The AcademyPopcorn class contains an IndestructibleBlock class. Use it to create side and ceiling walls to the game. You can ONLY edit the AcademyPopcornMain.cs file
            IndestructibleBlock indestructibleBlock = null;

            for (int row = 0; row < WorldRows; row++)
            {
                for (int col = 0; col < WorldCols; col++)
                {
                    if (row == 0)
                    {
                        indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                        engine.AddObject(indestructibleBlock);
                    }
                    else if (col == 0 || col == WorldCols - 1)
                    {
                        indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                        engine.AddObject(indestructibleBlock);
                    }
                }
            }

            for (int i = startCol; i < endCol; i++)
            {
                switch (i % 5)
                {
                case 0:
                    ExplodingBlock explodingBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                    engine.AddObject(explodingBlock);
                    break;

                default:
                    switch (i % 3)
                    {
                    case 0:
                        GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow, i));
                        engine.AddObject(giftBlock);
                        break;

                    default:
                        Block currBlock = new Block(new MatrixCoords(startRow, i));
                        engine.AddObject(currBlock);
                        break;
                    }
                    break;
                }
            }

            for (int i = 4; i < endCol; i += 3)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(8, i));

                engine.AddObject(currBlock);
            }

            TrailObject to = new TrailObject(new MatrixCoords(5, 6), 15);

            engine.AddObject(to);

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                          new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            ShootingRacket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
Example #24
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                                    new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            // Exercise 1 - add side walls and ceiling wall
            for (int col = 0; col < WorldCols; col++)
            {
                Block indestructibleBlock = new IndestructibleBlock(new MatrixCoords(0, col));

                engine.AddObject(indestructibleBlock);
            }

            for (int row = 0; row < WorldRows; row++)
            {
                Block indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, 0));

                engine.AddObject(indestructibleBlock);

                indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));

                engine.AddObject(indestructibleBlock);
            }

            // Exercise 5 - TrailObject test
            //TrailObject trailObject = new TrailObject(new MatrixCoords(10, 15), LifeTime);
            //engine.AddObject(trailObject);

            // Exercise 7 - Replace the normal ball with a meteorite ball
            //Ball meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1), TrailLifeTime);

            //engine.AddObject(meteoriteBall);

            // Exercise 9 - Test the UnstoppableBall and the UnpassableBlock
            //for (int i = startCol; i < endCol / 2; i++)
            //{
            //    Block currBlock = new UnpassableBlock(new MatrixCoords(startRow + 1, i));

            //    engine.AddObject(currBlock);
            //}

            //Ball ustoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //engine.AddObject(ustoppableBall);

            // Exercise 10 - Test the Explosion and the ExplosionBlock
            //Block explosionBlock = new ExplosionBlock(new MatrixCoords(startRow + 1, 7));
            //engine.AddObject(explosionBlock);

            //for (int i = endCol / 2; i < endCol; i++)
            //{
            //    Block expBlock = new ExplosionBlock(new MatrixCoords(startRow + 1, i));
            //    engine.AddObject(expBlock);
            //}

            // Exercise 12 - Test the GiftBlock and the Gift
            //for (int i = startCol; i < endCol; i++)
            //{
            //    Block giftBlock = new GiftBlock(new MatrixCoords(startRow + 1, i));

            //    engine.AddObject(giftBlock);
            //}

            // Exercise 13 - Shooting racket test
            for (int i = startCol; i < endCol; i++)
            {
                Block giftBlock = new GiftBlock(new MatrixCoords(startRow + 1, i));

                engine.AddObject(giftBlock);
            }

            Racket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock0 = new Block(new MatrixCoords(startRow-1, i));
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
                engine.AddObject(currBlock0);
            }

               //ExplodingBlock makes trails
             ExplodingBlock explodingBlock = new ExplodingBlock(new MatrixCoords(4,7));
             engine.AddObject(explodingBlock);

            //Ordinary ball
            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(theBall);

            //Meteorite Ball makes trails when it moves
            //MeteoriteBall meteroitBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            // engine.AddObject(meteroitBall);

            //Unstoppable Ball, can be stopped only by Unpassable Block
            UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            engine.AddObject(unstoppableBall);

            //Falling gift
            Gift giftObject = new Gift(new MatrixCoords(5, 15),
                new MatrixCoords(-1, 0));

            engine.AddObject(giftObject);

            //Gift Block
            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(10, 10));
            engine.AddObject(giftBlock);

            //UnpassableBlock
            UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(15, 15));
            engine.AddObject(unpassableBlock);
            UnpassableBlock unpassableBlock1 = new UnpassableBlock(new MatrixCoords(15, 16));
            engine.AddObject(unpassableBlock1);
            UnpassableBlock unpassableBlock2 = new UnpassableBlock(new MatrixCoords(15, 17));
            engine.AddObject(unpassableBlock2);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

               //Creating second Racket
               //When you add second racket by addObject method, it checks whether the game has already a racket
               //If it does, we are removing the previous, and adding the new one.
               //Racket secondRacket = new Racket(new MatrixCoords(WorldRows -10, WorldCols / 2), RacketLength);
               //engine.AddObject(secondRacket);

            TrailObject trailObject = new TrailObject(new MatrixCoords(1, 1), 20);

            engine.AddObject(trailObject);

            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock indestructibleBlockLeft = new IndestructibleBlock(new MatrixCoords(i,0));
                IndestructibleBlock indestructibleBlockRight = new IndestructibleBlock(new MatrixCoords(i, WorldCols-1));
                engine.AddObject(indestructibleBlockLeft);
                engine.AddObject(indestructibleBlockRight);
            }

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock indestructibleBlockCeiling = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(indestructibleBlockCeiling);
            }
        }
Example #26
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startRow; i < WorldRows; ++i)
            {
                IndestructibleBlock indestructibleBlockLeft  = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock indestructibleBlockRight = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(indestructibleBlockLeft);
                engine.AddObject(indestructibleBlockRight);
            }

            for (int i = 0; i < WorldCols; ++i)
            {
                IndestructibleBlock indestructibleBlockTop = new IndestructibleBlock(new MatrixCoords(startRow - 1, i));

                engine.AddObject(indestructibleBlockTop);
            }

            Random random = new Random();

            for (int row = 0; row < 3; ++row)
            {
                for (int i = startCol; i < endCol; i++)
                {
                    int   rand = random.Next(4);
                    Block currBlock;
                    if (rand == 0)
                    {
                        currBlock = new ExplodingBlock(new MatrixCoords(startRow + row, i));
                    }
                    else if (rand == 1)
                    {
                        currBlock = new GiftBlock(new MatrixCoords(startRow + row, i));
                    }
                    else if (rand == 2)
                    {
                        currBlock = new UnpassableBlock(new MatrixCoords(startRow + row, i));
                    }
                    else
                    {
                        currBlock = new Block(new MatrixCoords(startRow + row, i));
                    }
                    engine.AddObject(currBlock);
                }
            }

            MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, WorldCols / 2),
                                                      new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            ShootingRacket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            engine.AddObject(new TrailObject(new MatrixCoords(WorldRows - 1, 2), 5));
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                if (i == 7) // first hit is that brick
                {
                    currBlock = new ExplodeBlock(new MatrixCoords(startRow, i));
                }

                if (i == 17)  // adding gift object
                {
                    currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                }

                engine.AddObject(currBlock);
            }

            // Adding Unpassable Blocks
            for (int i = 10; i < 15; i++)
            {
                UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(5, i));
                engine.AddObject(unpassableBlock);
            }

            // Adding Unstoppable Ball
            //UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            //engine.AddObject(unstoppableBall);

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            engine.AddObject(theBall);

            //MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            //engine.AddObject(meteoriteBall);
            //engine.AddObject(meteoriteBall.Tail);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock leftWall = new IndestructibleBlock(new MatrixCoords(i, 0));
                engine.AddObject(leftWall);

                IndestructibleBlock rightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(rightWall);
            }

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(ceiling);
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < 10; i++) // Task 9 Test
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = 10; i < 20; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = 20; i < 30; i++) // Task 12 Test GiftBlock and Gift
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = 30; i < endCol; i++) // Task 10. Exploding Block test
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = 0; i < WorldRows; i++) // Task 1 Create walls
            {
                IndestructibleBlock leftWalls = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock rightWalls = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(leftWalls);
                engine.AddObject(rightWalls);
            }

            for (int i = 0; i < WorldCols; i++) // Task 1 Create ceiling
            {
                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, i));

                engine.AddObject(ceiling);
            }

            MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), // Task 7 Add Meteorite Ball
                new MatrixCoords(-1, 1));

            engine.AddObject(meteoriteBall);

            //UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0), // Task 9 Test Unstoppable ball
            //    new MatrixCoords(-1, 1));

            //engine.AddObject(unstoppableBall);

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            engine.AddObject(theBall);

            //Implement MetheoridBall
            //MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(meteoriteBall);

            //Implement UnstopableBall and UnpassableBlocks
            //UnstoppableBall theUnstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(theUnstoppableBall);

            for (int i = 0; i < WorldRows; i++)
            {
                UnpassableBlock LeftWall = new UnpassableBlock(new MatrixCoords(i, 0));
                UnpassableBlock RightWall = new UnpassableBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(LeftWall);
                engine.AddObject(RightWall);
            }
            for (int i = 1; i < WorldCols - 1; i++)
            {
                UnpassableBlock UppertWall = new UnpassableBlock(new MatrixCoords(0, i));
                engine.AddObject(UppertWall);
            }

            //Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            //engine.AddObject(theRacket);

            //Add indistructuble blocks
            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock LeftWall = new IndestructibleBlock(new MatrixCoords(i, 1));
                IndestructibleBlock RightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 2));
                engine.AddObject(LeftWall);
                engine.AddObject(RightWall);
            }
            for (int i = 2; i < WorldCols - 2; i++)
            {
                IndestructibleBlock UppertWall = new IndestructibleBlock(new MatrixCoords(1, i));
                engine.AddObject(UppertWall);
            }

            //Adding several explosion blocks
            for (int i = 7; i < WorldCols-2; i+=7)
            {
                ExplodingBlock explosion = new ExplodingBlock(new MatrixCoords(3, i));
                engine.AddObject(explosion);
            }

            //Add several gift blocks
            for (int i = 2; i < WorldCols - 2; i += 7)
            {
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(4, i));
                engine.AddObject(giftBlock);
            }

            //Add shooting rocket
            ShootingRacket shoot = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            engine.AddObject(shoot);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 1, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 2, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol / 3; i++)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow + 4, i));

                engine.AddObject(currBlock);
            }

            // Exploding blocks. Chain reaction :)
            for (int i = endCol / 2; i < endCol; i++)
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow + 3, i));

                engine.AddObject(currBlock);
            }

            //Gift testGift = new Gift(new MatrixCoords(10, 20));
            //engine.AddObject(testGift);

            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(7, 25));

            engine.AddObject(giftBlock);

            // TASK 1
            startCol = 0;
            endCol   = WorldRows - 1;

            for (int i = startRow; i < endCol; i++) // LEFT SIDE
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(i, startCol));

                engine.AddObject(currBlock);
            }

            startCol = WorldCols - 1;

            for (int i = startRow; i < endCol; i++) // RIGHT SIDE
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(i, startCol));

                engine.AddObject(currBlock);
            }

            startRow = 2;
            startCol = 0;
            endCol   = WorldCols;

            for (int i = startCol; i < endCol; i++) // CEILING
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // END TASK 1

            // Bellow the three balls are added to the engine
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                                    new MatrixCoords(-1, 1));

            MeteoriteBall theMeteoriteBall = new MeteoriteBall(new MatrixCoords(20, 9),
                                                               new MatrixCoords(-1, 1));

            UnstoppableBall theUnstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 25),
                                                                     new MatrixCoords(-1, 1));

            engine.AddObject(theBall);
            engine.AddObject(theMeteoriteBall);
            engine.AddObject(theUnstoppableBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);


            // Part of TASK 5
            //TrailObject trailObject = new TrailObject(new MatrixCoords(10, 20), 5);

            //engine.AddObject(trailObject);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //        Ball theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //new MatrixCoords(-1, 1));

            Ball theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
            new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock leftSide = new IndestructibleBlock(new MatrixCoords(row, 0));

                engine.AddObject(leftSide);

                IndestructibleBlock rightSide = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));

                engine.AddObject(rightSide);

            }

            for (int col = 1; col < WorldCols - 1; col++)
            {

                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, col));

                engine.AddObject(ceiling);
            }

            //TrailObject trailingObject = new TrailObject(new MatrixCoords(WorldRows / 2, WorldCols / 2), 10);

            UnpassableBlock unpassable = new UnpassableBlock(new MatrixCoords(WorldRows / 2, WorldCols / 2 ));

            engine.AddObject(unpassable);

            //ExplodingBlock exploadable = new ExplodingBlock(new MatrixCoords(4, 6));

            //engine.AddObject(exploadable);

            GiftBlock gift = new GiftBlock(new MatrixCoords(4, 6));

            engine.AddObject(gift);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // add a few gift blocks
            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow + 1, i));

                engine.AddObject(currBlock);
            }

            Ball ball = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(ball);

            // test the meteorite ball
            //MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //engine.AddObject(theBall);

            // test the unstoppable ball
            //UnstoppableBall unstoppable = new UnstoppableBall(new MatrixCoords(5, 5),
            //    new MatrixCoords(1, 1));

            //engine.AddObject(unstoppable);

            //Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            //engine.AddObject(theRacket);

            ShootingRacket shootingRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2));
            engine.AddObject(shootingRacket);

            // add left side
            int topMost = 2;
            int leftMost = 1;
            int sideHeight = 20;
            for (int i = topMost; i < sideHeight + topMost; i++)
            {
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(i, leftMost)));
            }

            // add ceiling
            int ceilingWidth = 39;
            for (int i = leftMost; i < ceilingWidth; i++)
            {
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(2, i)));
            }

            // add right side
            int rightMost = 38;
            for (int i = topMost; i < sideHeight + topMost; i++)
            {
                engine.AddObject(new IndestructibleBlock(new MatrixCoords(i, rightMost)));
            }

            // add exploding blocks
            topMost += 3;
            for (int i = topMost; i < sideHeight; i++)
            {
                engine.AddObject(new ExplodingBlock(new MatrixCoords(i, 25)));
            }

            // add gifts
            engine.AddObject(new Gift(new MatrixCoords(5, 5)));
            engine.AddObject(new Gift(new MatrixCoords(6, 9)));
            engine.AddObject(new Gift(new MatrixCoords(5, 14)));
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            /*for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }*/

            //Test  class GiftBlock and Gift - Homework Task 12  and  ExplodingBlock - HomeWork Task 10
            for (int i = startCol; i < endCol; i++)
            {
                if (i == 7)
                {
                    ExplodingBlock expBlock = new ExplodingBlock(new MatrixCoords(3, 7));
                    engine.AddObject(expBlock);
                    continue;
                }
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                engine.AddObject(currBlock);
            }

            //Ceiling wall - Homework Task 01
            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock currentBlock = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(currentBlock);
            }

            //Side walls - Homework Task 01
            for (int i = 1; i <= WorldRows; i++)
            {
                IndestructibleBlock currentBlockLeft = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock currentBlockRight = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(currentBlockLeft);
                engine.AddObject(currentBlockRight);
            }

            /*Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));*/

            // test Meteorite Ball - Homework Task 07
            MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            /*  //test TrailObject - Homework Task 05
            TrailObject testObject = new TrailObject(new MatrixCoords(10, 10), new char[,] { { '@' } }, 5);
            engine.AddObject(testObject);*/

            /* //test Gift
            Gift testGift = new Gift(new MatrixCoords(WorldRows / 5, WorldCols / 5));
            engine.AddObject(testGift);*/
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i += 3) // row 3 will be full of unpassable blocks
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            startRow = 4;
            for (int i = startCol; i < endCol; i++) // row 4 will be full of blocks
            {
                if (i % 4 != 0)
                {
                    Block currBlock = new Block(new MatrixCoords(startRow, i));
                    engine.AddObject(currBlock);
                }
                else
                {
                    // but we will put  an Exploding Block on each 4-th position
                    ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                    engine.AddObject(currBlock);
                }
            }

            startRow = 6;
            for (int i = startCol; i < endCol; i += 6) // row 6 will have gift blocks on each 6-th position
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow, i));
                engine.AddObject(currBlock);
            }
            // Task 5: test TrailObject
            //TrailObject tr = new TrailObject(new MatrixCoords(WorldRows / 2, WorldCols / 2));
            //engine.AddObject(tr);

            // Task 7: test MeteoriteBall
            // MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            // Task 9: test Unstoppable Ball and Unpassable Block
            //UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // adds top row wall (ceiling)
            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock wallCell = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(wallCell);
            }

            // adds left and right walls)
            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock wallCell = new IndestructibleBlock(new MatrixCoords(i, 0));
                engine.AddObject(wallCell);
                wallCell = new IndestructibleBlock(new MatrixCoords(i, WorldCols-1));
                engine.AddObject(wallCell);
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            #region Add Indestructible Blocks as ball delimeters

            for (int row = 0; row < WorldRows; row++)
            {
                for (int col = 0; col < WorldCols; col++)
                {
                    IndestructibleBlock currBlock = null;
                    if (row == 0)
                    {
                        currBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                        engine.AddObject(currBlock);
                    }
                    else
                    {
                        if (col == 0 || col == WorldCols - 1)
                        {
                            currBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                            engine.AddObject(currBlock);
                        }
                    }

                }
            }
            #endregion

            #region Add TrailObject

            //TrailObject trailObject = new TrailObject(new MatrixCoords(WorldRows, WorldCols),
            //                                          new char[,] { { '°' } }, 5);
            //engine.AddObject(trailObject);

            #endregion

            #region Add Blocks

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                Block currBlock2 = new Block(new MatrixCoords(startRow + 1, i));
                engine.AddObject(currBlock);
                engine.AddObject(currBlock2);
            }
            #endregion

            #region Add unpassable Blocks

            //for (int i = startCol; i < endCol; i = i + 4)
            //{
            //    UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(startRow + 5, i));

            //    engine.AddObject(unpassableBlock);
            //}
            for (int i = startCol; i < endCol; i = i + 3)
            {
                UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(WorldRows - 8, i));

                engine.AddObject(unpassableBlock);
            }
            #endregion

            #region Add exploding Blocks

            for (int i = startCol; i < endCol; i = i + 1)
            {
                ExplodingBlock expoldingBlock = new ExplodingBlock(new MatrixCoords(startRow + 2, i));

                engine.AddObject(expoldingBlock);
            }
            #endregion

            #region Add gift Blocks

            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow + 3, i));

                engine.AddObject(giftBlock);
            }
            #endregion

            #region Add Meteorite Ball

            MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            #endregion

            #region Add unstoppableBall Ball

            UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            #endregion

            #region Add Ball

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));
            #endregion

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            //ordinary ball
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 3, 0),
                new MatrixCoords(-1, 1));
            //engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2 - 3), RacketLength);

            engine.AddObject(theRacket);

            /*1.The AcademyPopcorn class contains an IndestructibleBlock class. Use it to create side and ceiling walls to the game.
             You can ONLY edit the AcademyPopcornMain.cs file.*/
            for (int row = startRow - 1; row < WorldRows; row++)
            {
                IndestructibleBlock leftWallBlock = new IndestructibleBlock(new MatrixCoords(row, startCol - 1),
                    IndestructibleBlock.SymbolWall);
                engine.AddObject(leftWallBlock);
                IndestructibleBlock rightWallBlock = new IndestructibleBlock(new MatrixCoords(row, endCol),
                    IndestructibleBlock.SymbolWall);
                engine.AddObject(rightWallBlock);
            }
            //create ceiling (using symbolTop = "_")
            for (int col = startCol - 1; col < WorldCols - 1; col++)
            {
                IndestructibleBlock topWallBlock = new IndestructibleBlock(new MatrixCoords(1, col),
                    IndestructibleBlock.SymbolTop);
                engine.AddObject(topWallBlock);
            }

            TrailObject comet = new TrailObject(new MatrixCoords(WorldRows / 2, WorldCols / 4), new char[,] { { '*' } }, 8);
            engine.AddObject(comet);

            //7.Test the MeteoriteBall by replacing the normal ball in the AcademyPopcornMain.cs file.
            MeteoriteBall metBall = new MeteoriteBall(new MatrixCoords(WorldRows / 3, 0),
                new MatrixCoords(-1, 1), 3);
            //engine.AddObject(metBall);

            //9.Test the UnpassableBlock and the UnstoppableBall by adding them to the engine in AcademyPopcornMain.cs file
            UnstoppableBall unstopBall = new UnstoppableBall(new MatrixCoords(WorldRows / 3, 0), new MatrixCoords(-1, 1));
            engine.AddObject(unstopBall);

            for (int i = 3; i < WorldCols - 2; i = i + 2)
            {
                UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(4, i), 'U');
                engine.AddObject(unpassableBlock);
            }

            for (int i = 2; i < WorldCols; i = i + 2)
            {
              ExplodingBlock bombBlock = new ExplodingBlock(new MatrixCoords(4, i), 'B');
              engine.AddObject(bombBlock);
            }

            for (int i = 2; i < WorldCols; i = i + 2)
            {
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(5, i), 'G');
                engine.AddObject(giftBlock);
            }
        }
Example #37
0
        public void Initialize(Engine engine)
        {
            // Initialize ceiling
            for (int i = wallStartRow; i < WorldCols; i++)
            {
                Block ceiling = new IndestructibleBlock(new MatrixCoords(wallStartRow, i));
                engine.AddObject(ceiling);
            }

            // Initialize indestructible walls
            for (int i = wallStartRow + 1; i < WorldRows; i++)
            {
                Block leftWallBlock  = new IndestructibleBlock(new MatrixCoords(i, 0));
                Block rightWallBlock = new IndestructibleBlock(new MatrixCoords(i, GetCols - 1));
                engine.AddObject(leftWallBlock);
                engine.AddObject(rightWallBlock);
            }

            // Initialize exploding Blocks
            for (int i = startCol; i < endCol; i++)
            {
                if (i % 7 == 0)
                {
                    Block explBlock = new ExplodingBlock(new MatrixCoords(startRow + 1, i));
                    engine.AddObject(explBlock);
                }
            }

            // Initialize Unpassable Blocks
            for (int i = startCol; i < endCol; i++)
            {
                if (i % 5 == 0)
                {
                    Block unpassableBlock = new UnpassableBlock(new MatrixCoords(WorldRows / 2, i));
                    engine.AddObject(unpassableBlock);
                }
            }

            // Initialize Gift Blocks
            for (int i = startCol; i < endCol; i++)
            {
                if (i % 8 == 0)
                {
                    Block currBlock = new GiftBlock(new MatrixCoords(startRow - 1, i));
                    engine.AddObject(currBlock);
                }
            }

            // Original Blocks
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                engine.AddObject(currBlock);
            }

            // Original Ball

            //ball theball = new ball(new matrixcoords(worldrows / 2, 0),
            //new matrixcoords(-1, 1));

            //engine.addobject(theball);

            // Meteorite Ball Test

            //Ball theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(theBall);


            // Unstoppable Ball Test

            Ball theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                               new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, GetCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            //1. The AcademyPopcorn class contains an IndestructibleBlock class.
            //Use it to create side and ceiling walls to the game.
            //You can ONLY edit the AcademyPopcornMain.cs file.

            //LeftWall
            for (int i = 0; i < endCol; i++)
            {
                IndestructibleBlock leftWall = new IndestructibleBlock(new MatrixCoords(i, 0));

                engine.AddObject(leftWall);
            }

            //RightWall
            for (int i = 0; i < endCol; i++)
            {
                IndestructibleBlock rightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));

                engine.AddObject(rightWall);
            }

            //Ceiling
            for (int i = 1; i < WorldCols - 1; i++)
            {
                IndestructibleBlock rightWall = new IndestructibleBlock(new MatrixCoords(0, i));

                engine.AddObject(rightWall);
            }

            //10. Testing the exploding block.
            for (int i = startCol; i < endCol; i++)
            {
                //if (i == 7)
                //{
                //    ExplodingBlock boomBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                //
                //    engine.AddObject(boomBlock);
                //}
                //else
                //{
                    Block currBlock = new Block(new MatrixCoords(startRow, i));

                    engine.AddObject(currBlock);
                //}
            }

            //12. Testing Gift and GiftBlock
            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow + 5, i));

                engine.AddObject(currBlock);
            }

            //7. Test the MeteoriteBall by replacing the normal ball in the AcademyPopcornMain.cs file.
            //MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //
            //engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //5. Testing TrailObject
            //TrailObject trail = new TrailObject(new MatrixCoords(10, 10), 5);
            //
            //engine.AddObject(trail);

            //9. Test the UnpassableBlock and the UnstopableBall by adding them to the engine in AcademyPopcornMain.cs file.
            //for (int i = 5; i < 20; i++)
            //{
            //    UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(8, i));
            //
            //    engine.AddObject(unpassableBlock);
            //}
            //
            //UnstopableBall theBall = new UnstopableBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //
            //engine.AddObject(theBall);

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);
        }
Example #39
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i += 2)
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow + 1, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow + 2, i), new char[, ] {
                    { '%' }
                });

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 4, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol + 5; i < endCol - 5; i++)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow + 3, i));

                engine.AddObject(currBlock);
            }

            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock newIndestructubleBlock = new IndestructibleBlock(new MatrixCoords(i, 0), '║');
                engine.AddObject(newIndestructubleBlock);
                newIndestructubleBlock = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1), '║');
                engine.AddObject(newIndestructubleBlock);
            }
            for (int i = 1; i < WorldCols - 1; i++)
            {
                IndestructibleBlock newIndestructubleBlock = new IndestructibleBlock(new MatrixCoords(0, i), '═');
                engine.AddObject(newIndestructubleBlock);
                newIndestructubleBlock = new IndestructibleBlock(new MatrixCoords(WorldRows - 1, i), '_');
                engine.AddObject(newIndestructubleBlock);
            }

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                          new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            // standart blocks

            #region Standart Blocks

            for (int row = 2; row < 5; row++)
            {
                for (int col = startCol; col < endCol; col++)
                {
                    Block standartBlock = new Block(new MatrixCoords(row, col));
                    engine.AddObject(standartBlock);
                }
            }

            #endregion

            #region GameField Walls

            for (int row = 0; row < WorldRows - 2; row++)
            {
                IndestructibleBlock leftWallBlock  = new IndestructibleBlock(new MatrixCoords(row + 2, startCol - 2));
                IndestructibleBlock rightWallBlock = new IndestructibleBlock(new MatrixCoords(row + 2, endCol + 1));
                engine.AddObject(rightWallBlock);
                engine.AddObject(leftWallBlock);
            }

            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock topWallBlock = new IndestructibleBlock(new MatrixCoords(startRow - 2, col));
                engine.AddObject(topWallBlock);
            }

            #endregion

            #region Impassable Blocks

            for (int col = 1; col < WorldCols - 1; col++)
            {
                //if (col == 1 || col == 2) continue;
                ImpassableBlock imBlock = new ImpassableBlock(new MatrixCoords(11, col));
                engine.AddObject(imBlock);
            }

            #endregion

            #region Explosion Blocks

            for (int col = 2; col < WorldCols - 1; col += 1)
            {
                ExplodingBlock expBlock = new ExplodingBlock(new MatrixCoords(5, col));
                engine.AddObject(expBlock);
            }

            #endregion

            #region Gift Blocks

            for (int col = 1; col < WorldCols - 1; col += 5)
            {
                GiftBlock giftBlocks = new GiftBlock(new MatrixCoords(6, col));
                engine.AddObject(giftBlocks);
            }

            #endregion

            Ball theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
                                             new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 1, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 2, i));

                engine.AddObject(currBlock);
            }
            for (int i = startCol; i < endCol / 3; i++)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(startRow + 4, i));

                engine.AddObject(currBlock);
            }

            // Exploding blocks. Chain reaction :)
            for (int i = endCol/2; i < endCol; i++)
            {
                ExplodingBlock currBlock = new ExplodingBlock(new MatrixCoords(startRow + 3, i));

                engine.AddObject(currBlock);
            }

            //Gift testGift = new Gift(new MatrixCoords(10, 20));
            //engine.AddObject(testGift);

            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(7, 25));
            engine.AddObject(giftBlock);

            // TASK 1
            startCol = 0;
            endCol = WorldRows - 1;

            for (int i = startRow; i < endCol; i++) // LEFT SIDE
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(i, startCol));

                engine.AddObject(currBlock);
            }

            startCol = WorldCols - 1;

            for (int i = startRow; i < endCol; i++) // RIGHT SIDE
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(i, startCol));

                engine.AddObject(currBlock);
            }

            startRow = 2;
            startCol = 0;
            endCol = WorldCols;

            for (int i = startCol; i < endCol; i++) // CEILING
            {
                IndestructibleBlock currBlock = new IndestructibleBlock(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            // END TASK 1

            // Bellow the three balls are added to the engine
            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            MeteoriteBall theMeteoriteBall = new MeteoriteBall(new MatrixCoords(20, 9),
                new MatrixCoords(-1, 1));

            UnstoppableBall theUnstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 25),
               new MatrixCoords(-1, 1));

            engine.AddObject(theBall);
            engine.AddObject(theMeteoriteBall);
            engine.AddObject(theUnstoppableBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // Part of TASK 5
            //TrailObject trailObject = new TrailObject(new MatrixCoords(10, 20), 5);

            //engine.AddObject(trailObject);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            //The AcademyPopcorn class contains an IndestructibleBlock class. Use it to create side and ceiling walls to the game. You can ONLY edit the AcademyPopcornMain.cs file
            IndestructibleBlock indestructibleBlock = null;
            for (int row = 0; row < WorldRows; row++)
            {
                for (int col = 0; col < WorldCols; col++)
                {
                    if (row == 0)
                    {
                        indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                        engine.AddObject(indestructibleBlock);
                    }
                    else if (col == 0 || col == WorldCols - 1)
                    {
                        indestructibleBlock = new IndestructibleBlock(new MatrixCoords(row, col));
                        engine.AddObject(indestructibleBlock);
                    }
                }
            }

            for (int i = startCol; i < endCol; i++)
            {
                switch (i % 5)
                {
                    case 0:
                        ExplodingBlock explodingBlock = new ExplodingBlock(new MatrixCoords(startRow, i));
                        engine.AddObject(explodingBlock);
                        break;
                    default:
                        switch (i % 3)
                        {
                            case 0:
                                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(startRow, i));
                                engine.AddObject(giftBlock);
                                break;
                            default:
                                Block currBlock = new Block(new MatrixCoords(startRow, i));
                                engine.AddObject(currBlock);
                                break;
                        }
                        break;
                }

            }

            for (int i = 4; i < endCol; i+=3)
            {
                UnpassableBlock currBlock = new UnpassableBlock(new MatrixCoords(8, i));

                engine.AddObject(currBlock);
            }

            TrailObject to = new TrailObject(new MatrixCoords(5, 6), 15);
            engine.AddObject(to);

            UnstoppableBall theBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            ShootingRacket theRacket = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            for (int i = startCol - 1; i < endCol + 1; i++)
            {
                IndestructibleBlock wallBlock = new IndestructibleBlock(new MatrixCoords(startRow - 1, i));
                engine.AddObject(wallBlock);
            }
            for (int i = startRow; i < WorldRows; i++)
            {
                IndestructibleBlock wallBlock = new IndestructibleBlock(new MatrixCoords(i, startCol - 1));
                IndestructibleBlock wallBlock2 = new IndestructibleBlock(new MatrixCoords(i, endCol));
                engine.AddObject(wallBlock);
                engine.AddObject(wallBlock2);
            }

            //create a row of GiftBlocks
            for (int i = startCol; i < endCol; i++)
            {
                GiftBlock currBlock = new GiftBlock(new MatrixCoords(startRow+4, i));

                engine.AddObject(currBlock);
            }

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //replace the normal ball with Meteorite ball
            //MeteoriteBall theMeteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            //engine.AddObject(theMeteoriteBall);

            //replace the MeteroriteBall with Unstoppable Ball
            Ball theUnstopableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));
            engine.AddObject(theUnstopableBall);

            //put some unpassable blocks
            for (int i = 2; i < WorldCols; i += 5)
            {
                engine.AddObject(new UnpassableBlock(new MatrixCoords(4, i)));
            }

            //create a sample Gift for testing
            Gift gift = new Gift(new MatrixCoords(1, WorldCols / 2));

            engine.AddObject(gift);
            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            TrailObject newTestTrailObject = new TrailObject(new MatrixCoords(startRow  + 10, startCol + 10), new char[,] { { 'V' } }, 20);
            engine.AddObject(newTestTrailObject);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));
                engine.AddObject(currBlock);
            }
            //10
            ExplodingBlock exBlock = new ExplodingBlock(new MatrixCoords(4, 30));

            engine.AddObject(exBlock);
            //END 10

            //01.The AcademyPopcorn class contains an IndestructibleBlock class.
            //Use it to create side and ceiling walls to the game. You can ONLY edit the
            //AcademyPopcornMain.cs file.

            for (int row = 0; row < 40; row++)
            {
                IndestructibleBlock leftSideBlock  = new IndestructibleBlock(new MatrixCoords(row, 0));
                IndestructibleBlock rightSideBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(leftSideBlock);
                engine.AddObject(rightSideBlock);
            }

            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock ceilingBlock = new IndestructibleBlock(new MatrixCoords(0, col));
                engine.AddObject(ceilingBlock);
            }
            //END 01

            //05
            TrailObject trailObj = new TrailObject(new MatrixCoords(8, 8), 8);
            //engine.AddObject(trailObj);
            //END 05

            //07.Test the MeteoriteBall by replacing the normal ball in the AcademyPopcornMain.cs file.
            MeteoriteBall metBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(metBall);
            //END 07

            //09
            ImpassableBlock imPassBlock = new ImpassableBlock(new MatrixCoords(4, 7));

            engine.AddObject(imPassBlock);
            UnstoppableBall unstopBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                             new MatrixCoords(-1, 1));
            //engine.AddObject(unstopBall);
            //END 09

            //12
            GiftBlock gift = new GiftBlock(new MatrixCoords(7, 25));

            engine.AddObject(gift);
            //END 12

            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));

            //engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow + 3, i));

                engine.AddObject(currBlock);

                Block otherBlock = new Block(new MatrixCoords(19, i));

                engine.AddObject(otherBlock);

                if (i > 19 && i < 30)
                {
                    // add unpassableBlocks
                    UnpassableBlock currUnpassableBlock = new UnpassableBlock(new MatrixCoords(18, i + 1));

                    engine.AddObject(currUnpassableBlock);
                }
            }

            // add GiftBlock
            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(8, 15));

            engine.AddObject(giftBlock);

            // add explodingBlock
            ExplodingBlock explodingBlock  = new ExplodingBlock(new MatrixCoords(startRow + 4, startCol + 1));
            ExplodingBlock explodingBlock1 = new ExplodingBlock(new MatrixCoords(startRow + 14, startCol + 19));

            engine.AddObject(explodingBlock);
            engine.AddObject(explodingBlock1);

            // add disapiared object
            TrailObject trailObject = new TrailObject(new MatrixCoords(17, 5), new char[, ] {
                { 'X', 'X', 'X' }
            }, 100);

            engine.AddObject(trailObject);

            for (int row = startRow - 1; row < WorldRows; row++)
            {
                IndestructibleBlock leftWallBlock  = new IndestructibleBlock(new MatrixCoords(row, 0));
                IndestructibleBlock rightWallBlock = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));

                engine.AddObject(leftWallBlock);
                engine.AddObject(rightWallBlock);
            }

            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock upWallBlock = new IndestructibleBlock(new MatrixCoords(1, col));

                engine.AddObject(upWallBlock);
            }

            // change ball
            MeteoriteBall theBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0), new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // test we should remove the previous racket from this.allObjects
            //engine.AddObject(theRacket);
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
                                    new MatrixCoords(-1, 1));

            engine.AddObject(theBall);


            //Implement MetheoridBall
            //MeteoriteBall meteoriteBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(meteoriteBall);


            //Implement UnstopableBall and UnpassableBlocks
            //UnstoppableBall theUnstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(theUnstoppableBall);

            for (int i = 0; i < WorldRows; i++)
            {
                UnpassableBlock LeftWall  = new UnpassableBlock(new MatrixCoords(i, 0));
                UnpassableBlock RightWall = new UnpassableBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(LeftWall);
                engine.AddObject(RightWall);
            }
            for (int i = 1; i < WorldCols - 1; i++)
            {
                UnpassableBlock UppertWall = new UnpassableBlock(new MatrixCoords(0, i));
                engine.AddObject(UppertWall);
            }

            //Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);
            //engine.AddObject(theRacket);

            //Add indistructuble blocks
            for (int i = 1; i < WorldRows; i++)
            {
                IndestructibleBlock LeftWall  = new IndestructibleBlock(new MatrixCoords(i, 1));
                IndestructibleBlock RightWall = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 2));
                engine.AddObject(LeftWall);
                engine.AddObject(RightWall);
            }
            for (int i = 2; i < WorldCols - 2; i++)
            {
                IndestructibleBlock UppertWall = new IndestructibleBlock(new MatrixCoords(1, i));
                engine.AddObject(UppertWall);
            }

            //Adding several explosion blocks
            for (int i = 7; i < WorldCols - 2; i += 7)
            {
                ExplodingBlock explosion = new ExplodingBlock(new MatrixCoords(3, i));
                engine.AddObject(explosion);
            }

            //Add several gift blocks
            for (int i = 2; i < WorldCols - 2; i += 7)
            {
                GiftBlock giftBlock = new GiftBlock(new MatrixCoords(4, i));
                engine.AddObject(giftBlock);
            }

            //Add shooting rocket
            ShootingRacket shoot = new ShootingRacket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(shoot);
        }
Example #47
0
        // Drawing all objects
        static void Initialize(Engine engine)
        {
            // Wall coordinates
            for (int col = 0; col < WorldCols; col += WallGap)
            {
                if (col > WorldCols / 3 && col < 2 * WorldCols / 3) col += WallGap;
                for (int width = col; width < col + WallWidth; width++)
                {
                    for (int row = 0; row <= ((col != 0 && col < WorldCols - WallGap) ? WorldRows - 1 : WorldRows); row++)
                    {
                        if (col != 0 && col < WorldCols - WallGap && row == 2) row = 6;
                        if (col > WallGap && col < WorldCols - WallGap && row == 17) row = 22;
                        IndestructibleBlock Wall = new IndestructibleBlock(new MatrixCoords(row, width));
                        engine.AddObject(Wall);
                    }
                }
            }

            // Ceiling coordinates
            for (int col = 0; col < WorldCols; col++)
            {
                IndestructibleBlock ceiling = new IndestructibleBlock(new MatrixCoords(0, col));
                engine.AddObject(ceiling);
            }

            // Floor coordinates
            for (int col = 0; col < WorldCols - 1; col++)
            {
                if (col == WallGap + WallWidth) col = 3 * WallGap;
                IndestructibleBlock floor = new IndestructibleBlock(new MatrixCoords(WorldRows - 1, col));
                engine.AddObject(floor);
            }

            // Block coordinates
            for (int row = 0; row < BlockLines; row++)
            {
                if (row == 2) row = 3;
                for (int col = WallGap + WallWidth + 1; col < 3 * WallGap - 1; col++)
                {
                    if (row == 4 && (col == 3 * WallGap / 2 || col == 5 * WallGap / 2)) col++;
                    Block currBlock = new Block(new MatrixCoords(StartBlockRow + row, col));
                    engine.AddObject(currBlock);
                }
            }

            for (int col = WallGap + WallWidth + 1; col < 3 * WallGap - 1; col++)
            {
                if (col == WallGap + 7) col = 3 * WallGap - 5;
                Block currBlock2 = new Block(new MatrixCoords(5, col));
                engine.AddObject(currBlock2);
            }

            for (int row = 0; row < WorldRows - 2 * BlockLines + 1; row += 3)
            {
                for (int col = WallWidth + 1; col < WorldCols - WallWidth - 1; col++)
                {
                    if (col == WallGap - 1) col = 3 * WallGap + WallWidth + 1;
                    Block currBlock = new Block(new MatrixCoords(StartBlockRow + row, col));
                    engine.AddObject(currBlock);
                }
            }

            for (int col = WallGap + WallWidth + 5; col < 3 * WallGap - 5; col++)
            {
                UnpassableBlock unpassBlock = new UnpassableBlock(new MatrixCoords(5, col));
                engine.AddObject(unpassBlock);
            }

            ExplodingBlock exploBlock1 = new ExplodingBlock(new MatrixCoords(7, 3 * WallGap / 2));
            engine.AddObject(exploBlock1);
            ExplodingBlock exploBlock2 = new ExplodingBlock(new MatrixCoords(7, 5 * WallGap / 2));
            engine.AddObject(exploBlock2);

            // Ball coordinates
            Ball theBall = new Ball(new MatrixCoords(2 * WorldRows / 3, WorldCols / 2 - 10), new MatrixCoords(-1, 1));
            engine.AddObject(theBall);

            // Meteorite ball coordinates
            MeteoriteBall meteoBall = new MeteoriteBall(new MatrixCoords(WorldRows - 1, 1), new MatrixCoords(-1, 1));
            engine.AddObject(meteoBall);

            MeteoriteBall meteoBall2 = new MeteoriteBall(new MatrixCoords(WorldRows - 1, 3), new MatrixCoords(-1, 1));
            engine.AddObject(meteoBall2);

            MeteoriteBall meteoBall3 = new MeteoriteBall(new MatrixCoords(WorldRows - 1, 7), new MatrixCoords(-1, 1));
            engine.AddObject(meteoBall3);

            // Unstoppable ball coordinates
            UnstoppableBall unstopBall = new UnstoppableBall(new MatrixCoords(WorldRows - 8, WorldCols - WallWidth - 3), new MatrixCoords(-1, -1));
            engine.AddObject(unstopBall);

            // Racket coordinates
            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, (WorldCols - RacketLength) / 2), RacketLength);
            engine.AddObject(theRacket);

            // Gift coordinates
            for (int col = WallGap + 3; col < 3 * WallGap - 1; col++)
            {
                GiftBlock gift = new GiftBlock(new MatrixCoords(1, col));
                engine.AddObject(gift);
            }
        }
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock0 = new Block(new MatrixCoords(startRow - 1, i));
                Block currBlock  = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
                engine.AddObject(currBlock0);
            }

            //ExplodingBlock makes trails
            ExplodingBlock explodingBlock = new ExplodingBlock(new MatrixCoords(4, 7));

            engine.AddObject(explodingBlock);

            //Ordinary ball
            //Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            //engine.AddObject(theBall);

            //Meteorite Ball makes trails when it moves
            //MeteoriteBall meteroitBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2, 0),
            //    new MatrixCoords(-1, 1));
            // engine.AddObject(meteroitBall);

            //Unstoppable Ball, can be stopped only by Unpassable Block
            UnstoppableBall unstoppableBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 0),
                                                                  new MatrixCoords(-1, 1));

            engine.AddObject(unstoppableBall);

            //Falling gift
            Gift giftObject = new Gift(new MatrixCoords(5, 15),
                                       new MatrixCoords(-1, 0));

            engine.AddObject(giftObject);

            //Gift Block
            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(10, 10));

            engine.AddObject(giftBlock);

            //UnpassableBlock
            UnpassableBlock unpassableBlock = new UnpassableBlock(new MatrixCoords(15, 15));

            engine.AddObject(unpassableBlock);
            UnpassableBlock unpassableBlock1 = new UnpassableBlock(new MatrixCoords(15, 16));

            engine.AddObject(unpassableBlock1);
            UnpassableBlock unpassableBlock2 = new UnpassableBlock(new MatrixCoords(15, 17));

            engine.AddObject(unpassableBlock2);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            //Creating second Racket
            //When you add second racket by addObject method, it checks whether the game has already a racket
            //If it does, we are removing the previous, and adding the new one.
            //Racket secondRacket = new Racket(new MatrixCoords(WorldRows -10, WorldCols / 2), RacketLength);
            //engine.AddObject(secondRacket);

            TrailObject trailObject = new TrailObject(new MatrixCoords(1, 1), 20);

            engine.AddObject(trailObject);

            for (int i = 0; i < WorldRows; i++)
            {
                IndestructibleBlock indestructibleBlockLeft  = new IndestructibleBlock(new MatrixCoords(i, 0));
                IndestructibleBlock indestructibleBlockRight = new IndestructibleBlock(new MatrixCoords(i, WorldCols - 1));
                engine.AddObject(indestructibleBlockLeft);
                engine.AddObject(indestructibleBlockRight);
            }

            for (int i = 0; i < WorldCols; i++)
            {
                IndestructibleBlock indestructibleBlockCeiling = new IndestructibleBlock(new MatrixCoords(0, i));
                engine.AddObject(indestructibleBlockCeiling);
            }
        }
Example #49
0
        static void Initialize(Engine engine)
        {
            int startRow = 3;
            int startCol = 2;
            int endCol   = WorldCols - 2;

            // "paint" blocks
            for (int i = startCol; i < endCol; i++)
            {
                Block currBlock = new Block(new MatrixCoords(startRow, i));

                engine.AddObject(currBlock);
            }

            Ball theBall = new Ball(new MatrixCoords(WorldRows / 2, 2),
                                    new MatrixCoords(-1, 1));

            engine.AddObject(theBall);

            //TrailObject trailObject = new TrailObject(new MatrixCoords(4, 4), 3);
            //engine.AddObject(trailObject);

            // Таск 7
            // Test the MeteoriteBall by replacing the normal ball in the AcademyPopcornMain.cs file.

            //MeteoriteBall mBall = new MeteoriteBall(new MatrixCoords(WorldRows / 2 + 1, 1), new MatrixCoords(-1, 1), 3);
            //engine.AddObject(mBall);

            // task 9
            // Test the UnpassableBlock and the UnstoppableBall by adding them
            // to the engine in AcademyPopcornMain.cs file

            UnstoppableBall unBall = new UnstoppableBall(new MatrixCoords(WorldRows / 2, 2),
                                                         new MatrixCoords(-1, 1));
            //engine.AddObject(unBall);

            // "paint" unpassable blocks
            //for (int i = startCol; i < endCol; i++)
            //{
            //    UnpassableBlock currBlockTwo = new UnpassableBlock(new MatrixCoords(startRow + 2, i));

            //    engine.AddObject(currBlockTwo);
            //}

            // task 10
            //for (int i = startCol; i < endCol; i++)
            //{
            //    ExplodingBlock exBlock = new ExplodingBlock(new MatrixCoords(startRow + 2, i));
            //    engine.AddObject(exBlock);
            //}

            // task 11
            Gift gift = new Gift(new MatrixCoords(7, 15), new MatrixCoords(1, 0));

            engine.AddObject(gift);

            // task 12
            GiftBlock giftBlock = new GiftBlock(new MatrixCoords(5, 8));

            engine.AddObject(giftBlock);

            Racket theRacket = new Racket(new MatrixCoords(WorldRows - 1, WorldCols / 2), RacketLength);

            engine.AddObject(theRacket);

            // task 1
            // The AcademyPopcorn class contains an IndestructibleBlock class.
            // Use it to create side and ceiling walls to the game.
            // You can ONLY edit the AcademyPopcornMain.cs file.
            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock borderBlockLeft = new IndestructibleBlock(new MatrixCoords(row, 0));
                engine.AddObject(borderBlockLeft);
            }

            for (int row = 0; row < WorldRows; row++)
            {
                IndestructibleBlock borderBlockRight = new IndestructibleBlock(new MatrixCoords(row, WorldCols - 1));
                engine.AddObject(borderBlockRight);
            }

            for (int coll = 0; coll < WorldCols; coll++)
            {
                IndestructibleBlock borderBlockRight = new IndestructibleBlock(new MatrixCoords(0, coll));
                engine.AddObject(borderBlockRight);
            }
        }