コード例 #1
0
        //Descobre a linha vertical que cruza por menos Bricks em uma BrickWall Ordenada
        public int FindOptimizedPath(BrickWall wall)
        {
            int maxNumberOfBricks = wall.Rows.Count;

            int maxSumOfOpen = 0;
            int sumOfOpen    = 0;

            for (int i = 1; i < maxNumberOfBricks; i++)
            {
                foreach (var el in wall.Rows)
                {
                    if (el.Bricks.BinarySearch(i) >= 0) //BinarySearch ao invés de Contains pois nosso array é ordenado
                    {
                        sumOfOpen++;
                    }
                }

                if (sumOfOpen > maxSumOfOpen)
                {
                    maxSumOfOpen = sumOfOpen;
                }

                sumOfOpen = 0;
            }

            return(maxNumberOfBricks - maxSumOfOpen);
        }
コード例 #2
0
ファイル: World.cs プロジェクト: umstek/Astute
        /// <summary>
        ///     Broadcast message can be any message received after the join message, in 1 second intervals.
        /// </summary>
        /// <param name="oldWorld">The current state of the world. </param>
        /// <param name="message">The BroadcastMessage received. </param>
        /// <returns>New world based on both the old world and the BroadcastMessage. </returns>
        private static World FromBroadcastMessage(World oldWorld, BroadcastMessage message)
        {
            var brickWalls = message.DamagesDetails.Select(details =>
            {
                var oldBrickWall = oldWorld.GridItems[details.Location.X, details.Location.Y] as BrickWall;
                // Assumption: BrickWall is the only thing which gets damaged.
                Debug.Assert(oldBrickWall != null);
                Trace.Assert(oldBrickWall != null);
                var newBrickWall = new BrickWall(oldBrickWall.Health, oldBrickWall.Location);
                return(newBrickWall);
            }).ToArray();

            var tanks = message.PlayersDetails
                        .Select(details =>
                                new Tank(
                                    details.Location,
                                    details.Health,
                                    details.FacingDirection,
                                    details.Points,
                                    details.Coins,
                                    details.PlayerNumber,
                                    details.IsShot,
                                    details.PlayerNumber == oldWorld.PlayerNumber
                                    )
                                ).ToArray();

            return(new World(oldWorld.PlayerNumber)
            {
                BrickWalls = new HashSet <BrickWall>(brickWalls),
                StoneWalls = oldWorld.StoneWalls,
                Waters = oldWorld.Waters,
                Tanks = new HashSet <Tank>(tanks),

                // Acts as a clock for TimeVarient items.
                // TODO Check accuracy of this calculation ( < 1 thing).
                // TODO Confirm that we don't need an actual clock for this.
                // TODO Identify what the server sends (does it actually sends time to disappear?).
                Coinpacks =
                    new HashSet <Coinpack>(
                        oldWorld.Coinpacks
                        .Where(coinpack => coinpack.TimeToDisappear > 1)     // ?
                        .Where(coinpack => !tanks.Select(tank => tank.Location).Contains(coinpack.Location))
                        .Select(coinpack =>
                                new Coinpack(coinpack.Location, coinpack.CoinValue, coinpack.TimeToDisappear - 1)
                                )
                        ),
                Lifepacks =
                    new HashSet <Lifepack>(
                        oldWorld.Lifepacks
                        .Where(lifepack => lifepack.TimeToDisappear > 1)     // ?
                        .Where(lifepack => !tanks.Select(tank => tank.Location).Contains(lifepack.Location))
                        .Select(lifepack =>
                                new Lifepack(lifepack.Location, lifepack.HealthValue, lifepack.TimeToDisappear - 1)
                                )
                        )
            });
        }
コード例 #3
0
        //Retorna a menor quantidade de Bricks que uma linha vertical pode atingir
        public int GetOptimizedLine(BrickWall wall)
        {
            BrickWall clearPaths = new BrickWall();

            wall.Rows.ForEach((el) =>
            {
                clearPaths.Rows.Add(GetClearRowPaths(el));
            });

            return(FindOptimizedPath(clearPaths));
        }
コード例 #4
0
        //Retorna uma nova BrickWall, baseado nos parametros recebidos
        public BrickWall GenerateBrickWall(int rows, int maxBricksInRow)
        {
            BrickWall wall = new BrickWall();

            for (int i = 0; i < rows; i++)
            {
                wall.Rows.Add(GenerateBrickRow(maxBricksInRow));
            }

            return(wall);
        }
