Suggest City Name Maps changes in Google Docs

Leoreth

Blue Period
Moderator
Joined
Aug 23, 2009
Messages
36,994
Location
東京藝術大学
You can now easily suggest changes to city name maps using Google Docs. I have uploaded all maps there, including an overlay of the world map. You can use suggest mode to submit changes, and I will approve if I agree. If enough changes have accumulated, I will export the maps and add them to the mod.

Due to the number and size of the sheets I had to split them across several documents:
- Egyptian, Chinese, Babylonian, Greek, Indian, Phoenician, Persian, Latin, Ethiopian, Korean, Mayan, Byzantine, Japanese: here
- Viking, Arabian, Tibetan, Khmer, Indonesian, Spanish, French, English, German, Russian, Malian, Polish, Portuguese, Quechua: here
- Italian, Mongolian, Aztec, Turkish, Thai, Congolese, Dutch, Prussian, American, Mexican, Polynesian, Harappan: here

Some notes on how the dynamic name system works. I explained this before but I don't think everyone is aware: Maps are associated with "languages". Civilisations can share languages (e.g. Spain, Mexico, Argentina and Colombia all use the Spanish map), and Civilisations can have multiple languages (e.g. the primary language of the Mughals is Persian, followed by Arabian and Indian). Secondary languages (and so on) are used if the primary language has no entry for a given tile. Some languages only exist to override very specific parts of the secondary names. For example, Germany has "Prussian" as primary language and "German" as secondary, but these maps are largely identical except some names like Berlin instead of Madgeburg.

Many maps are out of date by a long time, and many parts of it haven't been changed since DoC branched off RFC. So there is a lot of things that I would like to see addressed/fixed:
- since cities can be two tiles apart, the same name should only cover at most a 2x2 square so the same cannot appear more than one
- some maps have areas covered with very generic names (e.g. "Arabia" for all tiles on the Arabian peninsula for Latin), those should be removed imo
- language specific maps should be cleaned of names from other languages, because this is better implemented by using the other languages' maps as secondary, tertiary ... instead. For instance, the Khmer map includes many Indian names. Those should be removed if identical with the proper Indian map, and Indian added as a secondary language for the Khmer. Same e.g. with Tibetan/Chinese, Thai/Khmer, and especially "faux" languages such as Prussian/German, Mexican/Spanish.
- please keep in mind that the map does not reflect names changing over time, instead it should only include the earliest possible name for a city. Later changes are handled separately.
- fix transliterations. For the record, the preferred transliterations are: Pinyin for Chinese, Wapuro for Japanese, BGN/PCGN 1947 for Russian. I'm agnostic on the others. Russian is egregiously inconsistent, and I suspect influenced by Italian conventions, I'd really appreciate a revision.
- in many places maps have names that are often a stretch, mostly for regions where the language never was prominent. For example, German has names in the Americas for small German-speaking communities that are neither proper cities nor were ever part of a German-speaking polity. In my opinion, those names should be kept as easter eggs.

In general of course I also welcome plain suggestions of new/changed/better/more diverse names, and fixes for geographically inaccurate names (again, Russia seems affected a lot). Open for discussion in every case.

For reference, here's an excerpt of the CityNameManager.py file to document the association of civs to languages:
Spoiler :
Code:
    if iCiv == iEgypt:
       if pCiv.getStateReligion() == iIslam: return (iLangEgyptianArabic, iLangArabian)
       return (iLangEgyptian,)
   elif iCiv == iChina: return (iLangChinese,)
   elif iCiv == iBabylonia: return (iLangBabylonian,)
   elif iCiv == iHarappa: return (iLangHarappan, iLangIndian)
   elif iCiv == iIndia: return (iLangIndian,)
   elif iCiv == iGreece: return (iLangGreek,)
   elif iCiv == iCarthage: return (iLangPhoenician,)
   elif iCiv == iPolynesia: return (iLangPolynesian,)
   elif iCiv == iPersia:
       if utils.isReborn(iCiv): return (iLangArabian, iLangPersian)
       return (iLangPersian,)
   elif iCiv == iRome: return (iLangLatin,)
   elif iCiv == iTamils: return (iLangIndian,)
   elif iCiv == iEthiopia: return (iLangEthiopian,)
   elif iCiv == iKorea: return (iLangKorean, iLangChinese)
   elif iCiv == iMaya:
       if utils.isReborn(iCiv): return (iLangSpanish,)
       return (iLangMayan,)
   elif iCiv == iByzantium: return (iLangByzantine, iLangLatin)
   elif iCiv == iJapan: return (iLangJapanese,)
   elif iCiv == iVikings: return (iLangViking,)
   elif iCiv == iArabia: return (iLangArabian,)
   elif iCiv == iTibet: return (iLangTibetan, iLangChinese,)
   elif iCiv == iKhmer: return (iLangKhmer, iLangIndonesian)
   elif iCiv == iIndonesia: return (iLangIndonesian, iLangKhmer)
   elif iCiv == iMoors: return (iLangArabian,)
   elif iCiv == iSpain: return (iLangSpanish,)
   elif iCiv == iFrance: return (iLangFrench,)
   elif iCiv == iEngland: return (iLangEnglish,)
   elif iCiv == iHolyRome: return (iLangGerman,)
   elif iCiv == iRussia: return (iLangRussian,)
   elif iCiv == iMali: return (iLangMalian,)
   elif iCiv == iPoland: return (iLangPolish, iLangRussian)
   elif iCiv == iPortugal: return (iLangPortuguese, iLangSpanish)
   elif iCiv == iInca:
       if isResurrected(iCiv): return (iLangSpanish,)
       return (iLangQuechua,)
   elif iCiv == iItaly: return (iLangItalian,)
   elif iCiv == iMongolia: return (iLangMongolian, iLangChinese)
   elif iCiv == iAztecs:
       if utils.isReborn(iCiv): return (iLangMexican, iLangSpanish)
       return (iLangAztec,)
   elif iCiv == iMughals: return (iLangPersian, iLangArabian, iLangIndian)
   elif iCiv == iTurkey: return (iLangTurkish, iLangArabian)
   elif iCiv == iThailand: return (iLangThai, iLangKhmer, iLangIndonesian)
   elif iCiv == iCongo: return (iLangCongolese,)
   elif iCiv == iNetherlands: return (iLangDutch,)
   elif iCiv == iGermany: return (iLangPrussian, iLangGerman,)
   elif iCiv == iAmerica: return (iLangAmerican, iLangEnglish)
   elif iCiv == iArgentina: return (iLangSpanish,)
   elif iCiv == iBrazil: return (iLangPortuguese, iLangSpanish)
   elif iCiv == iCanada: return (iLangAmerican, iLangEnglish)
   elif iCiv == iCeltia: return (iLangCeltic,)
   elif iCiv == iSeljuks: return (iLangTurkish, iLangArabian)
   else: return None

