civCityState.go

package genworldvoronoi

import (
	"fmt"
	"log"

	"github.com/Flokey82/genworldvoronoi/geo"
)

func (m *Civ) GetCityState(id int) *CityState {
	if m.RegionToCityState[id] < 0 {
		return nil
	}
	for _, cs := range m.CityStates {
		if cs.ID == m.RegionToCityState[id] {
			return cs
		}
	}
	return nil
}

func (m *Civ) PlaceNCityStates(n int) {
	m.ResetRand()
	for i, c := range m.Cities {
		if i >= n {
			break
		}
		m.PlaceCityStateAt(c.ID, c)
		log.Printf("CityState %d: %s", i, c.Name)
	}
	m.ExpandCityStates()
}

// CityState represents a territory governed by a single city.
type CityState struct {
	ID      int      // Region where the city state originates
	Capital *City    // Capital city
	Culture *Culture // Culture of the city state
	Cities  []*City  // Cities within the city state
	Founded int64    // Year when the city state was founded

	// TODO: DO NOT CACHE THIS!
	Regions []int
	*geo.Stats
}

func (c *CityState) compare(other *CityState) float64 {
	if c == other {
		return 1.0
	}
	if c == nil || other == nil {
		return -1.0
	}

	capitalValue := c.Capital.compare(other.Capital)
	cultureValue := c.Culture.compare(other.Culture)

	return (capitalValue + cultureValue) / 2
}

func (c *CityState) String() string {
	return fmt.Sprintf("CityState %s: %d cities, %d regions", c.Capital.Name, len(c.Cities), len(c.Regions))
}

func (c *CityState) Log() {
	log.Printf("The city state of %s: %d cities, %d regions", c.Capital.Name, len(c.Cities), len(c.Regions))
	c.Stats.Log()
}

func (m *Civ) PlaceCityStateAt(r int, c *City) *CityState {
	cs := &CityState{
		ID:      r,
		Capital: c,
		Culture: m.GetCulture(r),
		Founded: c.Founded,            // TODO: Use current year.
		Cities:  []*City{c},           // TODO: ??? Remove this?
		Regions: []int{r},             // TODO: ??? Remove this?
		Stats:   m.GetStats([]int{r}), // TODO: ??? Remove this?
	}

	// If there is no known culture, generate a new one.
	if c.Culture == nil {
		c.Culture = m.PlaceCultureAt(r, true, nil) // TODO: Grow this culture.
	}

	m.CityStates = append(m.CityStates, cs)
	// TODO: Name? Language?
	return cs
}

// ExpandCityStates expands the city states on the map based on their culture,
// terrain preference, and other factors.
func (m *Civ) ExpandCityStates() {
	// Territories are based on cities acting as their capital.
	// Since the algorithm places the cities with the highes scores
	// first, we use the top 'n' cities as the capitals for the
	// territories.
	var seedCities []int
	for _, c := range m.CityStates {
		seedCities = append(seedCities, c.ID)
	}
	m.expandCityStates(false, seedCities)
}

func (m *Civ) expandCityStates(aggressive bool, seedCities []int) {
	weight := m.getTerritoryWeightFunc()
	biomeWeight := m.getTerritoryBiomeWeightFunc()
	cultureWeight := m.getTerritoryCultureWeightFunc()

	placeFunc := m.regPlaceNTerritoriesCustom
	if aggressive {
		placeFunc = m.expandTerritoriesAggressive
	}

	m.RegionToCityState = placeFunc(m.RegionToCityState, seedCities, func(o, u, v int) float64 {
		// TODO: Make sure we take in account expansionism, wealth, score, and culture.
		w := weight(o, u, v)
		if w < 0 {
			return -1
		}
		b := biomeWeight(o, u, v)
		if b < 0 {
			return -1
		}
		c := cultureWeight(o, u, v)
		if c < 0 {
			return -1
		}
		return (w + b + c) / 3
	})

	// Before relaxing the territories, we'd need to ensure that we only
	// relax without changing the borders of the empire...
	// So we'd only re-assign IDs that belong to the same territory.
	// m.rRelaxTerritories(m.r_city, 5)

	// Update the city states with the new regions.
	for _, c := range m.CityStates {
		// Loop through all cities and gather all that
		// are within the current city state.
		c.Cities = c.Cities[:0]
		for _, ct := range m.Cities {
			if m.RegionToCityState[ct.ID] == c.ID {
				c.Cities = append(c.Cities, ct)
			}
		}

		// Collect all regions that are part of the
		// current territory.
		c.Regions = c.Regions[:0]
		for r, terr := range m.RegionToCityState {
			if terr == c.ID {
				c.Regions = append(c.Regions, r)
			}
		}
		c.Stats = m.GetStats(c.Regions)
		c.Log()
	}
}

func (m *Civ) GetCityStates() []*CityState {
	// TODO: Deduplicate with GetEmpires.
	return m.CityStates
}

// getCityStateNeighbors returns all city states that are neighbors of the
// given city state.
func (m *Civ) getCityStateNeighbors(c *CityState) []int {
	return m.getTerritoryNeighbors(c.ID, m.RegionToCityState)
}

// getCityStateEmpire returns the empire that the given city state belongs to (if any).
func (m *Civ) getCityStateEmpire(c *CityState) int {
	return m.RegionToEmpire[c.ID]
}