/** * This is the handler for all things clubby, a club being a group of * players. Each club must have a unique name. It also handles elections * for various club positions. * @author Pinkfish * @started Sun Sep 27 03:35:42 EDT 1998 */ inherit "/handlers/inherit/club_personal"; #define __CLUBS_H_NO_CLASSES #include <clubs.h> #include <login.h> // Special variables to control the club inner workings. private nosave mapping _valid_relationships; private nosave mapping _gender_relationship; private void add_valid_relationship(string relation, string relation2, int flags); private void add_gender_relationship(string relationship, string male, string female); string* query_gender_relationships(string relationship); /** * The stuff releated to families. * @member relationships the relations in this family * @member never_join the list of people who can never join */ class family_info { mapping relationships; string *never_join; // Couple of extra variables for when I think of something else to go // in here. int tmp1; int tmp2; } #define CLUB_INTERFAMILY_FLAG 1 #define CLUB_JOIN_FAMILY_FLAG 2 /** * The information associated with relationship names. * @member opposite the opposite relationship name * @member flags flags associated with the relationship's */ class relationship_type_data { string opposite; int flags; } void create() { _valid_relationships = ([ ]); _gender_relationship = ([ ]); ::create(); add_valid_relationship("spouse", "spouse", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("spouse", "husband", "wife"); add_valid_relationship("sibling", "sibling", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("sibling", "brother", "sister"); add_valid_relationship("sibling-in-law", "sibling-in-law", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("sibling-in-law", "brother-in-law", "sister-in-law"); add_valid_relationship("child", "parent", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("child", "son", "daughter"); add_gender_relationship("parent", "father", "mother"); add_valid_relationship("grandparent", "grandchild", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("grandparent", "grandfather", "grandmother"); add_gender_relationship("grandchild", "grandson", "granddaughter"); add_valid_relationship("godchild", "godparent", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("godchild", "godson", "goddaughter"); add_gender_relationship("godparent", "godfather", "godmother"); add_valid_relationship("uncle", "niece", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("uncle", "uncle", "aunt"); add_gender_relationship("niece", "nephew", "niece"); add_valid_relationship("cousin", "cousin", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("cousin", "cousin", "cousin"); add_valid_relationship("master", "maid", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("maid", "butler", "maid"); add_gender_relationship("master", "master", "mistress"); add_valid_relationship("apprentice", "tutor", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("apprentice", "apprentice", "apprentice"); add_gender_relationship("tutor", "tutor", "tutor"); add_valid_relationship("guardian", "ward", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("guardian", "guardian", "guardian"); add_gender_relationship("ward", "ward", "ward"); add_valid_relationship("ex-spouse", "ex-spouse", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("ex-spouse", "ex-husband", "ex-wife"); add_valid_relationship("fiance", "fiancee", CLUB_INTERFAMILY_FLAG | CLUB_JOIN_FAMILY_FLAG); add_gender_relationship("fiance", "fiance", "fiancee"); } /* create() */ protected void create_extra_data(string name) { class family_info f_info; class club_info data; data = query_club_info(name); if (query_club_type(name) == CLUB_FAMILY) { f_info = new(class family_info); f_info->relationships = ([ ]); f_info->never_join = ({ }); data->extra_data = f_info; } else { ::create_extra_data(name); } set_club_changed(name); } /* create_extra_data() */ /** * This method determines how much the club will cost to run each * pay period. * @param club_name the name of the club to get the fees for * @return the amount the club will cost in the next pay period * @see query_time_fees_due() */ int query_club_cost_per_period(string club_name) { if (is_club(club_name)) { if (is_family(club_name)) { return FAMILY_COST_PER_YEAR + sizeof(query_members(club_name)) * FAMILY_COST_PER_MEMBER_PER_YEAR; } else { return ::query_club_cost_per_period(club_name); } } return 0; } /* query_club_cost_per_period() */ /** * This method returns the family information. * @param the name of the club * @return the family information */ private class family_info query_family_info(string name) { class club_info data; if (is_family(name)) { data = query_club_info(name); return data->extra_data; } } /* query_family_info() */ /** * This method adds a valid relationship to the current list. * @param relation1 the first relationship * @param relation2 the second relationship * @see query_opposite_relationship() * @see is_valid_interfamily_relationship() * @see is_valid_join_family_relationship() * @see is_valid_relationship() */ void add_valid_relationship(string relation1, string relation2, int flags) { class relationship_type_data frog; frog = new(class relationship_type_data); frog->opposite = relation2; frog->flags = flags; _valid_relationships[relation1] = frog; frog = new(class relationship_type_data); frog->opposite = relation1; frog->flags = flags; _valid_relationships[relation2] = frog; } /* add_valid_relationship() */ /** * This method returns the opposite relationship to the specified one. * @param relation the relation to return the opposite of * @return the opposite of the relationship * @see add_valid_relationship() * @see is_valid_interfamily_relationship() * @see is_valid_join_family_relationship() * @see is_valid_relationship() */ string query_opposite_relationship(string relation) { if (_valid_relationships[relation]) { return _valid_relationships[relation]->opposite; } return 0; } /* query_opposite_relationship() */ /** * This method checks to make sure the specified relationship is valid. * @param relation the relationship to check for validity * @return 1 if the relationship is valid * @see query_opposite_relationship() * @see is_valid_interfamily_relationship() * @see is_valid_join_family_relationship() * @see add_valid_relationship() */ int is_valid_relationship(string str) { return _valid_relationships[str] != 0; } /* is_valid_relationship() */ /** * This method checks to see if the relation is a valid interfamily one. * @param str the relationship to check * @return 1 if the relation is a valid interfamily one * @see is_valid_relationship() * @see is_valid_join_family_relationship() */ int is_valid_interfamily_relationship(string str) { class relationship_type_data frog; frog = _valid_relationships[str]; if (frog) { if (frog->flags & CLUB_INTERFAMILY_FLAG) { return 1; } } return 0; } /* is_valid_interfamily_relationship() */ /** * This method checks to see if the relation is a valid join family one. * @param str the relationship to check * @return 1 if the relation is a valid join family one * @see is_valid_relationship() * @see is_valid_interfamily_relationship() * @see add_valid_relationship() * @see query_opposite_relationship() */ int is_valid_join_family_relationship(string str) { class relationship_type_data frog; frog = _valid_relationships[str]; if (frog) { if (frog->flags & CLUB_JOIN_FAMILY_FLAG) { return 1; } } return 0; } /* is_valid_interfamily_relationship() */ /** * This method returns all the valid relationships. * @return all the current valid relationship types * @see add_valid_relationship() * @see is_valid_interfamily_relationship() * @see is_valid_join_family_relationship() * @see is_valid_relationship() * @see query_opposite_relationship() */ string *query_all_valid_relationships() { return keys(_valid_relationships); } /* query_all_valid_relationships() */ /** * This method adds a the different gender types for the * relationship. * @param relationship the relationship to set the genders for * @param male the male gender type * @param female the female gender type * @see query_all_relationships() * @see query_ungendered_relationships() */ private void add_gender_relationship(string relationship, string male, string female) { _gender_relationship[male] = relationship; _gender_relationship[female] = relationship; _gender_relationship[relationship] = ({ male, female }); } /* add_gender_relationship() */ /** * This returns the real relationship type based on the possible * genderised relationship. * @param relationship the relationship to get the real relationship for * @return the degendered relationship name * @see add_gender_relationship() * @see query_all_relationship_types() */ string query_ungendered_relationship(string relationship) { if (stringp(_gender_relationship[relationship])) { return _gender_relationship[relationship]; } if (pointerp(_gender_relationship[relationship])) { return relationship; } return 0; } /* query_ungendered_relationship() */ /** * This method returns all the possible relationships, including the * gendered ones. * @return the array of possible relationships * @see query_ungendered_relationship() * @see add_gender_relationship() */ string *query_all_relationships() { return keys(_gender_relationship); } /* query_all_relationships() */ /** * This method returns the genderised version of the relationship. * @param name relationship the relation to get the gender of * @param female 0 for male, 1 for female * @see query_all_relationships() * @see query_ungendered_relationship() * @see add_gender_relationships() * @see query_all_relationships() */ string query_relationship_gender(string relationship, int female) { string rel; rel = query_ungendered_relationship(relationship); if (!rel || female < 0 || female > 1) { return 0; } return _gender_relationship[rel][female]; } /* query_relationship_gender() */ private void real_add_relationship(string name, string person, string dest, string relationship) { class family_info womble; class relationship_data plum; womble = query_family_info(name); if (!womble->relationships[person]) { womble->relationships[person] = ({ }); } plum = new(class relationship_data); plum->related_to = dest; plum->relationship = relationship; womble->relationships[person] += ({ plum }); set_club_changed(name); } /* real_add_relationship() */ private void real_remove_relationship(string name, string person, string dest, string relationship) { class family_info womble; int i; womble = query_family_info(name); for (i = 0; i < sizeof(womble->relationships[person]); i++) { if (womble->relationships[person][i]->related_to == dest && womble->relationships[person][i]->relationship == relationship) { womble->relationships[person] = womble->relationships[person][0..i-1] + womble->relationships[person][i+1..]; set_club_changed(name); } } } /* real_add_relationship() */ /** * This method adds a relationship between two members of a family. * @param name the name of the family * @param person the person the relationship is from * @param dest the person the relationship is to * @param dest_name the name of the family the other person is in * @param relationship the relationship they have to you * @return 1 if succcessful, 0 if not */ int add_relationship(string name, string person, string dest_name, string dest, string relationship) { if (is_family(name) && is_family(dest_name) && is_member_of(name, person) && is_member_of(dest_name, dest) && is_valid_relationship(relationship)) { real_add_relationship(name, person, dest, relationship); // Add the reverse to the other person. real_add_relationship(dest_name, dest, person, query_opposite_relationship(relationship)); save_club(name); return 1; } return 0; } /* add_relationship() */ /** * This method returns the relationships the selected person has to * the other people in the family. * @param name the name of the family * @param person the person who to query the relationships for * @return the list of all the relationships the person has */ class relationship_data *query_relationships(string name, string person) { class family_info womble; if (is_family(name)) { womble = query_family_info(name); if (womble->relationships[person]) { return womble->relationships[person]; } } return ({ }); } /* query_relationships() */ /** * This method moves a person from one family to another family. * @param curr_family the current family * @param person the persons name * @param dest_family the destination family * @return 1 if successful moved * @see add_member() */ int move_family_member(string curr_family, string person, string dest_family) { class relationship_data *stuff; class family_info womble; if (is_family(curr_family) && is_family(dest_family) && is_member_of(curr_family, person)) { stuff = query_relationships(curr_family, person); /* Remove the relationships first. */ womble = query_family_info(curr_family); map_delete(womble->relationships, person); set_club_changed(curr_family); remove_member(curr_family, person); /* Add the new relationship. */ add_member(dest_family, person); womble = query_family_info(dest_family); womble->relationships[person] = stuff; set_club_changed(dest_family); return 1; } return 0; } /* move_family_member() */ /** * This method returns how the first player is related to the second player. * @param name the family the relationship is in * @param person the person the relationship is from * @param related to person they are related to * @return the array of relationships they have */ string *query_relationships_to(string name, string person, string related) { class relationship_data frog; string *relationships; relationships = ({ }); foreach (frog in query_relationships(name, person)) { if (frog->related_to == related) { relationships += ({ frog->relationship }); } } return relationships; } /* query_relationships_to() */ /** * This method checks to see if the specified relationship exists. * @param name the family the relationship is in * @param person the person the relationship is from * @param related to person they are related to * @param relationship the type of relationship they have * @return 1 if the relationship exists, 0 if not */ int is_relationship(string name, string person, string related, string relationship) { class relationship_data frog; foreach (frog in query_relationships(name, person)) { if (frog->related_to == related && frog->relationship == relationship) { return 1; } } return 0; } /* is_relationship() */ /** * This method removes a relationship from the club. * @param name the name of the family * @param person the person the relationship is from * @param dest the person the relationship is to * @param relationship the relationship they have to you * @return 1 if succcessful, 0 if not */ int remove_relationship(string name, string person, string dest_name, string dest, string relationship) { if (is_relationship(name, person, dest, relationship)) { real_remove_relationship(name, person, dest, relationship); if (dest_name) { real_remove_relationship(dest_name, dest, person, query_opposite_relationship(relationship)); } return 1; } return 0; } /* remove_relationship() */ /** * This method checks the extra information for the club. Please note * this does *not* save the information. You need to do this yourself. * @param name the name of the club to check * @see check_clubs() * @see remove_member() */ protected void check_family_information(string name, string member, int startup) { class family_info fam_data; // class relationship_data rel; string family; fam_data = query_family_info(name); if (fam_data) { /* * Check the stuff in the club to make sure the positions and stuff * are still valid. */ if (member && fam_data->relationships[member]) { family = LOGIN_OB->test_family(member); if (!family || normalise_name(family) != name) { if (find_player(member)) { find_player(member)->set_family_name(family); } else { log_file("CLUB", ctime(time()) + ": removed " + member + " from " + family + " family deficent.\n"); remove_member(name, member); } } /* foreach (rel in fam_data->relationships[member]) { family = PLAYER_HANDLER->test_family(rel->related_to); if (!family) { log_file("CLUB", ctime(time()) + ": removed relationship between " + member + " <-> " + rel->related_to + " (" + rel->relationship + "; family deficent.\n"); real_remove_relationship(name, member, rel->related_to, rel->relationship); } } */ /* Are they a member of any family now? Hmm... */ if (!undefinedp(fam_data->relationships)) { map_delete(fam_data->relationships, member); set_club_changed(name); } } } } /* check_family_information() */