Documentation
¶
Overview ¶
Package namegen implements random name generation.
It builds names according to letter and phrase patterns representative of naming conventions used by various Golarion cultures.
This code is a port of John Mechalas's JavaScript name generator from https://dungeonetics.com/pfnames/ and includes a starter set of his Golarion cultural name data.
To quote John's own documentation: "The name generators presented here are based on Markov chains, and construct names that tend to follow the same letter/syllable combinations and distributions as the source names from which they were seeded. Note that these algorithms are not perfect, and you might need to generate several names before settling on one that you like: it is the nature of the Markov chain to occasionally produce silly gibberish, names that do not 'fit', or even 'real' names. These accidents are part of the fun."
Note that the names are "gender"-based. This term is used simply to differentiate cultural naming patterns, which often follow the gender expression of the individual, but many cultures have other naming variations based on social constructs such as family/clan traditions, region, economic and political status, religion, etc. All of these are "genders" as far as this module is concerned, and an arbitrary number of them may be defined for any given culture.
The default "genders" included for the supplied set of cultures includes 'F' for female names, 'M' for male names, and 'S' for surnames. Not all cultures implement all of these.
The limits on name length are not hard rules but are rather goals for the generator to try for. Also note that there are times when the generator may give up before generating the quantity of names requested in order to avoid getting into a loop that takes too much time to complete.
This code, and specifically the individual Culture definition source files, uses trademarks and/or copyrights owned by Paizo Inc., used under Paizo's Community Use Policy (paizo.com/communityuse). We are expressly prohibited from charging you to use or access this content. GMA is not published, endorsed, or specifically approved by Paizo. For more information about Paizo Inc. and Paizo products, visit paizo.com.
Index ¶
- Variables
- func Generate(c Culture, gender rune, qty int, options ...func(*generateOptions)) ([]string, error)
- func GenerateWithSurnames(c Culture, gender rune, qty int, options ...func(*generateOptions)) ([][]string, error)
- func WithDieRoller(dr *dice.DieRoller) func(*generateOptions)
- func WithMaxLength(maxlen int) func(*generateOptions)
- func WithMinLength(minlen int) func(*generateOptions)
- func WithStartingLetter(start rune) func(*generateOptions)
- type Azlanti
- type BaseCulture
- type Bekyar
- type Bonuwat
- type Chelaxian
- type Culture
- type Dwarf
- type Elf
- type Erutaki
- type Garundi
- type Gnome
- type HalfOrc
- type Halfling
- type Keleshite
- type Kellid
- type Kitsune
- type Shoanti
- type Taldan
- type TianDan
- type TianDtang
- type TianHwan
- type TianLa
- type TianMin
- type TianShu
- type TianSing
- type Ulfen
- type Varisian
- type Vudrani
- type Zenj
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var Cultures = map[string]Culture{ "Azlanti": Azlanti{}, "Bekyar": Bekyar{}, "Bonuwat": Bonuwat{}, "Chelaxian": Chelaxian{}, "Dwarf": Dwarf{}, "Elf": Elf{}, "Erutaki": Erutaki{}, "Garundi": Garundi{}, "Gnome": Gnome{}, "Half-orc": HalfOrc{}, "Halfling": Halfling{}, "Keleshite": Keleshite{}, "Kellid": Kellid{}, "Kitsune": Kitsune{}, "Shoanti": Shoanti{}, "Taldan": Taldan{}, "Tian-dan": TianDan{}, "Tian-dtang": TianDtang{}, "Tian-hwan": TianHwan{}, "Tian-la": TianLa{}, "Tian-min": TianMin{}, "Tian-shu": TianShu{}, "Tian-sing": TianSing{}, "Ulfen": Ulfen{}, "Varisian": Varisian{}, "Vudrani": Vudrani{}, "Zenj": Zenj{}, }
Cultures lists the cultures that are defined in this package as distributed. Programs may use this to offer a choice of cultures to the user or to get a value which can be passed to Generate or GenerateWithSurnames.
The keys of this map are culture names. Their associated values are values of the corresponding Culture type.
Functions ¶
func Generate ¶
Generate creates the requested quantity of random names for the given culture and gender code. These are returned as a slice of name strings.
Example ¶
names, err := Generate(Kellid{}, 'F', 5, WithStartingLetter('K'))
if err != nil {
fmt.Printf("Error generating names: %v\n", err)
} else {
fmt.Println("Five example Kellid names starting with 'K':")
for i, name := range names {
fmt.Printf("#%d: %s\n", i+1, name)
}
}
Output:
func GenerateWithSurnames ¶
func GenerateWithSurnames(c Culture, gender rune, qty int, options ...func(*generateOptions)) ([][]string, error)
GenerateWithSurnames is just like Generate, but for every given name generated it also creates a surname. Names are returned as a slice of names, where each name is a slice of two strings (given name and surname).
Example ¶
names, err := GenerateWithSurnames(Taldan{}, 'M', 5)
if err != nil {
fmt.Printf("Error generating names: %v\n", err)
} else {
fmt.Println("Five example Taldan names:")
for i, name := range names {
fmt.Printf("#%d: %s %s\n", i+1, name[0], name[1])
}
}
Output:
func WithDieRoller ¶
WithDieRoller modifies a Generate or GenerateWithSurnames function call by specifying the DieRoller to use for random number generation. If this is not specified, or if a nil value is passed, a standard pseudorandom number generator will be employed. However, this option is provided in case you are generating names along with other character data that must remain consistent from one run of the program to the next, and as such you already have a seeded DieRoller in use, that you wish to use for the names as well.
func WithMaxLength ¶
func WithMaxLength(maxlen int) func(*generateOptions)
WithMaxLength modifies a Generate or GenerateWithSurnames function call by specifying the maximum length for the names to be generated. If the value given is 0 or this option is not present, the maximum length defined by the culture will be used.
func WithMinLength ¶
func WithMinLength(minlen int) func(*generateOptions)
WithMinLength modifies a Generate or GenerateWithSurnames function call by specifying the minimum length for the names to be generated. If the value given is 0 or this option is not present, the minimum length defined by the culture will be used.
func WithStartingLetter ¶
func WithStartingLetter(start rune) func(*generateOptions)
WithStartingLetter modifies a Generate or GenerateWithSurnames function call by specifying the initial letter for the names to be generated. If this is 0 or this option is not present, names starting with any letter may be created.
Types ¶
type Azlanti ¶
type Azlanti struct {
BaseCulture
}
Azlanti describes the naming conventions for the Azlanti culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type BaseCulture ¶
type BaseCulture struct {
}
BaseCulture provides a baseline common to all cultures. Each individual culture should include BaseCulture.
func (BaseCulture) Genders ¶
func (c BaseCulture) Genders() []rune
Genders returns a list of gender codes supported by this Culture.
func (BaseCulture) HasGender ¶
func (c BaseCulture) HasGender(gender rune) bool
HasGender returns true if the specified gender code is defined for this culture.
func (BaseCulture) HasSurnames ¶
func (c BaseCulture) HasSurnames() bool
HasSurnames returns true if this Culture implements surnames.
func (BaseCulture) Name ¶
func (c BaseCulture) Name() string
Name returns a human-readable name of the Culture.
type Bekyar ¶
type Bekyar struct {
BaseCulture
}
Bekyar describes the naming conventions for the Bekyar culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Bonuwat ¶
type Bonuwat struct {
BaseCulture
}
Bonuwat describes the naming conventions for the Bonuwat culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Chelaxian ¶
type Chelaxian struct {
BaseCulture
}
Chelaxian describes the naming conventions for the Chelaxian culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Chelaxian) HasGender ¶
HasGender returns true if the specified gender code is defined in the Chelaxian culture.
func (Chelaxian) HasSurnames ¶
HasSurnames returns true if the Chelaxian culture defines surnames.
type Culture ¶
type Culture interface {
Name() string
Genders() []rune
HasSurnames() bool
HasGender(rune) bool
// contains filtered or unexported methods
}
Culture is any specific cultural group with a distinctive naming convention.
Example ¶
names, err := Generate(Azlanti{}, 'M', 10)
if err != nil {
panic(fmt.Sprintf("oh, no, I can't generate names: %v", err))
}
fmt.Printf("Azlanti names: %v\n", names)
Output:
type Dwarf ¶
type Dwarf struct {
BaseCulture
}
Dwarf describes the naming conventions for the Dwarf culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Elf ¶
type Elf struct {
BaseCulture
}
Elf describes the naming conventions for the Elf culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Erutaki ¶
type Erutaki struct {
BaseCulture
}
Erutaki describes the naming conventions for the Erutaki culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Garundi ¶
type Garundi struct {
BaseCulture
}
Garundi describes the naming conventions for the Garundi culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Gnome ¶
type Gnome struct {
BaseCulture
}
Gnome describes the naming conventions for the Gnome culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type HalfOrc ¶
type HalfOrc struct {
BaseCulture
}
HalfOrc describes the naming conventions for the Half-orc culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Halfling ¶
type Halfling struct {
BaseCulture
}
Halfling describes the naming conventions for the Halfling culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Keleshite ¶
type Keleshite struct {
BaseCulture
}
Keleshite describes the naming conventions for the Keleshite culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Keleshite) HasGender ¶
HasGender returns true if the specified gender code is defined in the Keleshite culture.
func (Keleshite) HasSurnames ¶
HasSurnames returns true if the Keleshite culture defines surnames.
type Kellid ¶
type Kellid struct {
BaseCulture
}
Kellid describes the naming conventions for the Kellid culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Kitsune ¶
type Kitsune struct {
BaseCulture
}
Kitsune describes the naming conventions for the Kitsune culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Shoanti ¶
type Shoanti struct {
BaseCulture
}
Shoanti describes the naming conventions for the Shoanti culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Taldan ¶
type Taldan struct {
BaseCulture
}
Taldan describes the naming conventions for the Taldan culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Taldan) HasGender ¶
HasGender returns true if the specified gender code is defined in the Taldan culture.
func (Taldan) HasSurnames ¶
HasSurnames returns true if the Taldan culture defines surnames.
type TianDan ¶
type TianDan struct {
BaseCulture
}
TianDan describes the naming conventions for the Tian-dan culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (TianDan) HasGender ¶
HasGender returns true if the specified gender code is defined in the Tian-dan culture.
func (TianDan) HasSurnames ¶
HasSurnames returns true if the Tian-dan culture defines surnames.
type TianDtang ¶
type TianDtang struct {
BaseCulture
}
TianDtang describes the naming conventions for the Tian-dtang culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (TianDtang) HasGender ¶
HasGender returns true if the specified gender code is defined in the Tian-dtang culture.
func (TianDtang) HasSurnames ¶
HasSurnames returns true if the Tian-dtang culture defines surnames.
type TianHwan ¶
type TianHwan struct {
BaseCulture
}
TianHwan describes the naming conventions for the Tian-hwan culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (TianHwan) HasGender ¶
HasGender returns true if the specified gender code is defined in the Tian-hwan culture.
func (TianHwan) HasSurnames ¶
HasSurnames returns true if the Tian-hwan culture defines surnames.
type TianLa ¶
type TianLa struct {
BaseCulture
}
TianLa describes the naming conventions for the Tian-la culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type TianMin ¶
type TianMin struct {
BaseCulture
}
TianMin describes the naming conventions for the Tian-min culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (TianMin) HasGender ¶
HasGender returns true if the specified gender code is defined in the Tian-min culture.
func (TianMin) HasSurnames ¶
HasSurnames returns true if the Tian-min culture defines surnames.
type TianShu ¶
type TianShu struct {
BaseCulture
}
TianShu describes the naming conventions for the Tian-shu culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (TianShu) HasGender ¶
HasGender returns true if the specified gender code is defined in the Tian-shu culture.
func (TianShu) HasSurnames ¶
HasSurnames returns true if the Tian-shu culture defines surnames.
type TianSing ¶
type TianSing struct {
BaseCulture
}
TianSing describes the naming conventions for the Tian-sing culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
type Ulfen ¶
type Ulfen struct {
BaseCulture
}
Ulfen describes the naming conventions for the Ulfen culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Ulfen) HasGender ¶
HasGender returns true if the specified gender code is defined in the Ulfen culture.
func (Ulfen) HasSurnames ¶
HasSurnames returns true if the Ulfen culture defines surnames.
type Varisian ¶
type Varisian struct {
BaseCulture
}
Varisian describes the naming conventions for the Varisian culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Varisian) HasGender ¶
HasGender returns true if the specified gender code is defined in the Varisian culture.
func (Varisian) HasSurnames ¶
HasSurnames returns true if the Varisian culture defines surnames.
type Vudrani ¶
type Vudrani struct {
BaseCulture
}
Vudrani describes the naming conventions for the Vudrani culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
func (Vudrani) HasGender ¶
HasGender returns true if the specified gender code is defined in the Vudrani culture.
func (Vudrani) HasSurnames ¶
HasSurnames returns true if the Vudrani culture defines surnames.
type Zenj ¶
type Zenj struct {
BaseCulture
}
Zenj describes the naming conventions for the Zenj culture. Its methods give further details, but generally speaking the main operation to perform on these types is to just call the Generate and GenerateWithSurnames methods to create new names which conform to their cultural patterns.
Source Files
¶
- Azlanti.go
- Bekyar.go
- Bonuwat.go
- Chelaxian.go
- Dwarf.go
- Elf.go
- Erutaki.go
- Garundi.go
- Gnome.go
- Half_orc.go
- Halfling.go
- Keleshite.go
- Kellid.go
- Kitsune.go
- Shoanti.go
- Taldan.go
- Tian_dan.go
- Tian_dtang.go
- Tian_hwan.go
- Tian_la.go
- Tian_min.go
- Tian_shu.go
- Tian_sing.go
- Ulfen.go
- Varisian.go
- Vudrani.go
- Zenj.go
- namegen.go