コード例 #5
0
        public dynamic Post([FromBody] BrickWall wall)
        {
            long tick1 = DateTime.Now.Ticks;

            SumAndContStrategy strategy = new SumAndContStrategy();

            int hits = strategy.GetOptimizedLine(wall);

            long tick2 = DateTime.Now.Ticks;

            return(new { hits, tick = tick2 - tick1 });
        }
コード例 #6
0
        public dynamic Get(int rows, int bricks)
        {
            BrickWall wall = new BrickWall();

            BrickWallGenerator generator = new BrickWallGenerator();

            long tick1 = DateTime.Now.Ticks;

            wall = generator.GenerateBrickWall(rows, bricks);
            long tick2 = DateTime.Now.Ticks;

            return(new { wall, tick = tick2 - tick1 });
        }
コード例 #7
0
        public dynamic Get(int rows, int bricks, int rowsInc, int bricksInc, int average)
        {
            BrickWallGenerator generator = new BrickWallGenerator();

            BrickWall wall = new BrickWall();

            List <float>       millList = new List <float>();
            List <float>       hitsList = new List <float>();
            SumAndContStrategy strategy = new SumAndContStrategy();

            long tick1 = 0;
            long tick2 = 0;


            int bricksCount = bricksInc;
            int rowsCount   = rowsInc;

            while (bricksCount < bricks || rowsCount < rows)
            {
                List <int> millListTemp = new List <int>();
                List <int> hitsListTemp = new List <int>();

                for (int i = 0; i < average; i++)
                {
                    //Gera uma BrickWall para ser trabalhada
                    wall = generator.GenerateBrickWall(rowsCount, bricksCount);

                    tick1 = DateTime.Now.Ticks;
                    //Descobre a linha que menos corta tijolos
                    hitsListTemp.Add(strategy.GetOptimizedLine(wall));
                    tick2 = DateTime.Now.Ticks;

                    millListTemp.Add(Convert.ToInt32(tick2 - tick1));
                }
                if (rowsCount < rows)
                {
                    rowsCount += rowsInc;
                }

                if (bricksCount < bricks)
                {
                    bricksCount += bricksInc;
                }

                hitsList.Add(hitsListTemp.Sum() / average);
                millList.Add(millListTemp.Sum() / average);
            }

            return(new { millis = millList.ToArray(), hits = hitsList.ToArray() });
        }
コード例 #8
0
ファイル: PlayerTest.cs プロジェクト: tssoft/rpgautumn2015
        public void TestHandleCollisionPlayerWall()
        {
            var game   = new Game();
            var player = new Player(new Point(1, 0), game);
            var wall   = new BrickWall(new Point(1, 0), game);

            var expected = player.PrevPosition;

            player.HandleCollision(wall);

            var actual = player.Position;

            Assert.AreEqual(expected, actual);
        }
コード例 #9
0
        /// <summary>
        ///     Render a brickwall.
        /// </summary>
        /// <param name="brickWall">BrickWall model</param>
        /// <param name="squareSize">Maximum size of the containing square</param>
        /// <returns></returns>
        private static Rectangle RenderBrickWall(BrickWall brickWall, int squareSize)
        {
            var rectangle = new Rectangle
            {
                Height = squareSize,
                Width  = squareSize,
                Fill   = new VisualBrush(
                    new PackIconMaterial
                {
                    Kind       = PackIconMaterialKind.ViewDashboard, // ViewDashboard icon looks like a brick wall
                    Rotation   = 90,                                 // when rotated by 90 degrees
                    Foreground = new SolidColorBrush(Colors.Brown),
                    Opacity    = brickWall.Health * 25 / 100.0
                }
                    ),
                Stroke = new SolidColorBrush(Colors.DimGray)
            };

            return(rectangle);
        }
コード例 #10
0
    protected override void Start()
    {
        base.Start();
        //initialMovementSpeed = 3f;
        movementSpeed = initialMovementSpeed;
        SetSpeed(movementSpeed);
        health            = startingHealth;
        deathEvent       += FindObjectOfType <EnemySpawner>().tankSpawner.OnEnemyDeath;
        deathEvent       += FindObjectOfType <CoinSpawner>().ToSpawnCoin;
        enemyPassedEvent += FindObjectOfType <EnemySpawner>().tankSpawner.OnEnemyPassed;
        enemyPassedEvent += FindObjectOfType <PlayerMovement>().OnGeneralEnemyPassed;
        ws = FindObjectOfType <WallSpawner>();
        bw = FindObjectOfType <BrickWall>();

        animator = GetComponent <Animator>();
        currInfo = animator.GetCurrentAnimatorStateInfo(0);

        animatorIdleNumber = (float)UnityEngine.Random.Range(0, 2);
        SetAnimationStates(false, false);
        enemyType = "Tank";
    }
