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
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "../common/timer.hpp"
#include "../common/nullpo.hpp"
#include "../common/mt_rand.hpp"
#include "magic.hpp"
#include "battle.hpp"
#include "clif.hpp"
#include "intif.hpp"
#include "itemdb.hpp"
#include "map.hpp"
#include "mob.hpp"
#include "party.hpp"
#include "pc.hpp"
#include "script.hpp"
#include "skill.hpp"
#include "../common/socket.hpp"
#ifdef MEMWATCH
#include "memwatch.hpp"
#endif
int skill_pool_skills[MAX_POOL_SKILLS];
int skill_pool_skills_size = 0;
void skill_pool_register(int id)
{
if (skill_pool_skills_size + 1 >= MAX_POOL_SKILLS)
{
fprintf (stderr,
"Too many pool skills! Increase MAX_POOL_SKILLS and recompile.");
return;
}
skill_pool_skills[skill_pool_skills_size++] = id;
}
const char *skill_name (int skill)
{
if (skill > 0 && skill < MAX_SKILL_DB)
return skill_names[skill].desc;
else
return NULL;
}
int skill_pool (struct map_session_data *sd, int *skills)
{
int i, count = 0;
for (i = 0; count < MAX_SKILL_POOL && i < skill_pool_skills_size; i++)
{
int skill_id = skill_pool_skills[i];
if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
{
if (skills)
skills[count] = skill_id;
++count;
}
}
return count;
}
void skill_pool_empty (struct map_session_data *sd)
{
int i;
for (i = 0; i < skill_pool_skills_size; i++)
{
int skill_id = skill_pool_skills[i];
sd->status.skill[skill_id].flags = 0;
}
}
int skill_pool_size (struct map_session_data *sd)
{
return skill_pool (sd, NULL);
}
int skill_pool_max (struct map_session_data *sd)
{
return sd->status.skill[TMW_SKILLPOOL].lv;
}
int skill_pool_activate (struct map_session_data *sd, int skill_id)
{
if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
return 0; // Already there
else if (sd->status.skill[skill_id].id == skill_id // knows the skill
&& (skill_pool_size (sd) < skill_pool_max (sd)))
{
sd->status.skill[skill_id].flags |= SKILL_POOL_ACTIVATED;
pc_calcstatus (sd, 0);
MAP_LOG_PC (sd, "SKILL-ACTIVATE %d %d %d", skill_id,
sd->status.skill[skill_id].lv, skill_power (sd,
skill_id));
return 0;
}
return 1; // failed
}
int skill_pool_is_activated (struct map_session_data *sd, int skill_id)
{
return sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED;
}
int skill_pool_deactivate (struct map_session_data *sd, int skill_id)
{
if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
{
sd->status.skill[skill_id].flags &= ~SKILL_POOL_ACTIVATED;
MAP_LOG_PC (sd, "SKILL-DEACTIVATE %d", skill_id);
pc_calcstatus (sd, 0);
return 0;
}
return 1;
}
int skill_stat (int skill_id)
{
return skill_db[skill_id].stat;
}
int skill_power (struct map_session_data *sd, int skill_id)
{
int stat = skill_stat (skill_id);
int stat_value, skill_value;
int result;
if (stat == 0 || !skill_pool_is_activated (sd, skill_id))
return 0;
stat_value = battle_get_stat (stat, &(sd->bl));
skill_value = sd->status.skill[skill_id].lv;
if ((skill_value * 10) - 1 > stat_value)
skill_value += (stat_value / 10);
else
skill_value *= 2;
result = (skill_value * stat_value) / 10;
return result;
}
int skill_power_bl (struct block_list *bl, int skill)
{
if (bl->type == BL_PC)
return skill_power ((struct map_session_data *) bl, skill);
else
return 0;
}
|
