From 79b59f9b30fb6a1fdf8c3efb446271f7cb00d434 Mon Sep 17 00:00:00 2001 From: Markus Uhlin Date: Thu, 7 Dec 2023 21:31:49 +0100 Subject: FICS 1.6.2 --- FICS/variable.c | 899 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 899 insertions(+) create mode 100644 FICS/variable.c (limited to 'FICS/variable.c') diff --git a/FICS/variable.c b/FICS/variable.c new file mode 100644 index 0000000..b53664d --- /dev/null +++ b/FICS/variable.c @@ -0,0 +1,899 @@ +/* variable.c + * This is cludgy + */ + +/* + fics - An internet chess server. + Copyright (C) 1993 Richard V. Nash + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. +*/ + +/* Revision history: + name email yy/mm/dd Change + Richard Nash 93/10/22 Created + loon 95/03/17 added figure_boolean, use it :) + hersco 95/04/10 replaced figure_boolean with + set_boolean_var + DAV 95/19/11 moved variable command to here + added jprivate +*/ + +#include "stdinclude.h" + +#include "common.h" +#include "variable.h" +#include "playerdb.h" +#include "utils.h" +#include "ficsmain.h" +#include "config.h" +#include "rmalloc.h" +#include "board.h" +#include "command.h" +#include "talkproc.h" +#include "comproc.h" + +/* grimm */ +int SetValidFormula(int p, int which, char *val); +/* added for warning */ +PRIVATE int set_boolean_var(int *var, char *val) +{ + int v = -1; + + if (val == NULL) + return (*var = !*var); + + if (sscanf(val, "%d", &v) != 1) { + stolower(val); + if (!strcmp(val, "off")) + v = 0; + if (!strcmp(val, "false")) + v = 0; + if (!strcmp(val, "on")) + v = 1; + if (!strcmp(val, "true")) + v = 1; + } + if ((v == 0) || (v == 1)) + return (*var = v); + else + return (-1); +} + +PRIVATE int set_open(int p, char *var, char *val) +{ + int v = set_boolean_var(&parray[p].open, val); + + if (v < 0) + return VAR_BADVAL; + if (v > 0) + pprintf(p, "You are now open to receive match requests.\n"); + else { + player_decline_offers(p, -1, PEND_MATCH); + player_withdraw_offers(p, -1, PEND_MATCH); + pprintf(p, "You are no longer receiving match requests.\n"); + } + return VAR_OK; +} + +PRIVATE int set_sopen(int p, char *var, char *val) +{ + int v = set_boolean_var(&parray[p].sopen, val); + + if (v < 0) + return VAR_BADVAL; + pprintf(p, "sopen set to %d.\n", parray[p].sopen); + + if (v > 0) + pprintf(p, "You are now open to receive simul requests.\n"); + else + pprintf(p, "You are no longer receiving simul requests.\n"); + player_decline_offers(p, -1, PEND_SIMUL); + return VAR_OK; +} + +PRIVATE int set_ropen(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].ropen, val) < 0) + return VAR_BADVAL; + pprintf(p, "ropen set to %d.\n", parray[p].ropen); + return VAR_OK; +} + +PRIVATE int set_rated(int p, char *var, char *val) +{ + if (!parray[p].registered) { + pprintf(p, "You cannot change your rated status.\n"); + return VAR_OK; + } + if (set_boolean_var(&parray[p].rated, val) < 0) + return VAR_BADVAL; + pprintf(p, "rated set to %d.\n", parray[p].rated); + return VAR_OK; +} + +PRIVATE int set_shout(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_shout, val) < 0) + return VAR_BADVAL; + if (parray[p].i_shout) + pprintf(p, "You will now hear shouts.\n"); + else + pprintf(p, "You will not hear shouts.\n"); + return VAR_OK; +} + +PRIVATE int set_cshout(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_cshout, val) < 0) + return VAR_BADVAL; + if (parray[p].i_cshout) + pprintf(p, "You will now hear cshouts.\n"); + else + pprintf(p, "You will not hear cshouts.\n"); + return VAR_OK; +} + +PRIVATE int set_kibitz(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_kibitz, val) < 0) + return VAR_BADVAL; + if (parray[p].i_kibitz) + pprintf(p, "You will now hear kibitzes.\n"); + else + pprintf(p, "You will not hear kibitzes.\n"); + return VAR_OK; +} +PRIVATE int set_kiblevel(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 0) || (v > 9999)) + return VAR_BADVAL; + parray[p].kiblevel = v; + pprintf(p, "Kibitz level now set to: %d.\n", v); + return VAR_OK; +} + +PRIVATE int set_tell(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_tell, val) < 0) + return VAR_BADVAL; + if (parray[p].i_tell) + pprintf(p, "You will now hear tells.\n"); + else + pprintf(p, "You will not hear tells.\n"); + return VAR_OK; +} + +PRIVATE int set_notifiedby(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].notifiedby, val) < 0) + return VAR_BADVAL; + if (parray[p].notifiedby) + pprintf(p, "You will now hear if people notify you, but you don't notify them.\n"); + else + pprintf(p, "You will not hear if people notify you, but you don't notify them.\n"); + return VAR_OK; +} + +PRIVATE int set_pinform(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_login, val) < 0) + return VAR_BADVAL; + if (parray[p].i_login) + pprintf(p, "You will now hear logins/logouts.\n"); + else + pprintf(p, "You will not hear logins/logouts.\n"); + return VAR_OK; +} + +PRIVATE int set_ginform(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].i_game, val) < 0) + return VAR_BADVAL; + if (parray[p].i_game) + pprintf(p, "You will now hear game results.\n"); + else + pprintf(p, "You will not hear game results.\n"); + return VAR_OK; +} + +PRIVATE int set_private(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].private, val) < 0) + return VAR_BADVAL; + if (parray[p].private) + pprintf(p, "Your games will be private.\n"); + else + pprintf(p, "Your games may not be private.\n"); + return VAR_OK; +} + +PRIVATE int set_jprivate(int p, char *var, char *val) +{ + if (!parray[p].registered) { + pprintf(p, "Unregistered players may not keep a journal.\n"); + return VAR_OK; + } + + if (set_boolean_var(&parray[p].jprivate, val) < 0) + return VAR_BADVAL; + if (parray[p].jprivate) + pprintf(p, "Your journal will be private.\n"); + else + pprintf(p, "Your journal will not be private.\n"); + return VAR_OK; +} + +PRIVATE int set_automail(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].automail, val) < 0) + return VAR_BADVAL; + if (parray[p].automail) + pprintf(p, "Your games will be mailed to you.\n"); + else + pprintf(p, "Your games will not be mailed to you.\n"); + return VAR_OK; +} + +PRIVATE int set_mailmess(int p, char *var, char *val) +{ + if (!parray[p].registered) { + pprintf(p, "Unregistered players may not receive messages.\n"); + return VAR_OK; + } + if (set_boolean_var(&parray[p].i_mailmess, val) < 0) + return VAR_BADVAL; + if (parray[p].i_mailmess) + pprintf(p, "Your messages will be mailed to you.\n"); + else + pprintf(p, "Your messages will not be mailed to you.\n"); + return VAR_OK; +} + +PRIVATE int set_pgn(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].pgn, val) < 0) + return VAR_BADVAL; + if (parray[p].pgn) + pprintf(p, "Games will now be mailed to you in PGN.\n"); + else + pprintf(p, "Games will now be mailed to you in FICS format.\n"); + return VAR_OK; +} + +PRIVATE int set_bell(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].bell, val) < 0) + return VAR_BADVAL; + if (parray[p].bell) + pprintf(p, "Bell on.\n"); + else + pprintf(p, "Bell off.\n"); + return VAR_OK; +} + +PRIVATE int set_highlight(int p, char *var, char *val) +{ +/* if (set_boolean_var (&parray[p].highlight, val) < 0) return VAR_BADVAL; + */ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 0) || (v > 15)) + return VAR_BADVAL; + + if ((parray[p].highlight = v)) { + pprintf(p, "Highlight is now style "); + pprintf_highlight(p, "%d", v); + pprintf(p, ".\n"); + } else + pprintf(p, "Highlight is off.\n"); + return VAR_OK; +} + +PRIVATE int set_style(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 1) || (v > MAX_STYLES)) + return VAR_BADVAL; + parray[p].style = v - 1; + pprintf(p, "Style %d set.\n", v); + return VAR_OK; +} + +PRIVATE int set_flip(int p, char *var, char *val) +{ + if (set_boolean_var(&parray[p].flip, val) < 0) + return VAR_BADVAL; + if (parray[p].flip) + pprintf(p, "Flip on.\n"); + else + pprintf(p, "Flip off.\n"); + return VAR_OK; +} +/* +PRIVATE int set_uscf(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 0) || (v > 3000)) + return VAR_BADVAL; + parray[p].uscfRating = v; + pprintf(p, "USCF Rating set to %d.\n", v); + return VAR_OK; +} +*/ +PRIVATE int set_time(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 0) || (v > 240)) + return VAR_BADVAL; + parray[p].d_time = v; + pprintf(p, "Default time set to %d.\n", v); + return VAR_OK; +} + +PRIVATE int set_inc(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 0) || (v > 300)) + return VAR_BADVAL; + parray[p].d_inc = v; + pprintf(p, "Default increment set to %d.\n", v); + return VAR_OK; +} + +PRIVATE int set_height(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 5) || (v > 240)) + return VAR_BADVAL; + parray[p].d_height = v; + pprintf(p, "Height set to %d.\n", v); + return VAR_OK; +} + +PRIVATE int set_width(int p, char *var, char *val) +{ + int v = -1; + + if (!val) + return VAR_BADVAL; + if (sscanf(val, "%d", &v) != 1) + return VAR_BADVAL; + if ((v < 32) || (v > 240)) + return VAR_BADVAL; + parray[p].d_width = v; + pprintf(p, "Width set to %d.\n", v); + return VAR_OK; +} + +PUBLIC char *Language(int i) +{ + static char *Lang[NUM_LANGS] = {"English", "Spanish", "French", "Danish"}; + return Lang[i]; +} + +PRIVATE int set_language (int p, char *var, char *val) +{ + int i, len, gotIt = -1; + + if (!val) + return VAR_BADVAL; + len = strlen(val); + for (i=0; i < NUM_LANGS; i++) { + if (strncasecmp(val, Language(i), len)) + continue; + if (gotIt >= 0) + return VAR_BADVAL; + else gotIt = i; + } + if (gotIt < 0) + return VAR_BADVAL; + parray[p].language = gotIt; + pprintf(p, "Language set to %s.\n", Language(gotIt)); + return VAR_OK; +} + +PRIVATE int set_promote(int p, char *var, char *val) +{ + if (!val) + return VAR_BADVAL; + stolower(val); + switch (val[0]) { + case 'q': + parray[p].promote = QUEEN; + pprintf(p, "Promotion piece set to QUEEN.\n"); + break; + case 'r': + parray[p].promote = ROOK; + pprintf(p, "Promotion piece set to ROOK.\n"); + break; + case 'b': + parray[p].promote = BISHOP; + pprintf(p, "Promotion piece set to BISHOP.\n"); + break; + case 'n': + case 'k': + parray[p].promote = KNIGHT; + pprintf(p, "Promotion piece set to KNIGHT.\n"); + break; + default: + return VAR_BADVAL; + } + return VAR_OK; +} + +PRIVATE int set_prompt(int p, char *var, char *val) +{ + if (!val) { + if (parray[p].prompt && (parray[p].prompt != def_prompt)) + rfree(parray[p].prompt); + parray[p].prompt = def_prompt; + return VAR_OK; + } + if (!printablestring(val)) + return VAR_BADVAL; + if (parray[p].prompt != def_prompt) + rfree(parray[p].prompt); + parray[p].prompt = (char *) rmalloc(strlen(val) + 2); + strcpy(parray[p].prompt, val); + strcat(parray[p].prompt, " "); + return VAR_OK; +} + +int RePartner (int p, int new) +{ + int pOld; + + if (p < 0) + return -1; + pOld = parray[p].partner; + if (parray[pOld].partner == p) { + if (new >= 0) + pprintf_prompt (pOld, "Your partner has just chosen a new partner.\n"); + else + pprintf_prompt (pOld, "Your partner has just unset his/her partner.\n"); + player_withdraw_offers (pOld, -1, PEND_BUGHOUSE); + player_decline_offers (pOld, -1, PEND_BUGHOUSE); + player_withdraw_offers (p, -1, PEND_BUGHOUSE); + player_decline_offers (p, -1, PEND_BUGHOUSE); + } + player_withdraw_offers(p, -1, PEND_PARTNER); + player_decline_offers(p, -1, PEND_PARTNER); + parray[pOld].partner = -1; + parray[p].partner = new; + return new; +} + +PUBLIC int com_partner(int p, param_list param) +{ + int pNew; + + if (param[0].type == TYPE_NULL) { + RePartner(p, -1); + return COM_OK; + } + /* OK, we're trying to set a new partner. */ + pNew = player_find_part_login(param[0].val.word); + if (pNew < 0 || parray[pNew].status == PLAYER_PASSWORD + || parray[pNew].status == PLAYER_LOGIN) { + pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word); + return COM_OK; + } + if (pNew == p) { + pprintf(p, "You can't be your own bughouse partner.\n"); + return COM_OK; + } + /* Now we know a legit partner has been chosen. Is an offer pending? */ + if (player_find_pendfrom(p, pNew, PEND_PARTNER) >= 0) { + pprintf (p, "You agree to be %s's partner.\n", parray[pNew].name); + pprintf_prompt (pNew, "%s agrees to be your partner.\n", parray[p].name); + player_remove_request(pNew, p, PEND_PARTNER); + + /* Make the switch. */ + RePartner (p, pNew); + RePartner (pNew, p); + return COM_OK; + } + /* This is just an offer. Make sure a new partner is needed. */ + if (parray[pNew].partner >= 0) { + pprintf(p, "%s already has a partner.\n", parray[pNew].name); + return COM_OK; + } + pprintf(pNew, "\n"); + pprintf_highlight(pNew, "%s", parray[p].name); + pprintf(pNew, " offers to be your bughouse partner; "); + pprintf_prompt(pNew, "type \"partner %s\" to accept.\n", parray[p].name); + pprintf(p, "Making a partnership offer to %s.\n", parray[pNew].name); + player_add_request(p, pNew, PEND_PARTNER, 0); + +/* pprintf (p, "Command not implemented yet.\n"); */ + return COM_OK; +} + +PRIVATE int set_partner(int p, char *var, char *val) +{ +#if 0 + int p1 = parray[p].partner; + + if (!val) { + RePartner (p, -1); + return VAR_OK; + } + if (!printablestring(val)) + return VAR_BADVAL; + stolower(val); + p1 = player_find_part_login(val); + if (p1 < 0 || parray[p1].status == PLAYER_PASSWORD + || parray[p1].status == PLAYER_LOGIN) { + pprintf(p, "No user named \"%s\" is logged in.\n", val); + return VAR_OK; + } + if (p1 == p) { + pprintf(p, "You can't be your own bughouse partner!\n"); + return VAR_OK; + } + parray[p].partner = p1; + pprintf(p, "Your bughouse partner is now %s.\n", parray[p1].name); + pprintf_prompt(p1, "%s just chose you for a bughouse partner.\n", parray[p].name); +#endif + if (!val) + pprintf(p, "Command is obsolete; type \"partner\" to clear your partner\n"); + else + pprintf(p, "Command is obsolete; type \"partner %s\" to change your partner\n", val); + return VAR_OK; +} + +PRIVATE int set_busy(int p, char *var, char *val) +{ + if (!val) { + parray[p].busy[0] = '\0'; + pprintf(p, "Your \"busy\" string was cleared.\n"); + return VAR_OK; + } + if ((val) && (!printablestring(val))) + return VAR_BADVAL; + if (strlen(val) > 50) { + pprintf(p, "That string is too long.\n"); + return VAR_BADVAL; + } + sprintf(parray[p].busy, "%s", val); + pprintf(p, "Your \"busy\" string was set to \" %s\"\n", parray[p].busy); + return VAR_OK; +} + +/* this is really ugly */ +PRIVATE int set_plan(int p, char *var, char *val) +{ + int which; + int i; + + if (val && !printablestring(val)) + return VAR_BADVAL; + which = atoi(var); /* Must be an integer, no test needed */ + + if (which > MAX_PLAN) + return VAR_BADVAL; + + if (which > parray[p].num_plan) + which = parray[p].num_plan + 1; + + if (which == 0) { /* shove from top */ + if (parray[p].num_plan >= MAX_PLAN) { /* free the bottom string */ + if (parray[p].planLines[parray[p].num_plan - 1] != NULL) + rfree(parray[p].planLines[parray[p].num_plan - 1]); + } + if (parray[p].num_plan) { + for (i = (parray[p].num_plan >= MAX_PLAN) ? MAX_PLAN - 1 : parray[p].num_plan; i > 0; i--) + parray[p].planLines[i] = parray[p].planLines[i - 1]; + } + if (parray[p].num_plan < MAX_PLAN) + parray[p].num_plan++; + parray[p].planLines[0] = ((val == NULL) ? NULL : strdup(val)); + pprintf(p, "\nPlan variable %d changed to '%s'.\n", which+1, parray[p].planLines[which]); + pprintf(p, "All other variables moved down.\n"); + return VAR_OK; + } + if (which > parray[p].num_plan) { /* new line at bottom */ + if (parray[p].num_plan >= MAX_PLAN) { /* shove the old lines up */ + if (parray[p].planLines[0] != NULL) + rfree(parray[p].planLines[0]); + for (i = 0; i < parray[p].num_plan; i++) + parray[p].planLines[i] = parray[p].planLines[i + 1]; + } else { + parray[p].num_plan++; + } + parray[p].planLines[which - 1] = ((val == NULL) ? NULL : strdup(val)); + pprintf(p, "\nPlan variable %d changed to '%s'.\n", which, parray[p].planLines[which-1]); + return VAR_OK; + } + which--; + if (parray[p].planLines[which] != NULL) { + rfree(parray[p].planLines[which]); + } + if (val != NULL) { + parray[p].planLines[which] = strdup(val); + pprintf(p, "\nPlan variable %d changed to '%s'.\n", which+1, parray[p].planLines[which]); + } else { + parray[p].planLines[which] = NULL; + if (which == parray[p].num_plan - 1) { /* clear nulls from bottom */ + while ((parray[p].num_plan > 0) && (parray[p].planLines[parray[p].num_plan - 1] == NULL)) { + parray[p].num_plan--; + pprintf(p, "\nPlan variable %d cleared.\n", which+1); + } + } else if (which == 0) { /* clear nulls from top */ + while ((which < parray[p].num_plan) && (parray[p].planLines[which] == NULL)) { + which++; + } + if (which != parray[p].num_plan) { + for (i = which; i < parray[p].num_plan; i++) + parray[p].planLines[i - which] = parray[p].planLines[i]; + } + parray[p].num_plan -= which; + } + } + return VAR_OK; +} + +PRIVATE int set_formula(int p, char *var, char *val) +{ + int which; + player *me = &parray[p]; + +#ifdef NO_FORMULAS + pprintf(p, "Sorry -- not available because of a bug\n"); + return COM_OK; +#else + if (isdigit(var[1])) + which = var[1] - '1'; + else + which = MAX_FORMULA; + + if (val != NULL) { + val = eatwhite(val); + if (val[0] == '\0') + val = NULL; + } + if (!SetValidFormula(p, which, val)) + return VAR_BADVAL; + + if (which < MAX_FORMULA) { + if (val != NULL) { + while (me->num_formula < which) { + me->formulaLines[me->num_formula] = NULL; + (me->num_formula)++; + } + if (me->num_formula <= which) + me->num_formula = which + 1; + pprintf(p, "Formula variable f%d set to %s.\n", + which + 1, me->formulaLines[which]); + return VAR_OK; + } + pprintf(p, "Formula variable f%d unset.\n", which + 1); + if (which + 1 >= me->num_formula) { + while (which >= 0 && me->formulaLines[which] == NULL) + which--; + me->num_formula = which + 1; + } + } else { + if (me->formula != NULL) + pprintf(p, "Formula set to %s.\n", me->formula); + else + pprintf(p, "Formula unset.\n"); + } + return VAR_OK; +#endif +} + +PUBLIC var_list variables[] = { + {"open", set_open}, + {"simopen", set_sopen}, + {"rated", set_rated}, + {"ropen", set_ropen}, + {"cshout", set_cshout}, + {"shout", set_shout}, + {"kibitz", set_kibitz}, + {"kiblevel", set_kiblevel}, + {"tell", set_tell}, + {"notifiedby", set_notifiedby}, + {"pinform", set_pinform}, + {"i_login", set_pinform}, + {"ginform", set_ginform}, + {"i_game", set_ginform}, + {"automail", set_automail}, + {"mailmess", set_mailmess}, + {"bell", set_bell}, + {"pgn", set_pgn}, + {"private", set_private}, + {"jprivate", set_jprivate}, + {"highlight", set_highlight}, + {"style", set_style}, + {"flip", set_flip}, +/* {"uscf", set_uscf},*/ + {"prompt", set_prompt}, + {"partner", set_partner}, + {"promote", set_promote}, + {"time", set_time}, + {"inc", set_inc}, + {"height", set_height}, + {"width", set_width}, + {"language", set_language}, + {"busy", set_busy}, + {"0", set_plan}, + {"1", set_plan}, + {"2", set_plan}, + {"3", set_plan}, + {"4", set_plan}, + {"5", set_plan}, + {"6", set_plan}, + {"7", set_plan}, + {"8", set_plan}, + {"9", set_plan}, + {"10", set_plan}, + {"f1", set_formula}, + {"f2", set_formula}, + {"f3", set_formula}, + {"f4", set_formula}, + {"f5", set_formula}, + {"f6", set_formula}, + {"f7", set_formula}, + {"f8", set_formula}, + {"f9", set_formula}, + {"formula", set_formula}, + {NULL, NULL} +}; + +PRIVATE int set_find(char *var) +{ + int i = 0; + int gotIt = -1; + int len = strlen(var); + + while (variables[i].name) { + if (!strncmp(variables[i].name, var, len)) { + if (len == strlen(variables[i].name)) { + return i; + } else if (gotIt >= 0) { + return -VAR_AMBIGUOUS; + } + gotIt = i; + } + i++; + } + if (gotIt >= 0) { + return gotIt; + } + return -VAR_NOSUCH; +} + +PUBLIC int var_set(int p, char *var, char *val, int *wh) +{ + int which; + + if (!var) + return VAR_NOSUCH; + if ((which = set_find(var)) < 0) { + return -which; + } + *wh = which; + return variables[which].var_func(p, (isdigit(*variables[which].name) ? var : variables[which].name), val); +} + +PUBLIC int com_variables(int p, param_list param) +{ + int p1, connected; + int i; + + if (param[0].type == TYPE_WORD) { + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + } else { + p1 = p; + connected = 1; + } + + pprintf(p, "Variable settings of %s:\n", parray[p1].name); +/* if (parray[p1].fullName) + pprintf(p, " Realname: %s\n", parray[p1].fullName); + if (parray[p1].uscfRating) + pprintf(p, " USCF: %d\n", parray[p1].uscfRating); +*/ + pprintf(p, " time=%-3d inc=%-3d private=%d jprivate=%d Lang=%s\n", + parray[p1].d_time, parray[p1].d_inc, parray[p1].private, + parray[p1].jprivate, Language(parray[p1].language)); + pprintf(p, " rated=%d ropen=%d open=%d simopen=%d\n", + parray[p1].rated, parray[p1].ropen, parray[p1].open, parray[p1].sopen); + pprintf(p, " shout=%d cshout=%d kib=%d tell=%d notifiedby=%d\n", + parray[p1].i_shout, parray[p1].i_cshout, parray[p1].i_kibitz, parray[p1].i_tell, parray[p1].notifiedby); + pprintf(p, " pin=%d gin=%d style=%-3d flip=%d kiblevel=%d\n", + parray[p1].i_login, parray[p1].i_game, parray[p1].style + 1, parray[p1].flip, parray[p1].kiblevel); + pprintf(p, " highlight=%d bell=%d auto=%d mailmess=%d pgn=%d\n", + parray[p1].highlight, parray[p1].bell, parray[p1].automail, parray[p1].i_mailmess, parray[p1].pgn); + pprintf(p, " width=%-3d height=%-3d\n", + parray[p1].d_width, parray[p1].d_height); + if (parray[p1].prompt && parray[p1].prompt != def_prompt) + pprintf(p, " Prompt: %s\n", parray[p1].prompt); + if (parray[p1].partner >= 0) + pprintf(p, " Bughouse partner: %s\n", parray[parray[p1].partner].name); + +#if 0 + { /* added code to print channels */ + int count = 0; + for (i = 0; i < MAX_CHANNELS; i++) { + if (on_channel(i, p1)) { + if (!count) + pprintf(p, "\n Channels:"); + pprintf(p, " %d", i); + count++; + } + } + if (count) + pprintf(p, "\n"); + } +#endif /* Now use in [name] */ +/* if (parray[p1].numAlias && (p == p1)) { + pprintf(p, "\n Aliases:\n"); + for (i = 0; i < parray[p1].numAlias; i++) { + pprintf(p, " %s %s\n", parray[p1].alias_list[i].comm_name, + parray[p1].alias_list[i].alias); + } + } +*/ + if (parray[p1].num_formula) { + pprintf(p, "\n"); + for (i = 0; i < parray[p1].num_formula; i++) { + if (parray[p1].formulaLines[i] != NULL) + pprintf(p, " f%d: %s\n", i + 1, parray[p1].formulaLines[i]); + else + pprintf(p, " f%d:\n", i + 1); + } + } + if (parray[p1].formula != NULL) + pprintf(p, "\nFormula: %s\n", parray[p1].formula); + + if (!connected) + player_remove(p1); + return COM_OK; +} -- cgit v1.2.3