コード例 #11
0
ファイル: Map.cs プロジェクト: Gupocca/AdMapperIO
        public void Open(string file)
        {
            objects = new List<MapObject>();
            BufferReader reader = new BufferReader(file);

            if (Path.GetExtension(file) != ".adm")
            {
                throw new ArgumentException("File does not have *.adm extension.");
            }
            if (reader.ReadString() != "ADmapv2")
            {
                throw new ArgumentException("Not a valid Adrenaline map file.");
            }

            // general map info
            this.version = reader.ReadByte();
            this.gridSize = reader.ReadByte();

            // spare slots
            reader.Skip(15);

            this.Name = reader.ReadString();
            this.Author = reader.ReadString();
            this.floorType = reader.ReadByte();

            // objects
            while (reader.HasMore())
            {
                string objectType = reader.ReadString();
                int instances = (int)reader.ReadUShort();

                for (int i = 0; i < instances; i++)
                {
                    ushort x = reader.ReadUShort();
                    ushort y = reader.ReadUShort();
                    MapObject obj = null;

                    #region Object Creation
                    switch (objectType)
                    {
                        // pickups
                        case "objAbArmor":
                            obj = new BulletArmorPickup();
                            break;
                        case "objAbIncendary":
                            obj = new BulletIncendiaryPickup();
                            break;
                        case "objAbDefault":
                            obj = new BulletNormalPickup();
                            break;
                        case "objAbVelocity":
                            obj = new BulletVelocityPickup();
                            break;
                        case "objAnades":
                            obj = new GrenadePickup();
                            break;
                        case "objMedkit":
                            obj = new HealthPickup();
                            break;
                        case "objAeNormal":
                            obj = new LaserPickup();
                            break;
                        case "objAmines":
                            obj = new MinePickup();
                            break;
                        case "objApDisc":
                            obj = new PlasmaDiscPickup();
                            break;
                        case "objApFragma":
                            obj = new PlasmaFragmaPickup();
                            break;
                        case "objApHigh":
                            obj = new PlasmaHighPickup();
                            break;
                        case "objApNormal":
                            obj = new PlasmaNormalPickup();
                            break;
                        case "objAmNormal":
                            obj = new RocketDualPickup();
                            break;
                        case "objAmNade":
                            obj = new RocketNukePickup();
                            break;
                        case "objAcSniper":
                            obj = new SniperPickup();
                            break;
                        case "objAeSuper":
                            obj = new SuperLaserPickup();
                            break;

                        // static
                        case "objSpawn":
                            obj = new AllSpawn();
                            break;
                        case "objFlagBlue":
                            obj = new BlueFlag();
                            break;
                        case "objFlagRed":
                            obj = new RedFlag();
                            break;
                        case "objTBlueSpawn":
                            obj = new BlueSpawn();
                            break;
                        case "objTRedSpawn":
                            obj = new RedSpawn();
                            break;
                        case "objLevelMine":
                            obj = new LevelMine();
                            break;
                        case "objTeleportDest":
                            obj = new TeleportDestination();
                            break;
                        case "objTeleportSrc":
                            obj = new TeleportSource();
                            break;
                        case "objStaticLight":
                            obj = new Light(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte());
                            break;

                        // Walls
                        case "objBlockWallBlocks":
                            obj = new BlocksWall();
                            break;
                        case "objBlockBrick":
                            obj = new BrickWall();
                            break;
                        case "objCube":
                            obj = new CompanionCube();
                            break;
                        case "objCompanion":
                            obj = new Crate();
                            break;
                        case "objBlockWall":
                            obj = new GreyWall();
                            break;
                        case "objBlockIceWall":
                            obj = new IceWall();
                            break;
                        case "objBlockLight":
                            obj = new LightWall();
                            break;
                        case "objBlockLightWall":
                            obj = new LightWall2();
                            break;
                        case "objBlockOld":
                            obj = new OldWall();
                            break;
                        case "objBlockRusty":
                            obj = new RustyWall();
                            break;
                        case "objBlockStripeWall":
                            obj = new StripeWall();
                            break;
                        case "objBlockWallpaper":
                            obj = new WallpaperWall();
                            break;
                        case "objBlockCrate":
                            obj = new WoodWall();
                            break;

                        // weapons
                        case "objAssault":
                            obj = new Assault();
                            break;
                        case "objSawnOff":
                            obj = new Curveshot();
                            break;
                        case "objLaserRifle":
                            obj = new Laser();
                            break;
                        case "objLauncher":
                            obj = new Launcher();
                            break;
                        case "objMinigun":
                            obj = new Minigun();
                            break;
                        case "objPistol":
                            obj = new IceWall();
                            break;
                        case "Pistol":
                            obj = new LightWall();
                            break;
                        case "objPlasma":
                            obj = new Plasma();
                            break;
                        case "objShotgun":
                            obj = new Shotgun();
                            break;
                        case "objSMG":
                            obj = new SMG();
                            break;
                        case "objSniper":
                            obj = new Sniper();
                            break;

                        default:
                            // no known object... better read bytes anyway
                            reader.ReadUShort();
                            reader.ReadUShort();
                            break;
                    }
                    #endregion Object Creation

                    if (obj != null)
                    {
                        obj.X = x;
                        obj.Y = y;
                        objects.Add(obj);
                    }
                }
            }
        }
