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"