EDIT: Now you can also edit the rename dictionaries, i.e. how city names are translated when cities are acquired by another civilisation: here

A quick recap of how those rename dicts work:
- like founding maps, the languages specified are tried sequentially until an entry is found, if none is found the city keeps its current name
- renaming is actually a two step process. First the current name is translated back to the "default name" (which is called identifier), then the identifier is translated to the desired target language. This way the individual language dicts only need to cover one case per city (from the identifier to the language name) instead of all possible combinations
- in other words, in the identifier dicts, the right entries are all identifiers, while in the language dicts all the left entries are identifiers
- when adding an entry to a language dict, make sure to find the right identifier first
- in turn, add the reverse direction (new translated name to identifier) to the identifier dict
- if no identifier exists already, choose one. The native language name of the city is preferred, if that is hard to define just choose what is shortest/easiest to type
- if an identifier is added, you also need to add a rename to its language that leaves it unchanged. This is necessary so those languages can restore the names to their original when reacquiring. To illustrate, the identifier for London is "London". France has an entry "London" -> "Londres". If France conquers London, the identifier for the current name "London" is "London", and the French translation of "London" is "Londres". In case England reconquers the city, we find "London" as the identifier for "Londres". But the English dict needs an entry "London" -> "London" or otherwise the code would assume there is no English name for the city and leave it as "Londres"
 
Last edited:
It might be useful if also the peaks are visible. They don't need a city name and they are quite handy for orientation. Especially in areas far from the coast. (And if possible, rivers too)
 
I created the overlay from the region map which only distinguishes land and water, if you can make an improved version I'll apply it.
 
I was just looking at them and noticed that Mexico calls cell L21 San Francisco, but America calls it Los Angeles (I'm sure this problem must exist in many other cases, I just saw that one by chance). What's your preferred policy in such cases?
 
Would it be possible to increase the zoom level of the maps a little bit? It's kind of hard to see the city names easily at glance, and we don't really need to see such a large area at once.

Rivers would also be really helpful for figuring out where exactly a tile is supposed to be; I can help make this if you want.
 
Unfortunately you cannot zoom in Google Sheets as far as I know. And as I said, if you want to improve the overlay I would like that.
 
I think there is a paste formatting only option.
 
Here is a new version with all peaks and rivers visible.
Also, it looks like you blocked off Samarkand from access to China with a mountain. Pretty sure there's a hill there, that allows direct access (it's possible there is a mountain early on, that becomes a hill to allow for the Silk Road).

No other problems that I can tell.
 
O wait, that's right. I loaded the 3000 BC scenario for the peaks and rivers. There are 3 peaks (also 2 in the Andes) that turn into hills at certain events. I remove them from the sheet.

(I did remember these tiles while I started working on it, but I forgot to change them when I got to them.)

EDIT:
I see one of the tiles that changes from peak to something else is (40, 66), which is in Greenland. According to line 2315 of RFC.py, it should help the Aztecs. Wrong coordinates?
 
Last edited:
Yay, I really like playing with city name maps for some reason. Thus I quite extensively reworked the Egyptian map. A lot is based on this map. Some notes:
- I think Waset is a better name for Niwt-rst/Thebes. At the very least it's easier to pronounce...
- I tried to cram many important cities along the Nile for diversity, rather than have Niwt-rst covering nine tiles
- In the south, the cities were mostly all wrong and didn't follow the course of the Nile accurately at all. Should be less wrong now.
- I also reworked the Egyptian part of the Greek map, mostly with Ptolemaic era cities
- Maybe I will rework the area for other languages, and maybe give a list of Greek/Latin/Arabic names matching the Egyptian ones
- Thanks to the person who provided names for the Red Sea ports and cities outside Egypt proper!
- In case Egypt goes out of their way and founds cities outside its historical area, maybe give it Greek as a secondary language?
 
Babylonian and Phoenician might be better secondary languages for (pre-Hellenistic, of course) Egypt, in my opinion.
 
Something I noticed at a glance, Steb; to my knowledge, 'Akhenaten' should be 'Akhetaten'.
 
There's been lots of activity so far, thanks for all the suggestions.

I hope to bring the rename maps online soon as well.
 
Yeah, you should be able to see other people's comments.
 
Top Bottom