/** * Generalised voting room intended to be inherited into rooms in the mud that * will setup the parameters and settings for votes. * <p> * The room does not inherantly support player initiated votes, however it is * a fairly simple matter to add this to your own room and have your room add * votes when players initiate them. * * @author Ceres */ #include <board.h> #define DEFAULT_VOTE_DURATION 2600*24*7 inherit ROOM_OBJ; /** * @class * This class stores the essential information about a vote. It is only used * internally to the voting room. */ class vote { string type; /* used to setup vote types */ string desc; /* description of the vote */ string *choices; /* options in the vote */ int *votes; int ending; /* when the vote ends */ string *voted; /* people who've voted */ } /* * @class * This class stores the essential information about an election during the * setup phase. It is only used internally to the voting room. */ class election { mixed *candidates; /* who are the candidates */ int closes; /* when does acceptance of nominees close */ } private int vote_counter; /* Used to give each vote a unique number */ private mapping votes; /* the votes themselves */ private mapping elections; /* the elections being setup */ private nosave string vote_file; /* Controls which vote file to use */ private nosave mixed vote_cond; private nosave mixed comp_action; /* Completion action */ private nosave int vote_duration; /* The normal duration for a vote */ private nosave mixed stand_cond; private nosave mixed second_cond; private nosave mixed election_announcement; /* The board, person and subject */ int list_votes(); int cast_vote( string words, int num ); int stand_for_election(string position); int second_candidate(string who, string position); int list_elections(); /** * @ignore */ void create() { do_setup++; add_help_file("voting_room"); ::create(); do_setup--; if ( !do_setup ) { TO->setup(); TO->reset(); } seteuid("Room"); } /** * @ignore */ void init() { ::init(); // commands for votes add_command("vote", "<string> on <number>", (: cast_vote($4[0], $4[1]) :) ); add_command("votes", "", (: list_votes :)); // commands for elections add_command( "stand", "[for] <string>", (: stand_for_election($4[0]) :)); add_command( "second", "<string> [for] <string>", (: second_candidate($4[0], $4[1]) :) ); add_command("elections", "", (: list_elections :)); } /* init() */ /** * This method is called by the inheriting object to determine which save file * to use for votes. * * @param str The name of the file you want the voting info saved to * (without the .o) */ void set_save_file(string file) { int *vote_ids, i; string election; vote_file = file; if( file_size( vote_file + ".o" ) > 0 ) { unguarded( (: restore_object, vote_file :) ); if(!votes) votes = ([ ]); if(!elections) elections = ([ ]); vote_ids = m_indices( votes ); for ( i = 0; i < sizeof( vote_ids ); i++ ) if ( votes[ vote_ids[ i ] ]->ending < time() ) call_out( "end_vote", 10 * ( i + 1 ), vote_ids[ i ] ); else call_out( "end_vote", votes[ vote_ids[ i ] ]->ending - time(), vote_ids[ i ] ); foreach(election in keys(elections)) { if(elections[election]->closes < time()) call_out( "start_election_vote", 30 * random(5), election); else call_out( "start_election_vote", elections[election]->closes - time(), election); } } else { votes = ([ ]); elections = ([ ]); } } /** * This method returns the save file currently used for the room. * @return the current save file */ string query_save_file() { return vote_file; } /** * Private function to save the rooms data file. */ private void save_room() { unguarded( (: save_object, vote_file :) ); } /** * This function defines a function to be called to determine if a player * is eligible to vote. * * @param cond This will usually be a mixed array of an object and a function. * It could also be a function pointer. * * Your function should return 1 if the player is eligible to vote or 0 if * they are not. */ void set_vote_conditions(mixed cond) { vote_cond = cond; } /** * This function defines a function to be called when the vote is complete. * Typically your function will post the vote results somewhere or somesuch. * * @param cond This will usually be a mixed array of an object and a function. * It could also be a function pointer. */ void set_completion_action(mixed cond) { comp_action = cond; } /** * This function is used to set the normal vote and election duration. It can * be overridden when calling add_vote. If it is not set and no duration is * given in add_vote then the default value of DEFAULT_VOTE_DURATION is used. * * @param duraction The number of seconds the vote should be open. * * @see add_vote() */ void set_vote_duration(int duration) { vote_duration = duration; } /** * This function defines a function to be called to determine if a player * is eligible to stand for election to a position. * * @param cond This will usually be a mixed array of an object and a function. * It could also be a function pointer. * * Your function should return 1 if the player is eligible to stand or 0 if * they are not. */ void set_stand_conditions(mixed cond) { stand_cond = cond; } /** * This function defines a function to be called to determine if a player * is eligible to second a canditate for election. * * @param cond This will usually be a mixed array of an object and a function. * It could also be a function pointer. * * Your function should return 1 if the player is eligible to second or 0 if * they are not. */ void set_second_conditions(mixed cond) { second_cond = cond; } /** * This function defines the board, person and subject for announcements * of elections. * * @param board This is the board to post to. * @param person This is who to post as. * @param subject This is the subject line to use. * @param prefix The text to preceed the message. The default is * "All eligible persons are requested to vote for the position " * "of " * @param suffix The text to follow the message. */ void set_election_announcement(string board, string person, string subject, string prefix, string suffix) { election_announcement = ({ board, person, subject, prefix, suffix }); } /** * This function is called when a player votes. The syntax is * "vote <choice> on <vote>". * * @see set_vote_conditions() */ int cast_vote( string which_str, int vote_id ) { string pname; int which, ok; class vote this_vote; if ( undefinedp(votes[vote_id])) { add_succeeded_mess(({"There is no vote " + vote_id + ".\n", ""})); return 1; } if(strlen(which_str) > 1) { add_succeeded_mess(({"There is no choice " + which_str + " for vote id " + vote_id + ".\n", ""})); return 1; } this_vote = votes[vote_id]; which = upper_case( which_str )[ 0 ] - 65; if(which < 0 || which > sizeof(this_vote->choices) -1) { add_succeeded_mess(({"There is no choice " + which_str + " for vote id " + vote_id + ".\n", ""})); return 1; } ok = 1; if (functionp(vote_cond)) { ok = evaluate(vote_cond, TP); } if(arrayp(vote_cond)) { ok = call_other(vote_cond[0], vote_cond[1], TP); } if(!intp(ok)) { ok = 0; } if(!ok) { add_failed_mess("Sorry, but you are not allowed to vote on this " "subject.\n"); return 0; } pname = TP->query_name(); if(member_array(pname, this_vote->voted) != -1) { add_succeeded_mess(({"You have already voted on this subject.\n", ""})); return 1; } this_vote->voted += ({ pname }); this_vote->votes[which]++; save_room(); add_succeeded_mess(({ "You cast your vote for "+which_str + " on " + vote_id+".\n", "$N casts a vote.\n" })); return 1; } /* cast_vote() */ /** * This function is called when a player types 'list'. It lists the currently * open votes. */ int list_votes() { int i, j, *vote_ids; string text; class vote this_vote; if ( !m_sizeof( votes ) ) { write( "There are no votes in progress.\n" ); return 1; } vote_ids = m_indices( votes ); if ( sizeof( vote_ids ) > 1 ) write( "The following votes are in progress:\n" ); else write( "The following vote is in progress:\n" ); text = ""; for ( i = 0; i < sizeof( vote_ids ); i++ ) { this_vote = votes[vote_ids[i]]; text += " "+ vote_ids[i] + ". " + this_vote->desc +"\n Choices are :\n"; for(j=0; j<sizeof(this_vote->choices); j++) { text += sprintf(" %c. %s\n", 'A'+j, this_vote->choices[j]); } text += " Voting closes in "+ time_string( (this_vote->ending)-time() ) +".\n\n"; } TP->more_string(sprintf( "%-=*s", (int)TP->query_cols(), text )); return 1; } /** * This function is called to add a vote to the system. * * @param type Freeform string giving the type of vote. This is typically used * by your completion function so that it can perform different actions for * different types of votes. * * @param description The description of the vote as shown to the player. * * @param choices An array of vote options eg. ({"Yes", "No" }) * * @param ending An integer time of when the vote should be terminated. * * @see set_completion_action() */ void add_vote(string type, string description, string *choices, int ending) { class vote new_vote; vote_counter++; new_vote = new(class vote); new_vote->type = type; new_vote->desc = description; new_vote->choices = choices; new_vote->votes = allocate(sizeof(choices)); if(ending) new_vote->ending = ending; else if(vote_duration) new_vote->ending = (vote_duration + time()); else new_vote->ending = (DEFAULT_VOTE_DURATION + time()); new_vote->voted = ({ }); votes[ vote_counter ] = new_vote; call_out( "end_vote", new_vote->ending - time(), vote_counter ); } /** * @ignore */ mapping query_votes() { return votes + ([ ]); } /** * @ignore */ mapping query_elections() { return elections + ([ ]); } /** * This function is called to terminate a vote. It calls your completion * action. * * @see set_completion_action() */ void end_vote( int which ) { tell_creator("shaydz", "Ending vote " + which + "\n"); if ( !votes[ which ] ) return; TCRE("shaydz",sprintf("votes[which]->type:%O votes[which]->desc:%O " "votes[which]->choices:%O votes[which]->votes:%O " "votes[which]->voted:%O",votes[which]->type, votes[which]->desc, votes[which]->choices, votes[which]->votes, votes[which]->voted)); if(functionp(comp_action)) evaluate(comp_action, votes[which]->type, votes[which]->desc, votes[which]->choices, votes[which]->votes, votes[which]->voted); else if(arrayp(comp_action)) call_other(comp_action[0], comp_action[1], votes[which]->type, votes[which]->desc, votes[which]->choices, votes[which]->votes, votes[which]->voted); map_delete(votes, which); save_room(); } /** * This function is provided for convenience to make it easy for your vote * end function to post to a board. * * @param board The name of the board to post to. * @param name The name of the person to post as. * @param subject The subject line to use. * @param message The message to post. */ void make_announcement(string board, string name, string subject, string message ) { BOARD_HAND->add_message(board, name, subject, sprintf( "%-=*s", 64, message)); } /** * This function is used to initiate an election. * It sets up the election class and adds it to the mapping. * * @param position The name of the position the election is for. */ void initiate_election(string position) { class election tmp; if(elections[position]) return; tmp = new(class election); tmp->candidates = ({}); if(vote_duration) { tmp->closes = time() + vote_duration; } else { tmp->closes = time() + DEFAULT_VOTE_DURATION; } elections[position] = tmp; call_out("start_election_vote", time() + tmp->closes, position); save_room(); } /* initiate_election() */ /** * This method determines if there is already an election of the * specified type in progress. * @param position the name of the election in progress * @return 1 if there is an election in progress */ int query_election_in_progress(string position) { if (classp(elections[position])) { return 1; } return 0; } /* query_election_in_progress() */ /** * This function is used by players to stand for election. The syntax is: * "stand for <position>". * * @see set_stand_conditions() */ int stand_for_election(string position) { int ok, i; // check if they're eligible. ok = 1; if(functionp(stand_cond)) { ok = evaluate(stand_cond, TP, position); } else if(arrayp(stand_cond)) { ok = call_other(stand_cond[0], stand_cond[1], TP, position); } if(!intp(ok)) ok = 0; if(!ok) { add_succeeded_mess(({ "Sorry, but you are not allowed to stand for this " "election.\n", ""})); return 1; } // check if there is an election for this position. if(!elections[position]) { add_succeeded_mess(({"There is no election in progress for the post of " + position + ".\n", ""})); return 1; } // check if they're already a candidate for this position. for(i=0; i<sizeof(elections[position]->candidates); i++) { if(elections[position]->candidates[i][0] == TP->query_name()) { add_succeeded_mess(({"You are already standing in this " "election.\n", ""})); return 1; } } // add them to the list of candidates. elections[position]->candidates += ({({ TP->query_name(), "" })}); save_room(); add_succeeded_mess(({"You have been added to the list of candidates for " "the position of " + position + ". You must now " "find someone to second your candidacy.\n", "$N stands for election.\n"})); return 1; } /** * This function is used by players to second candidates for election. If a * candidates isn't seconded he/she won't be in the election. The syntax is: * "second <player> for <position>". * * @see set_second_conditions() */ int second_candidate(string who, string position) { mixed *candidates; int i, found, ok; // check if they're eligible. ok = 1; if(functionp(second_cond)) { ok = evaluate(second_cond, TP, position); } else if(arrayp(second_cond)) { ok = call_other(second_cond[0], second_cond[1], TP, position); } if(!intp(ok)) ok = 0; if(!ok) { add_succeeded_mess(({"Sorry, but you are not allowed to second candidates " "in this election.\n", ""})); return 1; } // check the position is up for election if(!elections[position]) { add_succeeded_mess(({"There is no election in progress for " + position + ".\n", ""})); return 1; } // check the candidate is standing candidates = (elections[position])->candidates; for(i=0; i< sizeof(candidates); i++) { if(candidates[i][0] == who) found = i+1; } if(!found) { add_succeeded_mess(({who + " is not standing for the position of " + position + ".\n", ""})); return 1; } if(TP->query_name() == who) { add_succeeded_mess(({"You cannot second yourself.\n", ""})); return 1; } if(candidates[found-1][1] != "") { add_succeeded_mess(({candidates[found-1][0] + " has already been seconded by " + candidates[found-1][1] + ".\n", ""})); return 1; } // mark the candidate as seconded (supported). candidates[found-1][1] = TP->query_name(); save_room(); add_succeeded_mess(({candidates[found-1][0] + " has been seconded in the election for "+ position+".\n", ""})); return 1; } /** * Once the candidacy phase is over this function starts the election vote * itself by taking all eligible candidates, setting them as choices in the * election and then posting an announcemment. */ void start_election_vote(string post) { string str, *choices; int i; if(!elections[post]) return; if(election_announcement[3]) str = election_announcement[3]; else str = "All eligible persons are requested to vote for the position of "; str += post + "\n\nThe candidates are:\n"; choices = ({ }); for(i=0; i<sizeof(elections[post]->candidates); i++) { if(elections[post]->candidates[i][1] != "") { str += sprintf(" %s seconded by %s.\n", elections[post]->candidates[i][0], elections[post]->candidates[i][1]); choices += ({ elections[post]->candidates[i][0] }); } } if(!sizeof(choices)) { str = "In the election for the position of " + post + " no candidate stood for election therefore the election " "is null and void.\n"; } else if(sizeof(choices) < 2) { str = "In the election for the position of " + post + " only one candidate stood for election therefore the election " "is null and void.\n"; } else { if(election_announcement[4]) str += election_announcement[4]; add_vote("election", "Election for the post of " + post + "\n", choices, 0); } make_announcement(election_announcement[0], election_announcement[1], election_announcement[2], str); map_delete(elections, post); save_room(); } /** * This function is called when a player types 'elections'. It lists the * elections currently accepting candidates. */ int list_elections() { class election this_election; string *posts, text; int i, j; if ( !m_sizeof( elections ) ) { write( "There are no elections in progress.\n" ); return 1; } posts = m_indices( elections ); if ( sizeof( posts ) > 1 ) write( "The following elections are in progress:\n" ); else write( "The following election is in progress:\n" ); text = ""; for ( i = 0; i < sizeof( posts ); i++ ) { this_election = elections[posts[i]]; text += " Election to the post of "+ posts[i] + ".\n"; if(!sizeof(this_election->candidates)) { text += " No candidates have declared yet.\n"; } else { text += " Current candidates are :\n"; for(j=0; j<sizeof(this_election->candidates); j++) { if(this_election->candidates[j][1] != "") text += sprintf(" %c. %s seconded by %s.\n", 'A'+j, this_election->candidates[j][0], this_election->candidates[j][1]); else text += sprintf(" %c. %s not yet seconded.\n", 'A'+j, this_election->candidates[j][0]); } } text += " Candidacies must be declared by "+ ctime( this_election->closes ) +".\n\n"; } TP->more_string(sprintf( "%-=*s", (int)TP->query_cols(), text )); return 1; } /** * This is an administrative function to allow the removal/cancellation * of an election. * @param election The name of the election to be cancelled * @return Returns 1 for success, 0 for failure. */ int delete_election(string election) { if(!elections[election]) return 0; map_delete(elections, election); save_room(); return 1; } /** * This is an administrative function to allow the removal/cancellation * of a vote. * @param vote_id The id number of the vote to be cancelled. * @return Returns 1 for success, 0 for failure. */ int delete_vote(int vote_id) { if(!votes[vote_id]) return 0; map_delete(votes, vote_id); save_room(); return 1; }