コード例 #1
0
        private BonusMap GetScoutBonusMap(List <Vehicle> enemyUnits, AbsolutePosition squadCenter, double scoutVisionRange, MapType mapType)
        {
            const double affectedRange = 1200;
            var          unitsForMap   = enemyUnits.Where(
                u => (u.X - squadCenter.X) < affectedRange &&
                (u.Y - squadCenter.Y) < affectedRange &&
                u.Type != VehicleType.Arrv
                ).ToList();

            var map = new BonusMap(mapType);

            foreach (var unit in unitsForMap)
            {
                map.AddUnitCalculation(unit, scoutVisionRange, unit.AerialDamage + unit.GroundDamage, 800);
            }
            return(map);
        }
コード例 #2
0
        private BonusMap GetAeroDangerMap(List <Vehicle> enemyUnits, AbsolutePosition squadCenter, MapType mapType)
        {
            const double affectedRange    = 500;
            var          enemyUnitsForMap = enemyUnits.Where(
                u => (u.X - squadCenter.X) < affectedRange &&
                (u.Y - squadCenter.Y) < affectedRange
                ).ToList();

            var map = new BonusMap(mapType);

            foreach (var unit in enemyUnitsForMap)
            {
                map.AddUnitCalculation(unit, unit.AerialAttackRange * 1, unit.AerialDamage, unit.AerialAttackRange * 2.5);
            }

            return(map);
        }
コード例 #3
0
        private BonusMap GetGroundCollisionMap(List <Vehicle> allUnits, List <long> squadIds, AbsolutePosition squadCenter, MapType mapType)
        {
            const double affectedRange = 300;
            var          unitsForMap   = allUnits.Where(
                u => !u.IsAerial &&
                !squadIds.Contains(u.Id) &&
                (u.X - squadCenter.X) < affectedRange &&
                (u.Y - squadCenter.Y) < affectedRange
                ).ToList();
            var map = new BonusMap(mapType);

            foreach (var unit in unitsForMap)
            {
                map.AddUnitCalculation(unit, 10, 1, 30);
            }

            return(map);
        }
コード例 #4
0
        private Dictionary <int, BonusMap> GetCommonWinMap(List <Vehicle> enemyUnits, Squad squad, MapType mapType)
        {
            const double affectedRange    = 1200;
            var          squadCenter      = squad.SquadCenter;
            var          enemyUnitsForMap = enemyUnits.Where(
                u => (u.X - squadCenter.X) < affectedRange &&
                (u.Y - squadCenter.Y) < affectedRange
                ).ToList();


            var myIsAerialSquad = squad.IsAerial;

            var myAeroDamage    = (squad.AirForce) / squad.Units.Count;
            var myGroundDamage  = (squad.GroundForce) / squad.Units.Count;
            var myAeroDefence   = (squad.AirDefence) / squad.Units.Count;
            var myGroundDefence = (squad.GroundDefence) / squad.Units.Count;


            var mapPositive = new BonusMap(mapType);
            var mapNegative = new BonusMap(mapType);

            foreach (var enemyUnit in enemyUnitsForMap)
            {
                var totalWin = CalculateTotalWin(enemyUnit, myIsAerialSquad, myAeroDamage, myGroundDamage, myAeroDefence, myGroundDefence);

                //totalWin = totalWin * 1.1;

                //if (totalWin < squad.FairValue)
                //    squad.FairValue = totalWin;

                var arrvRadius = enemyUnit.Type == VehicleType.Arrv ? 100 : 0;

                var squadRadius = squad.Radius;
                var firstRadius = myIsAerialSquad
                    ? (enemyUnit.AerialAttackRange + arrvRadius) * 1 + squadRadius
                    : (enemyUnit.GroundAttackRange + arrvRadius) * 1 + squadRadius;

                var secondRadiusAdditive = myIsAerialSquad
                    ? (enemyUnit.AerialAttackRange + arrvRadius) * 5 + squadRadius
                    : (enemyUnit.GroundAttackRange + arrvRadius) * 5 + squadRadius;
                var secondRadiusFlat = 1200;

                //firstRadius = 0;

                var secondRadius = mapType == MapType.Additive ? secondRadiusAdditive : secondRadiusFlat;


                if (totalWin > 0)
                {
                    mapPositive.AddUnitCalculation(enemyUnit, firstRadius, totalWin, secondRadius);
                }
                if (totalWin < 0)
                {
                    mapNegative.AddUnitCalculation(enemyUnit, firstRadius, totalWin, secondRadius);
                }
            }
            mapNegative.Reflect();

            //To fix value to fear of.
            //map.Table[MapPointsAmount - 1, MapPointsAmount - 1] = squad.FairValue;
            //map.Trim(1);

            var result = new Dictionary <int, BonusMap> {
                { -1, mapNegative }, { 1, mapPositive }
            };

            return(result);
        }