コード例 #12
0
    // Update is called once per frame
    void Update()
    {
        if (!exploded)
        {
            movement();
            OutOfBoundsDestroy();

            healthBar.fillAmount = health / startingHealth;

            RaycastHit[] hitArray = new RaycastHit[5];
            RaycastHit   hit;

            float[] spawnPositionX = new float[] { -5f, -3f, -1f, 1f, 3f, 5f };
            float   snapXPos       = 0f;
            float   minDistX       = 1000f;
            for (int i = 0; i < 6; i++)
            {
                float dist = Mathf.Abs(spawnPositionX[i] - transform.position.x);

                if (dist < minDistX)
                {
                    minDistX = dist;
                    snapXPos = spawnPositionX[i];
                }
            }



            for (int i = 0; i < 5; i++)
            {
                if (DetectWallAhead(4f, out hit, transform.position + Vector3.right * (-transform.position.x + snapXPos - 0.8f + 0.4f * i)))
                {
                    Debug.Log("SnapX: " + snapXPos);
                    float[] removalWallData = new float[2];


                    int listIndex   = 0;
                    int targetIndex = -1;

                    if (i == 2)
                    {
                        removalWallData[0] = snapXPos;
                        removalWallData[1] = ws.SnapWall(snapXPos, hit.point.z)[1];

                        foreach (float[] array in ws.wallPositionData)
                        {
                            if (array[0] == removalWallData[0] && array[1] == removalWallData[1])
                            {
                                targetIndex = listIndex;
                            }
                            listIndex++;
                        }
                    }



                    IDamageable damageableObject = hit.collider.GetComponent <IDamageable>();
                    if (damageableObject != null)
                    {
                        SetAnimationStates(true, false);
                        currInfo = animator.GetCurrentAnimatorStateInfo(0);
                        SetSpeed(0f);
                        if (currInfo.normalizedTime > 0.5f && currInfo.IsName("Destroying"))
                        {
                            SetSpeed(movementSpeed);
                            damageableObject.TakeHit(10f, Vector3.zero);
                            animatorSpeedPercent = 0f;
                            SetAnimationStates(false, false);


                            if (i == 2)
                            {
                                if (hit.collider.GetComponent <BrickWall>() != null)
                                {
                                    if (hit.collider.GetComponent <BrickWall>().instanceBuildStatus == BrickWall.buildStatus.Built)
                                    {
                                        int arrayIndex;
                                        switch (removalWallData[0])
                                        {
                                        case -5f:
                                            arrayIndex = 0;
                                            break;

                                        case -3f:
                                            arrayIndex = 1;
                                            break;

                                        case -1f:
                                            arrayIndex = 2;
                                            break;

                                        case 1f:
                                            arrayIndex = 3;
                                            break;

                                        case 3f:
                                            arrayIndex = 4;
                                            break;

                                        case 5f:
                                            arrayIndex = 5;
                                            break;

                                        default:
                                            arrayIndex = 100;
                                            break;
                                        }

                                        ws.columnArrays[arrayIndex].Remove(removalWallData[1]);
                                    }
                                }
                            }


                            if (targetIndex != -1)
                            {
                                //StartCoroutine(RemoveFromArrayList(targetIndex));
                                ws.wallPositionData.RemoveAt(targetIndex);
                            }

                            if (i == 2)
                            {
                                BrickWall brickwall = (BrickWall)damageableObject;
                                brickwall.UnblockNearblyWallPlacement();
                            }
                        }

                        /*
                         * damageableObject.TakeHit(10f, Vector3.zero);
                         * animatorSpeedPercent = 0f;
                         * SetAnimationStates(true, false);
                         *
                         * if(i==2){
                         *  BrickWall brickwall = (BrickWall) damageableObject;
                         *  brickwall.UnblockNearblyWallPlacement();
                         * }
                         */
                    }
                    else
                    {
                        //if(detectTankAhead(1f, transform.position + Vector3.up * 2f)){
                        SetSpeed(0f);
                        animatorSpeedPercent = animatorIdleNumber;
                        SetAnimationStates(false, true);

                        animator.SetFloat("speedPercent", animatorIdleNumber);
                        //}
                    }
                }
                else
                {
                    if (i == 2)
                    {
                        if (detectTankAhead(1f, transform.position + Vector3.up * 2f))
                        {
                            SetSpeed(0f);
                            animatorSpeedPercent = animatorIdleNumber;
                            SetAnimationStates(false, true);

                            animator.SetFloat("speedPercent", animatorIdleNumber);
                        }
                        else
                        {
                            SetSpeed(movementSpeed);
                            animatorSpeedPercent = 3f;
                            SetAnimationStates(false, false);
                        }
                    }
                }
            }

            //animator.SetFloat("speedPercent", animatorSpeedPercent);
            //Debug.Log(animatorSpeedPercent + "  " + animatorIdleNumber);
            transform.position -= Vector3.up;
        }
    }
