Esempio n. 1
0
        private void GetPossibleMovesForUnit(Unit unit, Dictionary<Unit, List<UnitOrderMetaData>> allOrders)
        {
            List<UnitOrderMetaData> orders = allOrders[unit];

            //The hold order!
            orders.Add(new UnitOrderMetaData(new HoldOrder(unit)));

            //All possible move orders
            foreach( Location location in unit.Location.AdjacentLocations )
            {
                orders.Add(new UnitOrderMetaData(new MoveOrder(unit, location)));
            }

            //Support orders
            PopulateSupportOrders(unit, allOrders);

            //Convoy orders
            PopulateMoveByConvoyOrders(unit, allOrders);
        }
Esempio n. 2
0
        private void PopulateMoveByConvoyOrders(Unit unit, Dictionary<Unit, List<UnitOrderMetaData>> allOrders)
        {
            List<UnitOrderMetaData> orders = allOrders[unit];

            if( unit.UnitType != UnitType.Army
                || !unit.Province.IsCoastal )
            {
                return;
            }

            //We've found an army that is placed in a coastal territory!

            //Find all sea-provinces that have fleets in them
            Route route = new Route(unit.Province);
            Queue<Route> routesToSearch = new Queue<Route>();
            foreach( Province province in unit.Location.AdjacentProvinces )
            {
                routesToSearch.Enqueue(new Route(route, province));
            }

            while( routesToSearch.Count > 0 )
            {
                Route aRoute = (Route)routesToSearch.Dequeue();
                if( aRoute.End.IsSea	//It's a sea province
                    && aRoute.End.Unit != null )	//There's a fleet there
                {
                    foreach( Province adjacentProvince in aRoute.End.AdjacentProvinces )
                    {
                        //Make sure that we do not end up in a never-ending loop.
                        if( !aRoute.Provinces.Contains(adjacentProvince) )
                        {
                            routesToSearch.Enqueue(new Route(aRoute, adjacentProvince));
                        }
                    }
                }
                else if( aRoute.End.IsCoastal	//A coastal territory
                    && aRoute.Provinces.Count >= 3 )	//We've gone at least one step on water!
                {
                    UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                        new MoveByConvoyOrder(unit, aRoute));
                    Route via = aRoute.Via;

                    List<UnitOrderMetaData> conveyOrders = new List<UnitOrderMetaData>();
                    for( int index = 0; index < via.Provinces.Count; ++index )
                    {
                        Unit convoyingUnit = via.Provinces[index].Unit;

                        UnitOrderMetaData conveyMeta = new UnitOrderMetaData(
                            new ConveyOrder(convoyingUnit, unit, aRoute.End));

                        //Schedule the convoy order for updates regarding it's dependent orders.
                        conveyOrders.Add(conveyMeta);

                        //Add the convoy order to the conveying unit.
                        //This means that we do not have to look at fleet to add their
                        //convoy orders, since they've been added for all convoyed armies!
                        List<UnitOrderMetaData> convoyUnitOrders = allOrders[convoyingUnit];
                        convoyUnitOrders.Add(conveyMeta);

                        orderMeta.RequiredOrders.Add(conveyMeta);
                    }

                    //Finalize the convey orders.
                    foreach( UnitOrderMetaData conveyOrder in conveyOrders )
                    {
                        conveyOrder.RequiredOrders.Add(orderMeta);
                        conveyOrder.RequiredOrders.AddRange(conveyOrders);
                        conveyOrder.RequiredOrders.Remove(conveyOrder);	//Remove yourself from the list!
                    }

                    orders.Add(orderMeta);
                }
            }
        }
