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
229
230
231
232
233
234
235
236
237
238
239
|
# El sistema ScriptAI
El sistema ScriptAI implementado por AC utiliza una estrategia especial: [Patrón del observador](https://en.wikipedia.org/wiki/Observer_pattern) para implementar una programación dirigida por eventos que es también el **CORE** de nuestro sistema modular.
Esta guía, junto con nuestro [sistema de módulos](create-a-module.md) te permite ampliar el AzerothCore sin parchearlo directamente. ¡Esto le permite actualizar su repositorio manteniendo sus adiciones y personalizaciones libres de conflictos!
## Recursos
### Lista de hooks
La lista de los hooks se encuentra dentro del archivo [ScriptMgr.h](https://github.com/azerothcore/azerothcore-wotlk/blob/master/src/server/game/Scripting/ScriptMgr.h)
### Glosario
- **Hook**: Una función que se declara dentro de un **_ScriptObject_** y que es definida por el **_Listeners_**
- **ScriptObject**: Clase abstracta que debe ser extendida para crear el **_Observer_**.
- **Script type**: La clase que extiende el `ScriptObject` y contiene hooks (por ejemplo, `PLayerScript`, `CreatureScript`, etc.), cuando extiendes la clase de tipo script estás inicializando un **_Concrete Observer_**
- **ScriptRegistry**: Esta clase contiene el registro de todos los `Observers` registrados.
- **ScriptMgr**: La clase singleton que contiene la lista de todos los hooks disponibles y actúa como un **_Observer_** notificando a los **_Listeners_** cuando se despacha un evento.
## Cómo crear un hook
¡No se preocupe, no es tan aterrador como puede pensar!.
Antes de pasar al siguiente paso deberías preguntarte: ¿tengo que crear un nuevo tipo de script basado en la clase `ScriptObject` o puedo reutilizar uno de los ya existentes?
Un tipo de script suele estar estrictamente relacionado con una determinada clase del core. Por ejemplo:
- `PlayerScript` -> `Player` class
- `WorldScript` -> `World` class
- `CreatureScript` -> `Creature` class
Y así sucesivamente.
Hay algunas excepciones como el `GlobalScript` que es un Observador utilizado en diferentes clases a lo largo del núcleo. Pero en general, un tipo de script debe referirse a una clase específica.
Por lo tanto, si ha creado una nueva clase que tiene que ser extendida con hooks, entonces puede proceder con el primer punto.
Sin embargo, la mayoría de las veces sólo tienes que añadir nuevos hooks a los scripts existentes, en este caso sólo salta al punto 2 de este capítulo.
### 1) Procedimiento estándar al añadir nuevas clases de scripts
En primer lugar, define la clase actual, y haz que herede de `ScriptObject`, así:
```cpp
class MyScriptType : public ScriptObject
{
uint32 _someId;
private:
void RegisterSelf();
protected:
MyScriptType(const char* name, uint32 someId)
: ScriptObject(name), _someId(someId)
{
ScriptRegistry<MyScriptType>::AddScript(this);
}
public:
// Si una función virtual en tu clase de tipo script
// no tiene que ser necesariamente anulada, simplemente declárala virtual
// con un cuerpo vacío. Si, por el contrario, es lógico anularla
// (es decir, si es el único método de la clase), hazla virtual pura, añadiéndole = 0.
virtual void OnBeforeSomeEvent(uint32 /*someArg1*/, std::string& /*someArg2/*) { }
// Esta es una función virtual pura:
virtual void OnAnotherEvent(uint32 /*someArg*/) = 0;
}
```
A continuación, tienes que añadir una especialización para ScriptRegistry. Pon esto al principio de `ScriptMgr.cpp`:
```cpp
template class ScriptRegistry<MyScriptType>;
```
Ahora añade el registro en la parte inferior del `ScriptMgr.cpp`:
```cpp
MyScriptType::MyScriptType(const char* name)
: ScriptObject(name)
{
ScriptRegistry<MyScriptType>::AddScript(this);
}
```
Entonces añade una rutina de limpieza en `ScriptMgr::unload()`.
```
SCR_CLEAR(MyScriptType);
```
¡Y finalmente tu clase está lista para funcionar con el sistema de scripts!
### 2) Implementar las funciones de los hooks
Si no has seguido el punto 1 y quieres reutilizar un `ScriptObject` existente, entonces tienes que declarar primero las funciones dentro de una de las clases de `ScriptObject` preexistentes (como `PlayerScript`, `ServerScript`, etc.)
#### Declarar los hooks
Lo que tienes que hacer ahora es añadir funciones a `ScriptMgr` que puedan ser llamadas desde el núcleo para desencadenar realmente ciertos eventos.
En `ScriptMgr.h`, dentro de `class ScriptMgr`
```cpp
void OnBeforeSomeEvent(uint32 someArg1, std::string& someArg2);
void OnAnotherEvent(uint32 someArg);
```
**NOTA:** para ciertos scripts el método declarado dentro de la clase `ScriptMgr` y el declarado en el `ScriptObject` relacionado, no siempre coinciden. Por ejemplo: `OnLogin` es un hook del PlayerScript que se declara como `OnPlayerLogin` cuando se utiliza dentro de la clase `ScriptMgr`, evitando así colisiones con otros métodos ya que la clase `ScriptMgr` recoge los hooks de todos los `ScriptObjects` dentro de la misma lista.
#### Defina sus hooks
Este paso define la forma en que su hook debe llamar a los listeners registrados.
La forma más habitual de hacerlo es la siguiente
En `ScriptMgr.cpp`:
```cpp
void ScriptMgr::OnBeforeSomeEvent(uint32 someArg1, std::string& someArg2)
{
FOREACH_SCRIPT(MyScriptType)->OnBeforeSomeEvent(someArg1, someArg2);
}
void ScriptMgr::OnAnotherEvent(uint32 someArg)
{
FOREACH_SCRIPT(MyScriptType)->OnAnotherEvent(someArg);
}
```
Ahora basta con llamar a estas dos funciones desde cualquier lugar del core para activar el evento en todos los scripts registrados de ese tipo.
### Cómo llamar a tus hooks
La clase `ScriptMgr` se inicializa dentro del AC como un singleton que contendrá todos los observers (ScriptObjects) y sus listeners registrados relacionados (hooks). AC proporciona una propiedad global llamada "sScriptMgr" que puede utilizar para llamar a su script dentro de las funciones de AC.
Por ejemplo:
```cpp
void CoreClass::SomeEvent()
{
uint32 arg1=10;
std::string arg2="something";
sScriptMgr->OnBeforeSomeEvent(arg1, arg2);
//[...]
}
```
## Documentar su hook
Recuerda documentar tu nuevo hook siguiendo la guía [Cómo documentar tu código](how-to-document-code.md).
Cuando creas un nuevo hook para publicarlo en el repo de `AzerothCore`, uno de los criterios de aceptación es escribir una documentación adecuada para él, para que otras personas sepan cómo usarlo correctamente. Así que, por favor, lee esa guía con atención.
### Escribir un registro de cambios
Cuando creas o modificas cualquier hook, tienes que crear un nuevo changelog para explicar a la gente cómo adaptar su código y mantenerlos informados sobre estos cambios. Por favor, siga [esta guía](how-to-use-changelog.md) para aprender a hacerlo.
## Convenciones de nomenclatura
Cada `hook` debe tener la siguiente convención de nombres:
`On[When]<Action>`
Por ejemplo:
- `OnBeforeConfigLoad`
- `OnAfterArenaRatingCalculation`
La acción normalmente coincide con el nombre de la función dentro de la cual se llama al `hook`.
Si la función madre es lo suficientemente compleja como para contener diferentes hooks, entonces la acción debe reflejar para qué se utiliza el `hook`.
La parte "Cuando" es opcional, pero se recomienda encarecidamente.
Ayuda a entender en qué parte de la función padre se llama al `hook`.
Por ejemplo, puedes tener tanto `OnBeforeConfigLoad` como `OnAfterConfigLoad`, para cambiar el comportamiento antes y después de cargar la configuración.
## Hooks avanzados
### Cómo cambiar el comportamiento de una función (filtrado)
Con los hooks no sólo puedes ejecutar acciones específicas en un momento determinado, incluso puedes cambiar el comportamiento de la función donde se llama al `hook` para hacerlo, tienes 2 soluciones:
#### 1) Utilización de los parámetros de referencia
Este es el más común. Básicamente utilizando el concepto de pasar un parámetro por referencia se puede cambiar todo lo que se pasa al propio `hook`.
Por ejemplo:
```cpp
OnMotdChange(std::string& newMotd)
```
Pasando el `newMotd` con el carácter '&' se permite a los listeners cambiar el valor del `Motd` cuando se llama a esa acción.
#### 2) Utilizar un valor de retorno `bool`
Este enfoque no es muy común, la mayoría de los hooks devuelven un tipo **"void"**, y trabajar con referencias es más fácil la mayoría de las veces, pero si realmente lo necesitas puedes implementar un hook declarado de esta manera:
```cpp
bool ScriptMgr::OnBeforePlayerTeleport(Player* player, uint32 mapid, float x, float y, float z, float orientation, uint32 options, Unit* target)
{
bool ret = true;
FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // Devuelve true por defecto si no son scripts
if (!itr->second->OnBeforeTeleport(player, mapid, x, y, z, orientation, options, target))
ret = false; // Cambiamos el valor de ret sólo cuando los scripts devuelven false
return ret;
}
```
Este hook notifica a todos los listeners pero también captura cuando al menos uno de los listeners registrados devuelve **"false"**, en ese caso el valor de retorno final también será false.
En este caso particular, este hook se utiliza dentro de una condición if para no permitir que un jugador sea teletransportado si uno de los listeners devuelve **false** por alguna razón.
Puedes implementar tu lógica diferente (por ejemplo, falso por defecto, verdadero si lo hay) sólo recuerda documentarlo adecuadamente.
### Cree su sistema de hooks dentro de su módulo
Usando la guía anterior puedes incluso crear tu `ScriptObject` dentro de tu módulo para permitir que la gente lo extienda.
Algunos módulos, como el de balance automático, permiten personalizar cierta parte de su función mediante el uso de hooks internos.
Puede ver este archivo como ejemplo: https://github.com/azerothcore/mod-autobalance/blob/master/src/AutoBalance.h
**NOTA:** También necesitas crear tu propia implementación de `ScriptMgr` y ofrecer un singleton que permita llamar a tus hooks.
### Consideraciones finales
Existen otras características del sistema `ScriptAI` que no han sido incluidas en esta documentación, como la creación de scripts vinculados a entidades específicas dentro de nuestra base de datos (Ej. `CreatureScript`). Este uso avanzado puede ser implementado replicando el código relacionado que tenemos dentro de los archivos `ScriptMgr`. Si necesitas ayuda o quieres mejorar esta documentación, no dudes en pedir apoyo y editar esta página.
## Recursos externos
- [Stack overflow topic: Is it possible to turn a core patch into a module for AzerothCore?](https://stackoverflow.com/questions/66340549/is-it-possible-to-turn-a-core-patch-into-a-module-for-azerothcore/66340683#66340683)
|