コード例 #13
0
    /// <summary>
    /// Generates the basic walls, floor, and entrance for any building.
    /// Picks the exact position of entrance, and returns it
    /// </summary>
    /// <param name="width"></param>
    /// <param name="height"></param>
    /// <param name="buildingObjects">Building objects to be filled with walls</param>
    /// <param name="buildTiles"></param>
    /// <param name="entranceID"></param>
    /// <param name="style"></param>
    /// <returns></returns>
    public static Vec2i GenerateWallsFloorAndEntrance(int width, int height, WorldObjectData[,] buildingObjects,
                                                      Tile[,] buildTiles, int entranceID, BuildingStyle style, int entraceDis = -1, WorldObjectData wallType = null, Tile tileType = null)
    {
        int entWidth = 2;

        if (entraceDis == -1)
        {
            if (entranceID == NORTH_ENTRANCE || entranceID == SOUTH_ENTRANCE)
            {
                entraceDis = MiscMaths.RandomRange(1, width - 1);
            }
            else
            {
                entraceDis = MiscMaths.RandomRange(1, height - 1);
            }
        }

        //Decide the position of the entrance
        Vec2i entrance = null;

        if (entranceID == NORTH_ENTRANCE)
        {
            entrance = new Vec2i(entraceDis, height - 1);
        }
        else if (entranceID == SOUTH_ENTRANCE)
        {
            entrance = new Vec2i(entraceDis, 0);
        }
        else if (entranceID == EAST_ENTRANCE)
        {
            entrance = new Vec2i(width - 1, entraceDis);
        }
        else if (entranceID == WEST_ENTRANCE)
        {
            entrance = new Vec2i(0, entraceDis);
        }


        //Assign correct wall type if none given
        if (wallType == null)
        {
            switch (style)
            {
            case BuildingStyle.stone:
                wallType = new BrickWall(new Vec2i(0, 0));
                break;

            case BuildingStyle.wood:
                //TODO - Add
                wallType = new BrickWall(new Vec2i(0, 0));
                break;
            }
        }//Asign correct tile type if none given
        if (tileType == null)
        {
            switch (style)
            {
            case BuildingStyle.stone:
                tileType = Tile.STONE_FLOOR;
                break;

            case BuildingStyle.wood:
                tileType = Tile.WOOD_FLOOR;
                break;
            }
        }
        //Iterate all points
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < height; z++)
            {
                //Asign tile
                buildTiles[x, z] = tileType;
                if (x == 0 || x == width - 1 || z == 0 || z == height - 1)
                {
                    //Asign wall if no entrance
                    if (!(entrance.x == x & entrance.z == z))
                    {
                        if (x == 3)
                        {
                            buildingObjects[x, z] = new BuildingWall(new Vec2i(0, 0), "brick", 5,
                                                                     new GlassWindow(new Vec2i(0, 0), new Vec2i(0, 1)), 2);
                        }
                        else
                        {
                            buildingObjects[x, z] = new BuildingWall(new Vec2i(0, -1), "brick", 5);
                        }
                    }
                }
            }
        }
        //(buildingObjects[0, 0] as BuildingWall).AddRoof(new Roof(new Vec2i(0, 0), new Vec2i(width, height)));

        return(entrance);
    }