Esempio n. 3
0
        private void PopulateSupportOrders(Unit unit, Dictionary<Unit, List<UnitOrderMetaData>> allOrders)
        {
            List<UnitOrderMetaData> orders = allOrders[unit];

            foreach( Location adjacentLocation in unit.Location.AdjacentLocations )
            {
                //Support of a unit one step away
                Unit adjUnit = adjacentLocation.Province.Unit;
                if( adjUnit != null && adjUnit.Power == this.Power )
                {
                    //Support for the adjacent unit's Hold order
                    {
                        // Work out the value of the move.
                        // Hold supports are only needed if

                        double costOfSupport = 0;
                        double orderValue = getLocationWeight(adjUnit.Location);

                        foreach (Location loc in unit.Location.AdjacentLocations)
                        {
                            double tempValue = getLocationWeight(loc) - getLocationWeight(unit.Location);
                            if (loc != adjUnit.Location && tempValue > costOfSupport) costOfSupport = tempValue;
                        }

                        if (getCompetition(adjUnit.Location) > 1) // We actually need todo this
                            orderValue *= param.SUPPORT_BONUS;

                        orderValue -= costOfSupport;
                        orderValue = randomMoveValue(orderValue);

                        UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                            new SupportHoldOrder(unit, adjUnit), orderValue, unit.Location);

                        orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                            new HoldOrder(adjUnit), orderValue, adjUnit.Location));
                        orders.Add(orderMeta);
                    }

                    //Support for the adjacent unit's Move orders
                    foreach( Location targetLocation in adjUnit.Location.AdjacentLocations )
                    {
                        if( targetLocation.Province != unit.Province
                            && unit.CanMoveTo(targetLocation.Province) )
                        {
                            double costOfSupport = 0;
                            double orderValue = getLocationWeight(targetLocation);

                            foreach (Location loc in unit.Location.AdjacentLocations)
                            {
                                double tempValue = getLocationWeight(loc) - getLocationWeight(unit.Location);
                                if (loc != targetLocation && tempValue > costOfSupport) costOfSupport = tempValue;
                            }

                            if (getCompetition(targetLocation) > 1) // We're meeting an equal force
                                orderValue *= param.SUPPORT_BONUS;
                            else if (getCompetition(targetLocation) == 1) // We can overwhelm them
                                orderValue *= param.SUPPORT_BONUS * param.SUPPORT_BONUS;

                            orderValue -= costOfSupport;
                            orderValue = randomMoveValue(orderValue);
                            /* End of support evaluation */

                            UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                                new SupportMoveOrder(unit, adjUnit, targetLocation.Province), orderValue, targetLocation);
                            orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                                new MoveOrder(adjUnit, targetLocation)));
                            orders.Add(orderMeta);
                        }
                    }
                }

                //Support of a unit two steps away
                foreach( Province farProvince in adjacentLocation.AdjacentProvinces )
                {
                    if( unit.Location.AdjacentProvinces.Contains(farProvince)	//It is an adjacent province.
                        || farProvince == unit.Province )	//It is this province
                    {
                        continue;
                    }

                    Unit farUnit = farProvince.Unit;
                    if( farUnit != null	//There is a unit there
                        && farUnit.CanMoveTo(adjacentLocation.Province) )
                    {
                        //Now, it might be possible for the farUnit to be able to move
                        //to the adjacentProvince in more than one way!
                        foreach( Location closeLocation in farUnit.Location.AdjacentLocations )
                        {
                            if( closeLocation.Province == adjacentLocation.Province )
                            {
                                UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                                    new SupportMoveOrder(unit, farUnit, adjacentLocation.Province));
                                orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                                    new MoveOrder(farUnit, closeLocation)));
                                orders.Add(orderMeta);
                            }
                        }
                    }
                }
            }
        }
Esempio n. 4
0
        private void PopulateSupportOrders(Unit unit, Dictionary<Unit, List<UnitOrderMetaData>> allOrders)
        {
            List<UnitOrderMetaData> orders = allOrders[unit];

            foreach( Location adjacentLocation in unit.Location.AdjacentLocations )
            {
                //Support of a unit one step away
                Unit adjUnit = adjacentLocation.Province.Unit;
                if( adjUnit != null && adjUnit.Power == this.Power )
                {
                    //Support for the adjacent unit's Hold order
                    {
                        UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                            new SupportHoldOrder(unit, adjUnit));

                        orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                            new HoldOrder(adjUnit)));
                        orders.Add(orderMeta);
                    }

                    //Support for the adjacent unit's Move orders
                    foreach( Location targetLocation in adjUnit.Location.AdjacentLocations )
                    {
                        if( targetLocation.Province != unit.Province
                            && unit.CanMoveTo(targetLocation.Province) )
                        {
                            UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                                new SupportMoveOrder(unit, adjUnit, targetLocation.Province));
                            orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                                new MoveOrder(adjUnit, targetLocation)));
                            orders.Add(orderMeta);
                        }
                    }
                }

                //Support of a unit two steps away
                foreach( Province farProvince in adjacentLocation.AdjacentProvinces )
                {
                    if( unit.Location.AdjacentProvinces.Contains(farProvince)	//It is an adjacent province.
                        || farProvince == unit.Province )	//It is this province
                    {
                        continue;
                    }

                    Unit farUnit = farProvince.Unit;
                    if( farUnit != null	//There is a unit there
                        && farUnit.CanMoveTo(adjacentLocation.Province) )
                    {
                        //Now, it might be possible for the farUnit to be able to move
                        //to the adjacentProvince in more than one way!
                        foreach( Location closeLocation in farUnit.Location.AdjacentLocations )
                        {
                            if( closeLocation.Province == adjacentLocation.Province )
                            {
                                UnitOrderMetaData orderMeta = new UnitOrderMetaData(
                                    new SupportMoveOrder(unit, farUnit, adjacentLocation.Province));
                                orderMeta.RequiredOrders.Add(new UnitOrderMetaData(
                                    new MoveOrder(farUnit, closeLocation)));
                                orders.Add(orderMeta);
                            }
                        }
                    }
                }
            }
        }