void spoil_powers_aux(FILE *fff, power_info *table)
{
int i;
variant vn, vd;
var_init(&vn);
var_init(&vd);
fprintf(fff, "\n== Powers ==\n");
fprintf(fff, "|| || *Stat* || *Lvl* || *Cost* || *Fail* || *Description* ||\n");
for (i = 0; ; i++)
{
power_info *base = &table[i];
if (!base->spell.fn) break;
base->spell.fn(SPELL_SPOIL_NAME, &vn);
if (var_is_null(&vn)) base->spell.fn(SPELL_NAME, &vn);
base->spell.fn(SPELL_SPOIL_DESC, &vd);
if (var_is_null(&vd)) base->spell.fn(SPELL_DESC, &vd);
fprintf(fff, "||%s||%s||%d||%d||%d||`%s`||\n",
var_get_string(&vn),
stat_abbrev_true[base->stat],
base->spell.level, base->spell.cost, base->spell.fail,
var_get_string(&vd)
);
}
var_clear(&vn);
var_clear(&vd);
}
void spoil_spells_aux(FILE *fff, spell_info *table)
{
int i;
variant vn, vd;
var_init(&vn);
var_init(&vd);
fprintf(fff, "\n== Spells ==\n");
fprintf(fff, "|| || *Lvl* || *Cost* || *Fail* || *Description* ||\n");
for (i = 0; ; i++)
{
spell_info *base = &table[i];
if (!base->fn) break;
base->fn(SPELL_SPOIL_NAME, &vn);
if (var_is_null(&vn)) base->fn(SPELL_NAME, &vn);
base->fn(SPELL_SPOIL_DESC, &vd);
if (var_is_null(&vd)) base->fn(SPELL_DESC, &vd);
fprintf(fff, "||%s||%d||%d||%d||`%s`||\n",
var_get_string(&vn), base->level, base->cost, base->fail, var_get_string(&vd));
}
var_clear(&vn);
var_clear(&vd);
}
void default_spell(int cmd, variant *res) /* Base class */
{
switch (cmd)
{
case SPELL_NAME:
var_set_string(res, "Unknown Spell");
break;
case SPELL_DESC:
case SPELL_INFO:
case SPELL_MUT_DESC:
var_set_string(res, "");
break;
case SPELL_GAIN_MUT:
case SPELL_LOSE_MUT:
var_clear(res);
break;
case SPELL_FAIL:
case SPELL_STOP:
case SPELL_CONT:
var_set_bool(res, TRUE);
break;
case SPELL_CAST:
msg_print("Zap?");
var_set_bool(res, TRUE);
break;
case SPELL_COST_EXTRA:
case SPELL_FAIL_MIN:
var_set_int(res, 0);
break;
case SPELL_ENERGY:
var_set_int(res, 100);
break;
case SPELL_CALC_BONUS:
var_set_bool(res, TRUE);
break;
case SPELL_COLOR:
var_set_int(res, TERM_WHITE);
break;
case SPELL_ON_BROWSE:
var_set_bool(res, FALSE);
break;
default:
var_clear(res);
break;
}
}
static void _list(menu_ptr menu, char *keys)
{
char temp[255];
int i;
int y = 1;
int x = 13;
Term_erase(x, y, 255);
if (menu->heading)
put_str(format(" %s", menu->heading), y++, x);
for (i = 0; i < menu->count; i++)
{
byte attr = TERM_WHITE;
variant key, text, color;
var_init(&key);
var_init(&text);
var_init(&color);
menu->fn(MENU_KEY, i, menu->cookie, &key);
if (var_is_null(&key))
keys[i] = I2A(i);
else
keys[i] = (char)var_get_int(&key);
if (menu->count <= 26)
keys[i] = tolower(keys[i]);
menu->fn(MENU_TEXT, i, menu->cookie, &text);
if (var_is_null(&text))
var_set_string(&text, "");
menu->fn(MENU_COLOR, i, menu->cookie, &color);
if (!var_is_null(&color))
attr = var_get_int(&color);
if (attr == TERM_DARK)
keys[i] = '\0';
sprintf(temp, " %c) %s", keys[i], var_get_string(&text));
c_prt(attr, temp, y + i, x);
var_clear(&key);
var_clear(&text);
var_clear(&color);
}
Term_erase(x, y + menu->count, 255);
}
void _gain_power(int level)
{
int group_idx = -1;
if (level % 2 == 1)
group_idx = level/2;
if (group_idx >= 0 && group_idx < _MAX_TALENTS && _group_size(group_idx) > 0)
{
variant name;
int idx = randint0(_group_size(group_idx));
talent_t *talent = &_talents[group_idx][idx];
if (!talent->spell.fn)
{
msg_print("BUG: Where is your talent?!");
return;
}
var_init(&name);
(talent->spell.fn)(SPELL_NAME, &name);
msg_format("You gain the power of '%s' %s.", var_get_string(&name), talent->gain_desc);
p_ptr->magic_num1[group_idx] = idx + 1;
var_clear(&name);
}
}
void
id_item_default_release(id_item_t *item)
{
assert(item != NULL);
switch (item->type) {
case ID_VAR:
if (item->var != NULL) {
var_clear(item->var);
ufree(item->var);
item->var = NULL;
}
break;
case ID_ARR:
if (item->arr != NULL) {
arr_free(item->arr);
item->arr = NULL;
}
break;
case ID_UNKNOWN:
default:
error(1, "unknown id type\n");
break;
}
}
void fail_spell(ang_spell spell)
{
variant res;
var_init(&res);
spell(SPELL_FAIL, &res);
var_clear(&res);
}
static void _character_dump(doc_ptr doc)
{
int i;
spell_info spells[MAX_SPELLS];
int ct = _get_spells_imp(spells, MAX_SPELLS, 0, _MAX_TALENTS - 1);
for (i = 0; i < ct; i++)
{
spell_info* current = &spells[i];
current->cost += get_spell_cost_extra(current->fn);
current->fail = MAX(current->fail, get_spell_fail_min(current->fn));
}
if (ct > 0)
{
int i;
variant name, info;
var_init(&name);
var_init(&info);
doc_printf(doc, "<topic:WildTalent>================================= <color:keypress>W</color>ild Talents ================================\n\n");
doc_printf(doc, "<color:G>%-23.23s Lv Stat Cost Fail Info</color>\n", "");
for (i = 0; i < ct; ++i)
{
spell_info *spell = &spells[i];
(spell->fn)(SPELL_NAME, &name);
(spell->fn)(SPELL_INFO, &info);
doc_printf(doc, "%-23.23s %2d %4.4s %4d %3d%% %s\n",
var_get_string(&name),
spell->level,
stat_abbrev_true[_which_stat(i)],
spell->cost,
spell->fail,
var_get_string(&info));
}
var_clear(&name);
var_clear(&info);
doc_newline(doc);
}
}
void dump_spells_aux(FILE *fff, spell_info *table, int ct)
{
int i;
variant vn, vd, vc, vfm;
if (!ct) return;
var_init(&vn);
var_init(&vd);
var_init(&vc);
var_init(&vfm);
if (character_dump_hack)
{
fprintf(fff, "=================================== Spells ====================================\n\n");
fprintf(fff, "%-20.20s Lvl Cost Fail %-15.15s Cast Fail\n", "", "Desc");
}
else
{
fprintf(fff, "\n[[[[r|%-20.20s Lvl Cost Fail %-15.15s Cast Fail\n", "Spells", "Desc");
}
for (i = 0; i < ct; i++)
{
spell_info *spell = &table[i];
spell_stats_ptr stats = spell_stats(spell);
spell->fn(SPELL_NAME, &vn);
spell->fn(SPELL_INFO, &vd);
spell->fn(SPELL_COST_EXTRA, &vc);
spell->fn(SPELL_FAIL_MIN, &vfm);
fprintf(fff, "%-20.20s %3d %4d %3d%% %-15.15s %4d %4d %3d%%\n",
var_get_string(&vn),
spell->level, calculate_cost(spell->cost + var_get_int(&vc)), MAX(spell->fail, var_get_int(&vfm)),
var_get_string(&vd),
stats->ct_cast, stats->ct_fail,
spell_stats_fail(stats)
);
}
var_clear(&vn);
var_clear(&vd);
var_clear(&vc);
var_clear(&vfm);
}
static int _choose_spell(spell_info* spells, int ct, cptr desc, int max_cost)
{
int choice = -1;
char prompt1[140];
char prompt2[140];
variant name;
bool describe = FALSE;
var_init(&name);
for (;;)
{
char ch = '\0';
strnfmt(prompt1, 78, "Use which %s? (Type '?' to Browse) ", desc);
strnfmt(prompt2, 78, "Browse which %s? (Type '?' to Use)", desc);
_list_spells(spells, ct, max_cost);
/* Prompt User */
choice = -1;
if (!get_com(describe ? prompt2 : prompt1, &ch, FALSE)) break;
if (ch == '?')
{
describe = !describe;
if (!get_com(describe ? prompt2 : prompt1, &ch, FALSE)) break;
}
if (isupper(ch))
choice = ch - 'A' + 26;
else if (islower(ch))
choice = ch - 'a';
else if (ch >= '0' && ch <= '9')
choice = ch - '0' + 52;
/* Valid Choice? */
if (choice < 0 || choice >= ct)
{
bell();
continue;
}
if (describe)
{
_describe_spell(&spells[choice], _col_height(ct));
continue;
}
/* Good to go! */
break;
}
var_clear(&name);
return choice;
}
int get_spell_energy(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_ENERGY, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
int get_spell_cost_extra(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_COST_EXTRA, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
int get_spell_fail_min(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_FAIL_MIN, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
cptr get_spell_name(ang_spell spell)
{
static char buf[255];
variant v;
var_init(&v);
spell(SPELL_NAME, &v);
sprintf(buf, "%s", var_get_string(&v));
var_clear(&v);
return buf;
}
cptr get_spell_desc(ang_spell spell)
{
static char buf[1024];
variant v;
var_init(&v);
spell(SPELL_DESC, &v);
sprintf(buf, "%s", var_get_string(&v));
var_clear(&v);
return buf;
}
bool cast_spell(ang_spell spell)
{
bool b;
variant res;
var_init(&res);
spell(SPELL_CAST, &res);
b = var_get_bool(&res);
var_clear(&res);
return b;
}
void mut_name(int i, char* buf)
{
variant v;
var_init(&v);
if (i >= 0 && i < MAX_MUTATIONS)
(_mutations[i].spell.fn)(SPELL_NAME, &v);
else
var_set_string(&v, "None");
sprintf(buf, "%s", var_get_string(&v));
var_clear(&v);
}
bool mut_gain(int mut_idx)
{
variant v;
if (mut_idx < 0 || mut_idx >= MAX_MUTATIONS) return FALSE;
if (mut_present(mut_idx)) return FALSE;
var_init(&v);
add_flag(p_ptr->muta, mut_idx);
(_mutations[mut_idx].spell.fn)(SPELL_GAIN_MUT, &v);
var_clear(&v);
_mut_refresh();
return TRUE;
}
bool mut_lose(int mut_idx)
{
variant v;
if (mut_idx < 0 || mut_idx >= MAX_MUTATIONS) return FALSE;
if (!mut_present(mut_idx)) return FALSE;
if (mut_locked(mut_idx)) return FALSE;
var_init(&v);
remove_flag(p_ptr->muta, mut_idx);
(_mutations[mut_idx].spell.fn)(SPELL_LOSE_MUT, &v);
var_clear(&v);
_mut_refresh();
return TRUE;
}
void mut_dump_file(FILE* file)
{
int i;
variant desc;
var_init(&desc);
for (i = 0; i < MAX_MUTATIONS; ++i)
{
if (mut_present(i))
{
(_mutations[i].spell.fn)(SPELL_MUT_DESC, &desc);
fprintf(file, "%s\n", var_get_string(&desc));
}
}
var_clear(&desc);
}
void
var_clearv(struct variable *var, ...)
{
struct variable *p;
va_list ap;
va_start(ap, var);
p = var;
while (p != NULL) {
var_clear(p);
p = va_arg(ap, struct variable *);
}
va_end(ap);
}
void mut_calc_bonuses(void)
{
int i;
variant v;
var_init(&v);
for (i = 0; i < MAX_MUTATIONS; i++)
{
if ( mut_present(i)
&& (_mutations[i].type & MUT_TYPE_BONUS) )
{
(_mutations[i].spell.fn)(SPELL_CALC_BONUS, &v);
}
}
var_clear(&v);
}
/**
@details
Send mtv event data through the variable server.
-# For each event in the mtv_list
-# call var_add() for all the event information
-# Send the size of list of variables we've added
-# Send the data
-# Clear the var_add list.
*/
int Trick::MTV::send_event_data() {
char varname[80];
const char *mtv_name = "trick_ip.mtv.mtv_list";
unsigned int ii ;
int jj;
for (ii=0; ii < mtv_count; ii++) {
sprintf(varname, "%s[%d][0].name", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].active", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].added", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].condition_count", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].action_count", mtv_name,ii);
var_add(varname);
sprintf(varname, "%s[%d][0].before_after", mtv_name,ii);
var_add(varname);
for (jj=0; jj< mtv_list[ii]->condition_count; jj++) {
sprintf(varname, "%s[%d][0].cond[%d].comment", mtv_name,ii,jj);
var_add(varname);
}
for (jj=0; jj< mtv_list[ii]->action_count; jj++) {
sprintf(varname, "%s[%d][0].act[%d].comment", mtv_name,ii,jj);
var_add(varname);
}
if (mtv_list[ii]->get_before_after() > 0) {
sprintf(varname, "%s[%d][0].target_name", mtv_name,ii);
var_add(varname);
}
}
var_send_list_size() ;
var_send() ;
var_clear() ;
return 0 ;
}
static void _spell_menu_fn(int cmd, int which, vptr cookie, variant *res)
{
_spell_menu_t *ss = (_spell_menu_t*)cookie;
_spell_menu_t *s = ss + which;
switch (cmd)
{
case MENU_TEXT:
if (s->total_charges)
{
char buf[1024];
_kind_t k = s->spell->kind;
cptr info = _do_device(s->spell->kind.tval, s->spell->kind.sval, SPELL_INFO);
sprintf(buf, "%-22.22s %3d %3d %3d%% ", _kind_name(&k), s->charges, s->total_charges, s->fail);
if (info)
strcat(buf, info);
var_set_string(res, buf);
}
else
var_clear(res);
break;
case MENU_HELP:
var_set_string(res, _kind_desc(&s->spell->kind));
break;
case MENU_COLOR:
if (!s->total_charges)
var_set_int(res, TERM_DARK);
else if (!s->charges)
var_set_int(res, TERM_RED);
else
var_set_int(res, TERM_WHITE);
break;
default:
default_menu(cmd, which, cookie, res);
}
}
static void _describe(menu_ptr menu, int which)
{
variant v;
var_init(&v);
menu->fn(MENU_HELP, which, menu->cookie, &v);
if (!var_is_null(&v))
{
char tmp[255*10];
int i, line;
for (i = 0; i < 2+10; i++)
Term_erase(13, menu->count + i + 1 + (menu->heading ? 1 : 0), 255);
roff_to_buf(var_get_string(&v), 80-15, tmp, sizeof(tmp));
for(i = 0, line = menu->count + 2 + (menu->heading ? 1 : 0); tmp[i]; i += 1+strlen(&tmp[i]))
{
prt(&tmp[i], line, 15);
line++;
}
}
var_clear(&v);
}
void mut_process(void)
{
int i;
variant v;
/* No effect on monster arena */
if (p_ptr->inside_battle) return;
/* No effect on the global map */
if (p_ptr->wild_mode) return;
var_init(&v);
for (i = 0; i < MAX_MUTATIONS; i++)
{
if ( mut_present(i)
&& (_mutations[i].type & MUT_TYPE_EFFECT) )
{
(_mutations[i].spell.fn)(SPELL_PROCESS, &v);
}
}
var_clear(&v);
}
static bool _describe_spell(spell_info *spell, int col_height)
{
bool result = TRUE;
variant info;
var_init(&info);
(spell->fn)(SPELL_ON_BROWSE, &info);
if (!var_get_bool(&info))
{
char tmp[62*5];
int i, line;
rect_t display = ui_menu_rect();
/* 2 lines below list of spells, 5 lines for description */
for (i = 0; i < 7; i++)
Term_erase(display.x, display.y + col_height + i + 2, display.cx);
/* Get the description, and line break it (max 5 lines) */
(spell->fn)(SPELL_DESC, &info);
roff_to_buf(var_get_string(&info), 62, tmp, sizeof(tmp));
line = display.y + col_height + 3;
for(i = 0; tmp[i]; i += 1+strlen(&tmp[i]))
{
put_str(&tmp[i], line, display.x + 2);
line++;
}
(spell->fn)(SPELL_INFO, &info);
put_str(format("%^s", var_get_string(&info)), line, display.x + 2);
result = FALSE;
}
var_clear(&info);
return result;
}
int
libcall_sum(id_item_t **args, int *rettypes, void **retvals)
{
id_item_t *arg;
struct variable *res;
assert(args != NULL);
rettypes[0] = ID_UNKNOWN;
retvals[0] = NULL;
res = xmalloc(sizeof(*res));
var_init(res);
var_set_zero(res);
while (*args != NULL) {
arg = *args;
if (arg->type != ID_VAR) {
print_warn("error: %s ID_VAR\n",
id_type_2_str(ID_VAR));
goto err;
}
if (varop_add(res, res, arg->var) != 0)
goto err;
args++;
}
rettypes[0] = ID_VAR;
retvals[0] = res;
return 0;
err:
var_clear(res);
return 1;
}
void default_menu(int cmd, int which, vptr cookie, variant *res)
{
var_clear(res);
}
static void _list_spells(spell_info* spells, int ct, int max_cost)
{
char temp[140];
int i;
rect_t display = ui_menu_rect();
int col_height = _col_height(ct);
int col_width;
variant name, info, color;
var_init(&name);
var_init(&info);
var_init(&color);
Term_erase(display.x, display.y, display.cx);
if (col_height == ct)
{
put_str("Lvl Cost Fail Desc", display.y, display.x + 29);
}
else
{
col_width = 42;
put_str("Lvl Cost Fail", display.y, display.x + 29);
put_str("Lvl Cost Fail", display.y, display.x + col_width + 29);
}
for (i = 0; i < ct; i++)
{
char letter = '\0';
byte attr = TERM_WHITE;
spell_info* spell = &spells[i];
var_set_int(&color, TERM_WHITE);
(spell->fn)(SPELL_NAME, &name);
(spell->fn)(SPELL_INFO, &info);
(spell->fn)(SPELL_COLOR, &color);
attr = var_get_int(&color);
if (i < 26)
letter = I2A(i);
else if (i < 52)
letter = 'A' + i - 26;
else
letter = '0' + i - 52;
sprintf(temp, " %c) ", letter);
strcat(temp, format("%-23.23s %3d %4d %3d%%",
var_get_string(&name),
spell->level,
spell->cost,
spell->fail));
if (col_height == ct)
strcat(temp, format(" %s", var_get_string(&info)));
if (spell->fail == 100)
attr = TERM_L_DARK;
if (spell->cost > max_cost)
attr = TERM_L_DARK;
if (spell->level > p_ptr->lev)
attr = TERM_L_DARK;
if (i < col_height)
{
Term_erase(display.x, display.y + i + 1, display.cx);
c_put_str(attr, temp, display.y + i + 1, display.x);
}
else
{
c_put_str(attr, temp, display.y + (i - col_height) + 1, display.x + col_width);
}
}
Term_erase(display.x, display.y + col_height + 1, display.cx);
var_clear(&name);
var_clear(&info);
var_clear(&color);
}
