aboutsummaryrefslogtreecommitdiff
path: root/internal/behavior/types.go
blob: 18d63637a660749a071bcbfa04b5f31a466edd69 (plain)
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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
package behavior

import (
	"strings"
)

func WordPrefixMatch(input, name string) bool {
	inputWords := strings.Fields(strings.ToLower(input))
	if len(inputWords) == 0 {
		return false
	}
	nameWords := strings.Fields(strings.ToLower(name))
	for _, iw := range inputWords {
		found := false
		for _, nw := range nameWords {
			if strings.HasPrefix(nw, iw) || strings.HasPrefix(iw, nw) {
				found = true
				break
			}
		}
		if !found {
			return false
		}
	}
	return true
}

type ActionType string

const (
	TypeGather         ActionType = "gather"
	TypeSteal          ActionType = "steal"
	TypeTalk           ActionType = "talk"
	TypeBurn           ActionType = "burn"
	TypeStoke          ActionType = "stoke"
	TypeSearch         ActionType = "search"
	TypeIdentify       ActionType = "identify"
	TypePlant          ActionType = "plant"
	TypeHarvest        ActionType = "harvest"
	TypeRake           ActionType = "rake"
	TypeWater          ActionType = "water"
	TypeCure           ActionType = "cure"
	TypeObstacle       ActionType = "obstacle"
	TypeFletch         ActionType = "fletch"
	TypeClean          ActionType = "cleaning"
	TypeCook           ActionType = "cook"
	TypeSmelt          ActionType = "smelting"
	TypeSmith          ActionType = "smith"
	TypeCraft          ActionType = "craft"
	TypeCombine        ActionType = "combine"
	TypeMix            ActionType = "mix"
	TypeConstruct      ActionType = "construct"
	TypeTriggerModule  ActionType = "trigger_module"
	TypeUseInteraction ActionType = "use_interaction"
)

type Action struct {
	Type       ActionType
	TargetID   string
	TargetName string
	WaitLeft   int
	Data       any
}

func (a *Action) Advance() bool {
	if a.WaitLeft > 0 {
		a.WaitLeft--
		return false
	}
	return true
}

type GatherData struct {
	ObjDefID     string
	InstanceKey  string
	InstanceIdx  int
	Wait         float64
	DepleteTimer bool
	Step         int
	Verb         string
	ToolName     string
	ToolType     string
}

type ProductionData struct {
	ItemID        string
	Phase         int
	TicksPerCycle float64
	StartMessage  string
	EndMessage    string
	Remaining     int
}

type StealData struct {
	TargetType    string
	StealDrops    []DropEntry
	StealLevel    int
	StealXP       int
	StealSpeed    float64
	TargetName    string
	MobInstanceID string
	ObjDefID      string
	GuardMob      string
	GuardWatching bool
}

type TalkData struct {
	Node            string
	Cfg             *TalkConfig
	SeqIndex        int
	EstateDirectory bool
	StealGuard      bool
	PendingChoice   string
	PendingAction   *NodeAction
	CancelTalk      bool
	PendingSeq      bool
	PendingChosen   bool
}

type UseInteractionData struct {
	Message string
	Action  *NodeAction
	ObjName string
}

type BurnData struct {
	ItemID    string
	ToolSpeed float64
	Level     int
	XP        int
	BurnTicks float64
	Phase     int
}

type IdentifyData struct {
	JunkID string
	XPPer  int
}

type ObstacleData struct {
	CourseID       string
	Phase          int
	ObstacleIndex  int
	TotalObstacles int
	NextRoom       int
	StartRoom      int
	OnFailRoom     int
	ObstacleXP     int
	CompletionXP   int
	// FailChance is the resolved failure probability for this attempt.
	// nil => derived at runtime from agility level vs RequiredLevel.
	FailChance     *float64
	FailDamageMin  int
	FailDamageMax  int
	Phases         []PhaseData
	RequiredLevel  int
}

// PhaseData is the runtime form of an obstacle phase.
type PhaseData struct {
	Message   string
	Delay     float64
	FailCheck bool
}

type FarmData struct {
	Prefix   string
	SeedID   string
	XP       float64
	Product  string
	MinYield float64
	MaxYield float64
}

type SearchData struct {
	ItemID  string
	SlotIdx int
	Started bool
}

type CombineData struct {
	ItemID        string
	Phase         int
	StepIndex     int
	Remaining     int
	StartMessage  string
	EndMessage    string
	TicksPerCycle float64
}

type FletchData struct {
	ItemID        string
	Phase         int
	TicksPerCycle float64
	Remaining     int
}

type CleanData struct {
	Phase  int
	Filter string
}

type ModTriggerStep struct {
	Message string `yaml:"message"`
	Delay   int    `yaml:"delay"`
}

type TriggerModuleData struct {
	ModID     string
	Steps     []ModTriggerStep
	StepIndex int
}

type DropEntry struct {
	ItemID         string `yaml:"item_id"`
	Table          string `yaml:"table"`
	Tool           string `yaml:"tool,omitempty"`
	Weight         int    `yaml:"weight"`
	Quantity       int    `yaml:"quantity"`
	Depletes       bool   `yaml:"depletes"`
	SuccessMessage string `yaml:"success_message"`
	Level          int    `yaml:"level"`
	XP             int    `yaml:"xp"`
}

type DropTableDef struct {
	Drops []DropEntry `yaml:"drops"`
}