Esempio n. 1
0
        public IPlotOperation CreateCityBarRenderer()
        {
            var map = GameData.Terrain;

            bool CityMapper(byte index, out ISettlement s, out Nothing context)
            {
                if (index == 0)
                {
                    s       = null;
                    context = null;
                    return(false);
                }

                s       = GameData.Settlements[index];
                context = null;
                return(true);
            }

            var settlementMatcher =
                new DirectMappingTileMatcher <byte, ISettlement, Nothing>((x, y) => map[x, y].City, CityMapper);

            return(PlotOperations.FromContext(RenderingConfig)
                   .Create(settlementMatcher)
                   .ForViewport()
                   .WithRenderer(CreateRenderer())
                   .Build());
        }
Esempio n. 2
0
        TileMatchControl CreateResourceLayer()
        {
            var resourceTypes = GameData.Rules.TerrainResourceTypes;
            var map           = GameData.Terrain;

            int Query(int x, int y)
            {
                return(map[x, y].Resources);
            }

            bool AlwaysTrue(int x, int y)
            {
                return(true);
            }

            var m = new DistinctTileMatcher <int, TTile, Nothing>(Query);

            for (var idx = 0; idx < resourceTypes.Count; idx++)
            {
                var resource = resourceTypes[idx];
                if (resource.GraphicTag != null)
                {
                    m.Add(idx, new BasicTileSelector <TTile, Nothing>(AlwaysTrue,
                                                                      RenderingConfig.MatcherNavigator,
                                                                      Tiles,
                                                                      resource.GraphicTag));
                }
            }

            // alternative ...

            Tuple <TTile, Nothing> LookupTileFromResourceId(int idx)
            {
                var resource = resourceTypes[idx];

                if (Tiles.FindFirstTile(resource, out var retval))
                {
                    return(Tuple.Create(retval, Nothing.Instance));
                }

                return(null);
            }

            var cachedLookup = new LookupTable <Tuple <TTile, Nothing> >(resourceTypes.Count,
                                                                         LookupTileFromResourceId);

            Tuple <TTile, Nothing> QueryCachedData(int x, int y)
            {
                var data = map[x, y].Resources;

                return(cachedLookup.Lookup(data));
            }

            var dm =
                new DirectMappingTileMatcher <Tuple <TTile, Nothing>, TTile, Nothing>(
                    QueryCachedData, LookupTable.UnwrapTuple);

            return(new TileMatchControl(dm, RotationCacheControl));
        }