-
Notifications
You must be signed in to change notification settings - Fork 0
/
traits_default.go
195 lines (165 loc) · 7.01 KB
/
traits_default.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
package aifiver
// DefaultTraits adds the default traits to the traiter.
// These are just examples. If you have suggestions for better traits, please
// open an issue or a pull request!
func DefaultTraits(tt *Traiter) {
traitParanoid := NewTrait("Paranoid", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreTrust) < -6
})
traitParanoid.Stats.Skill[TSkillDiplomacy] = -5
traitParanoid.Stats.Skill[TSkillIntrigue] = 5
tt.AddTrait(traitParanoid)
traitGullable := NewTrait("Gullable", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreTrust)+p.GetFacet(FacetAgreCompliance) > 15
})
traitGullable.Stats.Skill[TSkillDiplomacy] = -5
traitGullable.Stats.Skill[TSkillIntrigue] = -5
tt.AddTrait(traitGullable)
MarkOppositeTraits(traitParanoid, traitGullable)
traitChaste := NewTrait("Chaste", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurImpulsiveness) < -5
})
traitChaste.Stats.Skill[TSkillLearning] = 2
traitChaste.Stats.Opinion[TOpinionSame] = 10
traitChaste.Stats.Opinion[TOpinionOpposite] = -10
tt.AddTrait(traitChaste)
traitLustful := NewTrait("Lustful", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurImpulsiveness) > 5
})
traitLustful.Stats.Skill[TSkillIntrigue] = 2
traitLustful.Stats.Opinion[TOpinionSame] = 10
traitLustful.Stats.Opinion[TOpinionOpposite] = -10
tt.AddTrait(traitLustful)
MarkOppositeTraits(traitChaste, traitLustful)
traitHonest := NewTrait("Honest", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurImpulsiveness) < -6 &&
p.GetFacet(FacetConsDutifulness) > 6 &&
p.GetFacet(FacetAgreAltruism) > 2 &&
p.GetFacet(FacetAgreStraightforwardness) > 2
})
traitHonest.Stats.Skill[TSkillDiplomacy] = 2
traitHonest.Stats.Skill[TSkillIntrigue] = -4
traitHonest.Stats.Opinion[TOpinionSame] = 10
traitHonest.Stats.Opinion[TOpinionOpposite] = -10
tt.AddTrait(traitHonest)
traitDeceitful := NewTrait("Deceitful", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreAltruism) < 0 &&
p.GetFacet(FacetAgreStraightforwardness) < 2 &&
p.GetFacet(FacetAgreModesty) < -5
})
traitDeceitful.Stats.Skill[TSkillDiplomacy] = -2
traitDeceitful.Stats.Skill[TSkillIntrigue] = 4
traitDeceitful.Stats.Opinion[TOpinionOpposite] = -10
tt.AddTrait(traitDeceitful)
MarkOppositeTraits(traitHonest, traitDeceitful)
traitGenerous := NewTrait("Generous", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreAltruism) > 6
})
traitGenerous.Stats.Skill[TSkillDiplomacy] = 2
traitGenerous.Stats.Skill[TSkillIntrigue] = -2
traitGenerous.Stats.Opinion[TOpinionOpposite] = -15
tt.AddTrait(traitGenerous)
traitGreedy := NewTrait("Greedy", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreAltruism) < -6
})
traitGreedy.Stats.Skill[TSkillDiplomacy] = -2
traitGreedy.Stats.Skill[TSkillIntrigue] = 2
tt.AddTrait(traitGreedy)
MarkOppositeTraits(traitGenerous, traitGreedy)
traitJust := NewTrait("Just", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreAltruism) > 6 &&
p.GetFacet(FacetAgreStraightforwardness) > 6
})
traitJust.Stats.Skill[TSkillDiplomacy] = 2
traitJust.Stats.Skill[TSkillIntrigue] = -2
traitJust.Stats.Skill[TSkillParenting] = 2
tt.AddTrait(traitJust)
traitArbitrary := NewTrait("Arbitrary", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreAltruism) < -6 &&
p.GetFacet(FacetAgreStraightforwardness) < -6
})
traitArbitrary.Stats.Skill[TSkillDiplomacy] = -2
traitArbitrary.Stats.Skill[TSkillIntrigue] = 2
traitArbitrary.Stats.Skill[TSkillParenting] = -2
tt.AddTrait(traitArbitrary)
MarkOppositeTraits(traitJust, traitArbitrary)
traitBrave := NewTrait("Brave", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) < -6 &&
p.GetFacet(FacetNeurAngryHostility) < -6
})
traitBrave.Stats.Skill[TSkillMartial] = 2
traitBrave.Stats.Skill[TSkillProwess] = 3
traitBrave.Stats.Skill[TSkillIntrigue] = -2
tt.AddTrait(traitBrave)
traitCowardly := NewTrait("Cowardly", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) > 6 &&
p.GetFacet(FacetNeurAngryHostility) > 6
})
traitCowardly.Stats.Skill[TSkillMartial] = -2
traitCowardly.Stats.Skill[TSkillProwess] = -3
traitCowardly.Stats.Skill[TSkillIntrigue] = 2
tt.AddTrait(traitCowardly)
MarkOppositeTraits(traitBrave, traitCowardly)
traitPatient := NewTrait("Patient", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) < -6 &&
p.GetFacet(FacetNeurAngryHostility) > 6 &&
p.GetFacet(FacetNeurImpulsiveness) < -4
})
traitPatient.Stats.Skill[TSkillMartial] = 2
traitPatient.Stats.Skill[TSkillIntrigue] = -2
traitPatient.Stats.Skill[TSkillParenting] = 2
tt.AddTrait(traitPatient)
traitImpatient := NewTrait("Impatient", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) > 6 &&
p.GetFacet(FacetNeurAngryHostility) < -6 &&
p.GetFacet(FacetNeurImpulsiveness) > 4
})
traitImpatient.Stats.Skill[TSkillMartial] = -2
traitImpatient.Stats.Skill[TSkillIntrigue] = 2
traitImpatient.Stats.Skill[TSkillParenting] = -2
tt.AddTrait(traitImpatient)
MarkOppositeTraits(traitPatient, traitImpatient)
traitHumble := NewTrait("Humble", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreModesty) > 6
})
traitHumble.Stats.Skill[TSkillDiplomacy] = 2
traitHumble.Stats.Skill[TSkillIntrigue] = -2
tt.AddTrait(traitHumble)
traitProud := NewTrait("Proud", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetAgreModesty) < -6
})
traitProud.Stats.Skill[TSkillDiplomacy] = -2
traitProud.Stats.Skill[TSkillIntrigue] = 2
tt.AddTrait(traitProud)
MarkOppositeTraits(traitHumble, traitProud)
traitGregarious := NewTrait("Gregarious", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetExtrGregariousness) > 6
})
traitGregarious.Stats.Skill[TSkillDiplomacy] = 2
traitGregarious.Stats.Opinion[TOpinionSame] = 10
tt.AddTrait(traitGregarious)
traitSolitary := NewTrait("Solitary", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetExtrGregariousness) < -6
})
traitSolitary.Stats.Skill[TSkillLearning] = 2
traitSolitary.Stats.Opinion[TOpinionSame] = 10
tt.AddTrait(traitSolitary)
MarkOppositeTraits(traitGregarious, traitSolitary)
traitCalm := NewTrait("Calm", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) < -6 &&
p.GetFacet(FacetNeurAngryHostility) < -6
})
traitCalm.Stats.Skill[TSkillDiplomacy] = 1
traitCalm.Stats.Skill[TSkillIntrigue] = 1
traitCalm.Stats.Opinion[TOpinionSame] = 10
traitCalm.Stats.Opinion[TOpinionOpposite] = -10
tt.AddTrait(traitCalm)
traitVengeful := NewTrait("Vengeful", TTypePersonality, func(p *Personality) bool {
return p.GetFacet(FacetNeurAnxiety) > 6 &&
p.GetFacet(FacetNeurAngryHostility) > 6
})
traitVengeful.Stats.Skill[TSkillDiplomacy] = -1
traitVengeful.Stats.Skill[TSkillMartial] = 4
tt.AddTrait(traitVengeful)
MarkOppositeTraits(traitCalm, traitVengeful)
}