swg-source/dsrc
1
0
Fork 0
mirror of https://github.com/SWG-Source/dsrc.git synced 2026-07-31 00:15:54 -04:00
Code Issues Projects Releases Wiki Activity
Files
485a019196716d64c53dd2de20071b751c1cfc7b
dsrc/sku.0/sys.server/compiled/game/script/library/guild.scriptlib
T

3061 lines
91 KiB
Plaintext
Raw Blame History

// ======================================================================
//
// guild.scriptlib
//
// Copyright 2002 Sony Online Entertainment
//
// ======================================================================
// ======================================================================
// GUILD_PERMISSION_MEMBER and GUILD_PERMISSION_MAIL are referenced from code and
// must be updated in GuildInterface.cpp if changed. These should not be moved in
// any case, since they are persisted and the db would need to be updated.
const int GUILD_PERMISSIONS_NONE = 0; // sponsored
// administrative guild permissions
const int GUILD_PERMISSION_MEMBER = (1<<0); // used to differentiate between sponsored and member
const int GUILD_PERMISSION_SPONSOR = (1<<1);
const int GUILD_PERMISSION_DISBAND = (1<<2);
const int GUILD_PERMISSION_ACCEPT = (1<<3);
const int GUILD_PERMISSION_KICK = (1<<4);
const int GUILD_PERMISSION_MAIL = (1<<5);
const int GUILD_PERMISSION_TITLE = (1<<6);
const int GUILD_PERMISSION_NAMECHANGE = (1<<7);
const int GUILD_PERMISSION_WAR = (1<<8);
const int GUILD_PERMISSION_RANK = (1<<9);
// if you need to add a new administrative guild permission,
// use one of the following reserved administrative guild
// permissions, which has been reserved for that specific purpose
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED1 = (1<<10);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED2 = (1<<11);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED3 = (1<<12);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED4 = (1<<13);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED5 = (1<<14);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED6 = (1<<15);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED7 = (1<<16);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED8 = (1<<17);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED9 = (1<<18);
const int GUILD_PERMISSION_ADMINISTRATIVE_RESERVED10 = (1<<19);
const int GUILD_PERMISSIONS_ALL_ADMINISTRATIVE = (GUILD_PERMISSION_MEMBER | GUILD_PERMISSION_SPONSOR | GUILD_PERMISSION_DISBAND | GUILD_PERMISSION_ACCEPT | GUILD_PERMISSION_KICK | GUILD_PERMISSION_MAIL | GUILD_PERMISSION_TITLE | GUILD_PERMISSION_NAMECHANGE | GUILD_PERMISSION_WAR | GUILD_PERMISSION_RANK | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED1 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED2 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED3 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED4 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED5 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED6 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED7 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED8 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED9 | GUILD_PERMISSION_ADMINISTRATIVE_RESERVED10);
// non-administrative guild permissions
const int GUILD_PERMISSION_ELECTION_CANDIDATE = (1<<20); // guild member is running in the current guild election
const int GUILD_PERMISSION_WAR_INCLUSION = (1<<21); // guild member is in the guild war inclusion list
const int GUILD_PERMISSION_WAR_EXCLUSION = (1<<22); // guild member is in the guild war exclusion list
const int GUILD_PERMISSION_ONLINE_STATUS = (1<<23); // guild member logs in/off notification
const int GUILD_PERMISSIONS_ALL_PERSONAL = (GUILD_PERMISSION_WAR_EXCLUSION | GUILD_PERMISSION_ONLINE_STATUS);
const int GUILD_MEMBERS_PER_PAGE = 25;
const string GUILD_MAIL_DISBAND_SUBJECT = "@guildmail:disband_subject";
const string_id GUILD_MAIL_DISBAND_TEXT = new string_id("guildmail", "disband_text");
const string_id GUILD_MAIL_DISBAND_NOT_ENOUGH_MEMBERS_TEXT = new string_id("guildmail", "disband_not_enough_members_text");
const string GUILD_MAIL_SPONSOR_SUBJECT = "@guildmail:sponsor_subject";
const string_id GUILD_MAIL_SPONSOR_TEXT = new string_id("guildmail", "sponsor_text");
const string GUILD_MAIL_ACCEPT_SUBJECT = "@guildmail:accept_subject";
const string_id GUILD_MAIL_ACCEPT_TEXT = new string_id("guildmail", "accept_text");
const string GUILD_MAIL_ACCEPT_TARGET_SUBJECT = "@guildmail:accept_target_subject";
const string_id GUILD_MAIL_ACCEPT_TARGET_TEXT = new string_id("guildmail", "accept_target_text");
const string GUILD_MAIL_KICK_SUBJECT = "@guildmail:kick_subject";
const string_id GUILD_MAIL_KICK_TEXT = new string_id("guildmail", "kick_text");
const string GUILD_MAIL_DECLINE_SUBJECT = "@guildmail:decline_subject";
const string_id GUILD_MAIL_DECLINE_TEXT = new string_id("guildmail", "decline_text");
const string GUILD_MAIL_DECLINE_TARGET_SUBJECT = "@guildmail:decline_target_subject";
const string_id GUILD_MAIL_DECLINE_TARGET_TEXT = new string_id("guildmail", "decline_target_text");
const string GUILD_MAIL_NAMECHANGE_SUBJECT = "@guildmail:namechange_subject";
const string_id GUILD_MAIL_NAMECHANGE_TEXT = new string_id("guildmail", "namechange_text");
const string GUILD_MAIL_LEADERCHANGE_SUBJECT = "@guildmail:leaderchange_subject";
const string_id GUILD_MAIL_LEADERCHANGE_TEXT = new string_id("guildmail", "leaderchange_text");
const string GUILD_MAIL_LEAVE_SUBJECT = "@guildmail:leave_subject";
const string_id GUILD_MAIL_LEAVE_TEXT = new string_id("guildmail", "leave_text");
const string_id SID_GUILD_SPONSOR_NOT_FOUND = new string_id ("guild", "sponsor_not_found");
const string_id SID_GUILD_MEMBER_NOT_FOUND = new string_id ("guild", "could_not_find_member");
const string STR_GUILD_PERMISSION_MAIL_YES = "@guild:permission_mail_yes";
const string STR_GUILD_PERMISSION_MAIL_NO = "@guild:permission_mail_no";
const string STR_GUILD_PERMISSION_SPONSOR_YES = "@guild:permission_sponsor_yes";
const string STR_GUILD_PERMISSION_SPONSOR_NO = "@guild:permission_sponsor_no";
const string STR_GUILD_PERMISSION_TITLE_YES = "@guild:permission_title_yes";
const string STR_GUILD_PERMISSION_TITLE_NO = "@guild:permission_title_no";
const string STR_GUILD_PERMISSION_ACCEPT_YES = "@guild:permission_accept_yes";
const string STR_GUILD_PERMISSION_ACCEPT_NO = "@guild:permission_accept_no";
const string STR_GUILD_PERMISSION_KICK_YES = "@guild:permission_kick_yes";
const string STR_GUILD_PERMISSION_KICK_NO = "@guild:permission_kick_no";
const string STR_GUILD_PERMISSION_WAR_YES = "@guild:permission_war_yes";
const string STR_GUILD_PERMISSION_WAR_NO = "@guild:permission_war_no";
const string STR_GUILD_PERMISSION_NAMECHANGE_YES= "@guild:permission_namechange_yes";
const string STR_GUILD_PERMISSION_NAMECHANGE_NO = "@guild:permission_namechange_no";
const string STR_GUILD_PERMISSION_DISBAND_YES = "@guild:permission_disband_yes";
const string STR_GUILD_PERMISSION_DISBAND_NO = "@guild:permission_disband_no";
const string STR_GUILD_PERMISSION_RANK_YES = "@guild:permission_rank_yes";
const string STR_GUILD_PERMISSION_RANK_NO = "@guild:permission_rank_no";
const string STR_GUILD_PERMISSION_MAIL = "@guild:permission_mail";
const string STR_GUILD_PERMISSION_SPONSOR = "@guild:permission_sponsor";
const string STR_GUILD_PERMISSION_TITLE = "@guild:permission_title";
const string STR_GUILD_PERMISSION_ACCEPT = "@guild:permission_accept";
const string STR_GUILD_PERMISSION_KICK = "@guild:permission_kick";
const string STR_GUILD_PERMISSION_WAR = "@guild:permission_war";
const string STR_GUILD_PERMISSION_NAMECHANGE = "@guild:permission_namechange";
const string STR_GUILD_PERMISSION_DISBAND = "@guild:permission_disband";
const string STR_GUILD_PERMISSIONS_PROMPT = "@guild:permissions_prompt";
const string_id SID_GUILD_PERMISSIONS_TITLE = new string_id("guild", "permissions_title");
const string STR_GUILD_REMOTE_DEVICE = "object/intangible/data_item/guild_stone.iff";
const string STR_GUILD_MEMBERS_PROMPT = "@guild:members_prompt";
const string STR_GUILD_MEMBERS_FILTER_PROMPT = "@guild:members_filter_prompt";
const string STR_GUILD_MEMBERS_TITLE = "@guild:members_title";
const string STR_GUILD_MEMBERS_NAME_PROMPT = "@guild:members_name_prompt";
const string STR_GUILD_INFO_TITLE = "@guild:info_title";
const string STR_GUILD_ADD_ENEMY = "@guild:add_enemy";
const string_id GUILD_ENEMIES_PROMPT = new string_id("guild", "enemies_prompt");
const string STR_GUILD_ENEMIES_TITLE = "@guild:enemies_title";
const string STR_GUILD_WAR_ENEMY_NAME_PROMPT = "@guild:war_enemy_name_prompt";
const string STR_GUILD_WAR_ENEMY_NAME_TITLE = "@guild:war_enemy_name_title";
const string STR_GUILD_ACCEPT = "@guild:accept";
const string STR_GUILD_DECLINE = "@guild:decline";
const string STR_GUILD_SPONSORED_OPTIONS_PROMPT = "@guild:sponsored_options_prompt";
const string STR_GUILD_SPONSORED_OPTIONS_TITLE = "@guild:sponsored_options_title";
const string STR_GUILD_SPONSORED_PROMPT = "@guild:sponsored_prompt";
const string STR_GUILD_SPONSORED_TITLE = "@guild:sponsored_title";
const string STR_GUILD_NAMECHANGE_ABBREV_PROMPT = "@guild:namechange_abbrev_prompt";
const string STR_GUILD_NAMECHANGE_ABBREV_TITLE = "@guild:namechange_abbrev_title";
const string STR_GUILD_SPONSOR_VERIFY_PROMPT = "@guild:sponsor_verify_prompt";
const string STR_GUILD_SPONSOR_VERIFY_TITLE = "@guild:sponsor_verify_title";
const string STR_GUILD_SPONSOR_PROMPT = "@guild:sponsor_prompt";
const string STR_GUILD_SPONSOR_TITLE = "@guild:sponsor_title";
const string STR_GUILD_DISBAND_TITLE = "@guild:disband_title";
const string STR_GUILD_DISBAND_PROMPT = "@guild:disband_prompt";
const string STR_GUILD_NAMECHANGE_NAME_PROMPT = "@guild:namechange_name_prompt";
const string STR_GUILD_NAMECHANGE_NAME_TITLE = "@guild:namechange_name_title";
const string STR_GUILD_RANK_SUMMARY_PROMPT = "@guild:guild_rank_summary_prompt";
const string REGISTERED_GUILD = "guild.guildId";
const string GUILD_SCREEN_ID = "guild.guildScreenId";
const string GUILD_SCREEN_TYPE = "guild.guildScreen.type";
const string GUILD_SCREEN_TEMPLATE = "object/tangible/furniture/technical/guild_registry.iff";
const string STR_GUILD_MEMBER_OPTIONS_PROMPT = "@guild:member_options_prompt";
const string STR_GUILD_MEMBER_OPTIONS_TITLE = "@guild:member_options_title";
const string STR_GUILD_MEMBER_RANK_PROMPT = "@guild:member_rank_prompt";
const string STR_GUILD_MEMBER_RANK_TITLE = "@guild:member_rank_title";
const string STR_GUILD_TITLE = "@guild:title";
const string STR_GUILD_KICK = "@guild:kick";
const string STR_GUILD_RANK = "@guild:rank";
const string STR_GUILD_PERMISSIONS = "@guild:permissions";
const string STR_GUILD_WAR_EXCLUDE_TOGGLE = "@guild:war_exclude_toggle";
const string STR_GUILD_WAR_INCLUDE_TOGGLE = "@guild:war_include_toggle";
const string STR_GUILD_TITLE_PROMPT = "@guild:title_prompt";
const string STR_GUILD_TITLE_TITLE = "@guild:title_title";
const string STR_GUILD_KICK_TITLE = "@guild:kick_title";
const string STR_GUILD_KICK_PROMPT = "@guild:kick_prompt";
const string_id SID_GUILD_PERMISSION_MAIL = new string_id("guild", "permission_mail");
const string_id SID_GUILD_PERMISSION_SPONSOR = new string_id("guild", "permission_sponsor");
const string_id SID_GUILD_PERMISSION_TITLE = new string_id("guild", "permission_title");
const string_id SID_GUILD_PERMISSION_ACCEPT = new string_id("guild", "permission_accept");
const string_id SID_GUILD_PERMISSION_KICK = new string_id("guild", "permission_kick");
const string_id SID_GUILD_PERMISSION_WAR = new string_id("guild", "permission_war");
const string_id SID_GUILD_PERMISSION_NAMECHANGE = new string_id("guild", "permission_namechange");
const string_id SID_GUILD_PERMISSION_DISBAND = new string_id("guild", "permission_disband");
const string_id SID_GUILD_PERMISSION_RANK = new string_id("guild", "rank");
const string_id SID_GUILD_PERMISSION_WAR_EXCLUDE = new string_id("guild", "war_exclude");
const string_id SID_GUILD_PERMISSION_WAR_INCLUDE = new string_id("guild", "war_include");
const string STR_SUI_BACK_BUTTON = "@guild:back_button";
const string[] MEMBER_FILTER_LIST =
{
"@guild:member_filter_alpha",
"@guild:member_filter_permission",
"@guild:member_filter_title",
"@guild:member_filter_name"
};
const string[] PERMISSION_LIST =
{
STR_GUILD_PERMISSION_MAIL,
STR_GUILD_PERMISSION_SPONSOR,
STR_GUILD_PERMISSION_TITLE,
STR_GUILD_PERMISSION_ACCEPT,
STR_GUILD_PERMISSION_KICK,
STR_GUILD_PERMISSION_WAR,
STR_GUILD_PERMISSION_NAMECHANGE,
STR_GUILD_PERMISSION_DISBAND
};
const string_id SID_GUILD_CREATE_FAIL_IN_GUILD = new string_id ("guild", "create_fail_in_guild");
const string_id SID_GUILD_CREATE_FAIL_NAME_BAD_LENGTH = new string_id ("guild", "create_fail_name_bad_length");
const string_id SID_GUILD_CREATE_FAIL_ABBREV_BAD_LENGTH = new string_id ("guild", "create_fail_abbrev_bad_length");
const string_id SID_GUILD_CREATE_FAIL_NAME_IN_USE = new string_id ("guild", "create_fail_name_in_use");
const string_id SID_GUILD_CREATE_FAIL_ABBREV_IN_USE = new string_id ("guild", "create_fail_abbrev_in_use");
const string_id SID_GUILD_CREATE_FAIL_NAME_NOT_ALLOWED = new string_id ("guild", "create_fail_name_not_allowed");
const string_id SID_GUILD_CREATE_FAIL_ABBREV_NOT_ALLOWED = new string_id ("guild", "create_fail_abbrev_not_allowed");
const string_id SID_GUILD_SPONSOR_FAIL_FULL = new string_id ("guild", "sponsor_fail_full");
const string_id SID_GUILD_SPONSOR_ALREADY_IN_GUILD = new string_id ("guild", "sponsor_already_in_guild");
const string_id SID_GUILD_TITLE_FAIL_BAD_LENGTH = new string_id ("guild", "title_fail_bad_length");
const string_id SID_GUILD_TITLE_FAIL_NOT_ALLOWED = new string_id ("guild", "title_fail_not_allowed");
const string_id SID_GUILD_GENERIC_FAIL_NO_PERMISSION = new string_id ("guild", "generic_fail_no_permission");
const string_id SID_GUILD_LEAVE_FAIL_LEADER_TRIED_TO_LEAVE = new string_id ("guild", "leave_fail_leader_tried_to_leave");
const string_id SID_GUILD_WAR_FAIL_NO_SUCH_GUILD = new string_id ("guild", "war_fail_no_such_guild");
const string_id SID_GUILD_KICK_SELF = new string_id ("guild", "kick_self");
const string_id SID_GUILD_KICK_TARGET = new string_id ("guild", "kick_target");
const string_id SID_GUILD_DECLINE_SELF = new string_id ("guild", "decline_self");
const string_id SID_GUILD_DECLINE_TARGET = new string_id ("guild", "decline_target");
const string_id SID_GUILD_SPONSOR_SELF = new string_id ("guild", "sponsor_self");
const string_id SID_GUILD_SPONSOR_TARGET = new string_id ("guild", "sponsor_target");
const string_id SID_GUILD_ACCEPT_SELF = new string_id ("guild", "accept_self");
const string_id SID_GUILD_ACCEPT_TARGET = new string_id ("guild", "accept_target");
const string_id SID_GUILD_LEAVE_SELF = new string_id ("guild", "leave_self");
const string_id SID_GUILD_TITLE_SELF = new string_id ("guild", "title_self");
const string_id SID_GUILD_TITLE_TARGET = new string_id ("guild", "title_target");
const string_id SID_GUILD_NAMECHANGE_FAIL_ABBREV_BAD_LENGTH = new string_id ("guild", "namechange_fail_abbrev_bad_length");
const string_id SID_GUILD_NAMECHANGE_FAIL_NAME_BAD_LENGTH = new string_id ("guild", "namechange_fail_name_bad_length");
const string_id SID_GUILD_NAMECHANGE_FAIL_ABBREV_NOT_ALLOWED = new string_id ("guild", "namechange_fail_abbrev_not_allowed");
const string_id SID_GUILD_NAMECHANGE_FAIL_NAME_NOT_ALLOWED = new string_id ("guild", "namechange_fail_name_not_allowed");
const string_id SID_GUILD_NAMECHANGE_SELF = new string_id ("guild", "namechange_self");
const string_id SID_GUILD_ALLEGIANCE_SELF = new string_id ("guild", "allegiance_self");
const string_id SID_GUILD_ALLEGIANCE_UNCHANGED_SELF = new string_id ("guild", "allegiance_unchanged_self");
const string_id SID_NO_FREE_TRIAL = new string_id ("guild", "no_free_trial");
const string_id SID_GUILD_SPONSOR_ACCEPT = new string_id ("guild", "sponsor_accept");
const string_id SID_GUILD_SPONSOR_DECLINE = new string_id ("guild", "sponsor_decline");
const string_id SID_GUILD_NO_DESTROY_REMOTE = new string_id ("guild", "no_destroy_remote");
const string_id SID_SUI_CANNOT_BACK_FURTHER = new string_id ("guild", "no_back_further");
const string_id SID_MAKE_NEW_SCREEN = new string_id ("guild", "make_new_screen");
const string_id SID_NO_TITLES_IN_GUILD = new string_id ("guild", "no_titles_in_guild");
const string_id SID_NO_CANDIDATES = new string_id ("guild", "vote_no_candidates");
const string_id SID_GUILD_WAR_EXCLUSION_TOGGLED = new string_id ("guild", "sid_guild_war_exclusion_toggled");
const string_id SID_GUILD_WAR_INCLUSION_TOGGLED = new string_id ("guild", "sid_guild_war_inclusion_toggled");
const string_id SID_COMPLETED_ELECTIONS_EMAIL_BODY_LEADER_SAME = new string_id("guild", "sid_completed_elections_email_body_leader_same");
const string_id SID_COMPLETED_ELECTIONS_EMAIL_BODY_LEADER_CHANGED = new string_id("guild", "sid_completed_elections_email_body_leader_changed");
const int MAX_MEMBERS_PER_GUILD = 500;
const int [] PERMISSION_INTERFACE_FLAGS =
{
0,
GUILD_PERMISSION_SPONSOR,
GUILD_PERMISSION_ACCEPT,
GUILD_PERMISSION_KICK,
GUILD_PERMISSION_MAIL,
GUILD_PERMISSION_TITLE,
GUILD_PERMISSION_DISBAND,
GUILD_PERMISSION_NAMECHANGE,
GUILD_PERMISSION_RANK,
GUILD_PERMISSION_WAR,
GUILD_PERMISSION_WAR_EXCLUSION,
GUILD_PERMISSION_WAR_INCLUSION
};
const int INTERFACE_GUILD_UNKNOWN = 0;
const int INTERFACE_GUILD_ROSTER = 1;
const int INTERFACE_GUILD_RANK_LIST = 2;
const int INTERFACE_GUILD_RANK_SUMMARY = 3;
const int INTERFACE_GUILD_PERMISSION_LIST = 4;
const int INTERFACE_GUILD_ELECTION = 5;
const int INTERFACE_GUILD_WAR_PREFERENCES = 6;
// ======================================================================
string resolveGuildName(int guildId)
{
if (guildId != 0)
{
string guildName = guildGetName(guildId);
if (guildName != null && guildName != "")
return guildName;
return "unknown";
}
return "none";
}
// ----------------------------------------------------------------------
string resolveMemberName(int guildId, obj_id who)
{
if (isIdValid(who))
{
// try to get name directly
{
string s = getName(who);
if (s != null && s != "")
return s;
}
// try to get name from guild info
{
string s = guildGetMemberName(guildId, who);
if (s != null && s != "")
return s;
}
return "unknown";
}
return "none";
}
// ----------------------------------------------------------------------
void GuildLog(int guildId, string command, obj_id actor, obj_id target, string description)
{
string guildDesc = resolveGuildName(guildId);
string actorDesc = resolveMemberName(guildId, actor);
CustomerServiceLog("Guild", "[command="+command+"] [guild="+guildId+"("+guildDesc+")] [actor="+actor+"("+resolveMemberName(guildId, actor)+")] [target="+target+"("+resolveMemberName(guildId, target)+")] - " + description);
}
// ----------------------------------------------------------------------
string buildFakeLocalizedProse(string rawText, string substitute1, string substitute2)
{
if (rawText.startsWith("@"))
{
string cookedText = new string(rawText);
// convert text into a string id and localize it
string_id id = new string_id(rawText.substring(1, rawText.indexOf(":")), rawText.substring(rawText.indexOf(":")+1, rawText.length()));
cookedText = localize(id);
// replace %TU
int pos1 = cookedText.indexOf("%TU");
if (pos1 != -1)
cookedText = cookedText.substring(0, pos1) + substitute1 + cookedText.substring(pos1+3, cookedText.length());
// replace %TT
int pos2 = cookedText.indexOf("%TT");
if (pos2 != -1)
cookedText = cookedText.substring(0, pos2) + substitute2 + cookedText.substring(pos2+3, cookedText.length());
return cookedText;
}
else
return rawText;
}
// ======================================================================
boolean hasGuildPermission(int guildId, obj_id who, int permission)
{
if(guildId == 0)
{
return false;
}
if(!isIdValid(who))
{
return false;
}
// We do not want god mode to affect non-administrative permissions
if(isGod(who) && (permission & (~GUILD_PERMISSIONS_ALL_ADMINISTRATIVE)) == 0)
{
return true;
}
if((guildGetMemberPermissions(guildId, who) & permission) == permission)
{
return true;
}
return false;
}
// ----------------------------------------------------------------------
boolean hasDeclaredWarAgainst(int guildId, int enemyId)
{
int[] enemies = guildGetEnemies(guildId);
if (enemies != null)
for (int i = 0; i < enemies.length; ++i)
if (enemies[i] == enemyId)
return true;
return false;
}
// ======================================================================
int create(obj_id actor, string guildName, string guildAbbrev)
{
if(isFreeTrialAccount(actor))
{
sendSystemMessage(actor, SID_NO_FREE_TRIAL);
return 0;
}
if (getGuildId(actor) != 0)
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_IN_GUILD);
else if (guildAbbrev.length() < 1 || guildAbbrev.length() > 5)
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_ABBREV_BAD_LENGTH);
else if (guildName.length() < 1 || guildName.length() > 25)
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_NAME_BAD_LENGTH);
else if (findGuild(guildAbbrev) != 0)
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_ABBREV_IN_USE);
else if (findGuild(guildName) != 0)
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_NAME_IN_USE);
else if (isNameReserved(guildAbbrev))
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_ABBREV_NOT_ALLOWED);
else if (isNameReserved(guildName))
sendSystemMessage(actor, SID_GUILD_CREATE_FAIL_NAME_NOT_ALLOWED);
else
{
int guildId = createGuild(guildName, guildAbbrev);
if (guildId != 0)
{
GuildLog(guildId, "create", actor, null, "guildName='"+guildName+"' guildAbbrev='"+guildAbbrev+"'");
guildAddCreatorMember(guildId, actor);
guildSetLeader(guildId, actor);
return guildId;
}
return 0;
}
return 0;
}
// ----------------------------------------------------------------------
void changeLeader(int guildId, obj_id newLeader)
{
obj_id oldLeader = guildGetLeader(guildId);
if (oldLeader != newLeader && isIdValid(newLeader))
{
GuildLog(guildId, "changeLeader", null, newLeader, "");
mailToGuild(guildId, GUILD_MAIL_LEADERCHANGE_SUBJECT, GUILD_MAIL_LEADERCHANGE_TEXT, guildGetMemberName(guildId, newLeader));
obj_id[] memberIds = getMemberIds(guildId, false, true);
// set old leader's permissions if they are still in the guild
if (findObjIdTableOffset(memberIds, oldLeader) != -1)
{
guildSetMemberPermissionAndAllegiance(guildId, oldLeader, ((guildGetMemberPermissions(guildId, oldLeader) & (~GUILD_PERMISSIONS_ALL_ADMINISTRATIVE)) | GUILD_PERMISSION_MEMBER) & (~GUILD_PERMISSION_ELECTION_CANDIDATE), null);
}
// set new leader
guildSetLeader(guildId, newLeader);
// set new leader's permissions
if (findObjIdTableOffset(memberIds, newLeader) != -1)
{
guildSetMemberPermissionAndAllegiance(guildId, newLeader, (guildGetMemberPermissions(guildId, newLeader) | GUILD_PERMISSIONS_ALL_ADMINISTRATIVE) & (~GUILD_PERMISSION_ELECTION_CANDIDATE), null);
}
obj_id oldLeaderPDA = getGuildRemoteDevice(oldLeader);
obj_id newLeaderPDA = getGuildRemoteDevice(newLeader);
if(isIdValid(oldLeaderPDA) && isIdValid(newLeaderPDA))
{
if(hasObjVar(oldLeaderPDA, GUILD_SCREEN_ID))
{
obj_id guildScreen = getObjIdObjVar(oldLeaderPDA, GUILD_SCREEN_ID);
if(isIdValid(guildScreen))
{
messageTo(guildScreen, "handlerGuildNewLeader", null, 1, true);
if(hasObjVar(newLeaderPDA, GUILD_SCREEN_ID))
removeObjVar(newLeaderPDA, GUILD_SCREEN_ID);
}
}
}
}
}
// ----------------------------------------------------------------------
void disbandForNotEnoughMembers(int guildId)
{
GuildLog(guildId, "disbandForNotEnoughMembers", null, null, "");
mailToGuild(guildId, GUILD_MAIL_DISBAND_SUBJECT, GUILD_MAIL_DISBAND_NOT_ENOUGH_MEMBERS_TEXT);
disbandGuild(guildId);
}
// ----------------------------------------------------------------------
void disband(int guildId, obj_id actor)
{
if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_DISBAND))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
GuildLog(guildId, "disband", actor, null, "");
mailToGuild(guildId, GUILD_MAIL_DISBAND_SUBJECT, GUILD_MAIL_DISBAND_TEXT, getName(actor));
disbandGuild(guildId);
}
}
// ----------------------------------------------------------------------
void sponsor(int guildId, obj_id actor, string who)
{
obj_id target = utils.getNearbyPlayerByName(actor, who);
if(!isIdValid(target))
{
target = getPlayerIdFromFirstName(who);
}
if (isIdValid(target) && isIdValid(actor))
{
if (getGuildId(target) != 0)
{
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_SPONSOR_ALREADY_IN_GUILD);
dict.put("player", who);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
}
else
{
obj_id[] members = guildGetMemberIds(guildId);
if (members.length >= MAX_MEMBERS_PER_GUILD)
{
dictionary dict = new dictionary();
dict.put("stringMessage", SID_GUILD_SPONSOR_FAIL_FULL);
dict.put("player", who);
messageTo(actor, "onGuildSponsorVerifyResponse", dict, 0, false);
}
else
{
GuildLog(guildId, "sponsor", actor, target, "");
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_SPONSOR_SELF);
dict.put("player", who);
dict.put("guildId", guildId);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
dictionary dict2 = new dictionary();
dict2.put("proseSID", SID_GUILD_SPONSOR_TARGET);
dict2.put("player", guildGetMemberName(guildId, actor));
dict2.put("guildId", guildId);
messageTo(target, "onGuildSponsorVerifyResponseProse", dict2, 0, false);
obj_id leader = guildGetLeader(guildId);
if (isIdValid(leader))
mailToGuildMember(guildId, leader, GUILD_MAIL_SPONSOR_SUBJECT, GUILD_MAIL_SPONSOR_TEXT, getName(actor), who);
guildAddSponsorMember(guildId, target);
}
}
}
}
// ----------------------------------------------------------------------
void accept(int guildId, obj_id actor, string who)
{
if(!isIdValid(actor))
return;
if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_ACCEPT))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
obj_id memberId = findMemberIdByName(guildId, who, true, false);
if (isIdValid(memberId))
{
GuildLog(guildId, "accept", actor, memberId, "");
string memberName = guildGetMemberName(guildId, memberId);
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_ACCEPT_SELF);
dict.put("player", who);
dict.put("guildId", guildId);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
dictionary dict2 = new dictionary();
dict2.put("proseSID", SID_GUILD_ACCEPT_TARGET);
string name = guildGetMemberName(guildId, actor);
dict2.put("player", name);
dict2.put("guildId", guildId);
messageTo(memberId, "onGuildSponsorVerifyResponseProse", dict2, 0, false);
// mail guild members prior to accept
mailToGuild(guildId, GUILD_MAIL_ACCEPT_SUBJECT, GUILD_MAIL_ACCEPT_TEXT, getName(actor), memberName);
// accept them (may not be immediate)
guildSetMemberPermissionAndAllegiance(guildId, memberId, GUILD_PERMISSION_MEMBER, guildGetLeader(guildId));
// mail new member
mailToPerson(guildId, memberName, GUILD_MAIL_ACCEPT_TARGET_SUBJECT, GUILD_MAIL_ACCEPT_TARGET_TEXT, getName(actor), guildGetName(guildId));
messageTo(memberId, "onGuildCreateTerminalDataObject", null, 0, false);
}
}
}
// ----------------------------------------------------------------------
void leave(obj_id actor)
{
int guildId = getGuildId(actor);
if (guildId != 0)
{
// We should not let the guild lead leave the group (they need to transfer leadership first)
if (actor == guildGetLeader(guildId))
{
sendSystemMessage(actor, SID_GUILD_LEAVE_FAIL_LEADER_TRIED_TO_LEAVE);
}
else
{
GuildLog(guildId, "leave", actor, null, "");
prose_package pp = new prose_package();
pp.actor.set(guildGetName(guildId));
pp.stringId = SID_GUILD_LEAVE_SELF;
sendSystemMessageProse(getChatName(actor), pp);
mailToGuild(guildId, GUILD_MAIL_LEAVE_SUBJECT, GUILD_MAIL_LEAVE_TEXT, getName(actor));
guildRemoveMember(guildId, actor);
}
}
}
// ----------------------------------------------------------------------
void kick(int guildId, obj_id actor, string who)
{
if (guildId == 0)
return;
obj_id memberId = findMemberIdByName(guildId, who, false, true);
if (isIdValid(memberId))
{
// anyone can kick themselves, if they're limber enough
if (memberId == actor)
leave(actor);
// people with kick permission may kick full members, but not the leader (unless the actor is in god mode)
else if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_KICK) || (!isGod(actor) && memberId == guildGetLeader(guildId)))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
GuildLog(guildId, "kick", actor, memberId, "removing member");
string memberName = guildGetMemberName(guildId, memberId);
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_KICK_SELF);
dict.put("player", memberName);
dict.put("guildId", guildId);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
dictionary dict2 = new dictionary();
dict2.put("proseSID", SID_GUILD_KICK_TARGET);
dict2.put("player", guildGetMemberName(guildId, actor));
dict2.put("guildId", guildId);
messageTo(memberId, "onGuildSponsorVerifyResponseProse", dict2, 0, false);
mailToGuild(guildId, GUILD_MAIL_KICK_SUBJECT, GUILD_MAIL_KICK_TEXT, getName(actor), memberName);
guildRemoveMember(guildId, memberId);
}
}
// people with accept permission may kick sponsored members
else
{
obj_id sponsoredId = findMemberIdByName(guildId, who, true, false);
if (isIdValid(sponsoredId))
{
if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_ACCEPT))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
GuildLog(guildId, "kick", actor, memberId, "removing sponsored");
string memberName = guildGetMemberName(guildId, sponsoredId);
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_DECLINE_SELF);
dict.put("player", memberName);
dict.put("guildId", guildId);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
dictionary dict2 = new dictionary();
dict2.put("proseSID", SID_GUILD_DECLINE_TARGET);
dict2.put("player", guildGetMemberName(guildId, actor));
dict2.put("guildId", guildId);
messageTo(sponsoredId, "onGuildSponsorVerifyResponseProse", dict2, 0, false);
// mail guild
mailToGuild(guildId, GUILD_MAIL_DECLINE_SUBJECT, GUILD_MAIL_DECLINE_TEXT, getName(actor), memberName);
// perform the decline (may not be immediate)
guildRemoveMember(guildId, sponsoredId);
// mail declined member
mailToPerson(guildId, memberName, GUILD_MAIL_DECLINE_TARGET_SUBJECT, GUILD_MAIL_DECLINE_TARGET_TEXT, guildGetMemberName(guildId, actor), guildGetName(guildId));
}
}
}
}
// ----------------------------------------------------------------------
void title(int guildId, obj_id actor, string who, string title)
{
if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_TITLE))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
obj_id memberId = findMemberIdByName(guildId, who, false, true);
if (isIdValid(memberId))
{
if (isNameReserved(title))
sendSystemMessage(actor, SID_GUILD_TITLE_FAIL_NOT_ALLOWED);
else if (title.length() > 25)
sendSystemMessage(actor, SID_GUILD_TITLE_FAIL_BAD_LENGTH);
else
{
GuildLog(guildId, "title", actor, memberId, "setting title to '"+title+"'");
string memberName = guildGetMemberName(guildId, memberId);
dictionary dict = new dictionary();
dict.put("proseSID", SID_GUILD_TITLE_SELF);
dict.put("title", title);
dict.put("player", memberName);
messageTo(actor, "onGuildSponsorVerifyResponseProse", dict, 0, false);
dictionary dict2 = new dictionary();
dict2.put("proseSID", SID_GUILD_TITLE_TARGET);
dict2.put("player", guildGetMemberName(guildId, actor));
dict2.put("title", title);
messageTo(memberId, "onGuildSponsorVerifyResponseProse", dict2, 0, false);
guildSetMemberTitle(guildId, memberId, title);
}
}
}
}
// ----------------------------------------------------------------------
void handleGuildNameChange(int guildId, string newName, string newAbbrev, obj_id changerId)
{
// skip name changes instigated by people who no longer have permission
if (isIdValid(changerId) && !hasGuildPermission(guildId, changerId, GUILD_PERMISSION_NAMECHANGE))
return;
// skip name changes if the name is already taken
if (findGuild(newName) != 0 || findGuild(newAbbrev) != 0)
return;
GuildLog(guildId, "handleGuildNameChange", changerId, null, "name='"+newName+"' abbrev='"+newAbbrev+"'");
guildSetName(guildId, newName);
guildSetAbbrev(guildId, newAbbrev);
string memberName = null;
if (isIdValid(changerId))
memberName = guildGetMemberName(guildId, changerId);
if (memberName != null)
mailToGuild(guildId, GUILD_MAIL_NAMECHANGE_SUBJECT, GUILD_MAIL_NAMECHANGE_TEXT, newName, newAbbrev, memberName);
else
mailToGuild(guildId, GUILD_MAIL_NAMECHANGE_SUBJECT, GUILD_MAIL_NAMECHANGE_TEXT, newName, newAbbrev, "System");
}
// ----------------------------------------------------------------------
void nameChange(int guildId, obj_id actor, string newName, string newAbbrev)
{
if (!hasGuildPermission(guildId, actor, GUILD_PERMISSION_NAMECHANGE))
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
else
{
if (newAbbrev.length() < 1 || newAbbrev.length() > 5)
sendSystemMessage(actor, SID_GUILD_NAMECHANGE_FAIL_ABBREV_BAD_LENGTH);
else if (newName.length() < 1 || newName.length() > 25)
sendSystemMessage(actor, SID_GUILD_NAMECHANGE_FAIL_NAME_BAD_LENGTH);
else if (isNameReserved(newAbbrev))
sendSystemMessage(actor, SID_GUILD_NAMECHANGE_FAIL_ABBREV_NOT_ALLOWED);
else if (isNameReserved(newName))
sendSystemMessage(actor, SID_GUILD_NAMECHANGE_FAIL_NAME_NOT_ALLOWED);
else
{
GuildLog(guildId, "nameChange", actor, null, "queueing change to name='"+newName+"' abbrev='"+newAbbrev+"'");
prose_package pp = new prose_package();
pp.actor.set(newName);
pp.target.set(newAbbrev);
pp.stringId = SID_GUILD_NAMECHANGE_SELF;
sendSystemMessageProse(getChatName(actor), pp);
obj_id masterGuildObj = getMasterGuildObject();
dictionary params = new dictionary();
params.put("guildId", guildId);
params.put("newName", newName);
params.put("newAbbrev", newAbbrev);
if (getGuildId(actor) == guildId)
params.put("changerId", actor);
else
params.put("changerId", obj_id.NULL_ID);
messageTo(masterGuildObj, "initiateGuildNameChange", params, 0, false);
}
}
}
// ----------------------------------------------------------------------
void war(int guildId, obj_id actor, string who)
{
int enemyId = findGuild(who);
if(enemyId == 0)
sendSystemMessage(actor, SID_GUILD_WAR_FAIL_NO_SUCH_GUILD);
else
war(guildId, actor, enemyId);
}
// ----------------------------------------------------------------------
void war(int guildId, obj_id actor, int enemyId)
{
if(enemyId != 0 && enemyId != guildId)
{
if(!hasGuildPermission(guildId, actor, GUILD_PERMISSION_WAR))
{
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
}
else
{
GuildLog(guildId, "war", actor, null, "Declaring war with "+enemyId+"("+guildGetName(enemyId)+")");
guildSetEnemy(guildId, enemyId);
}
}
}
// ----------------------------------------------------------------------
void peace(int guildId, obj_id actor, string who)
{
peace(guildId, actor, findGuild(who));
}
// ----------------------------------------------------------------------
void peace(int guildId, obj_id actor, int enemyId)
{
if(enemyId != 0 && enemyId != guildId)
{
if(!hasGuildPermission(guildId, actor, GUILD_PERMISSION_WAR))
{
sendSystemMessage(actor, SID_GUILD_GENERIC_FAIL_NO_PERMISSION);
}
else
{
GuildLog(guildId, "war", actor, null, "Declaring peace with "+enemyId+"("+guildGetName(enemyId)+")");
guildRemoveEnemy(guildId, enemyId);
}
}
}
void togglePersonalPermission(int guildId, obj_id actor, string who, int permBit)
{
obj_id memberId = findMemberIdByName(guildId, who, false, true);
if((isIdValid(memberId) && memberId == actor && (permBit & GUILD_PERMISSIONS_ALL_PERSONAL) > 0) || isGod(actor) || guildGetLeader(guildId) == actor)
{
GuildLog(guildId, "togglePermission", actor, memberId, "bit "+permBit);
guildSetMemberPermission(guildId, memberId, guildGetMemberPermissions(guildId, memberId) ^ permBit);
}
}
// ----------------------------------------------------------------------
void togglePermission(int guildId, obj_id actor, string who, int permBit)
{
if(guildGetLeader(guildId) == actor || isGod(actor))
{
obj_id memberId = findMemberIdByName(guildId, who, false, true);
if(isIdValid(memberId))
{
GuildLog(guildId, "togglePermission", actor, memberId, "bit "+permBit);
guildSetMemberPermission(guildId, memberId, guildGetMemberPermissions(guildId, memberId) ^ permBit);
}
}
}
// ----------------------------------------------------------------------
void dumpInfo(int guildId, obj_id actor)
{
debugConsoleMsg(actor, "Guild Id: " + guildId);
if(guildId == 0)
return;
debugConsoleMsg(actor, "Guild Name: " + guildGetName(guildId));
debugConsoleMsg(actor, "Guild Abbrev: " + guildGetAbbrev(guildId));
debugConsoleMsg(actor, "Guild Leader: " + guildGetLeader(guildId));
obj_id[] members = guildGetMemberIds(guildId);
int memberCount = 0;
if(members != null)
memberCount = members.length;
debugConsoleMsg(actor, "Guild members (" + memberCount + "):");
for(int i = 0; i < memberCount; ++i)
{
debugConsoleMsg(actor, (i+1) + ")"
+ " id = " + members[i]
+ " name = " + guildGetMemberName(guildId, members[i])
+ " perms = " + guildGetMemberPermissions(guildId, members[i])
+ " title = " + guildGetMemberTitle(guildId, members[i])
+ " allegiance = " + guildGetMemberAllegiance(guildId, members[i]));
}
int[] enemies = guildGetEnemies(guildId);
int enemyCount = 0;
if(enemies != null)
enemyCount = enemies.length;
debugConsoleMsg(actor, "Guild enemies (" + enemyCount + "):");
for(int i = 0; i < enemyCount; ++i)
{
debugConsoleMsg(actor, (i+1) + ") " + enemies[i]);
}
}
// ----------------------------------------------------------------------
obj_id findMemberIdByName(int guildId, string name, boolean fromSponsored, boolean fromMembers)
{
obj_id[] members = getMemberIds(guildId, fromSponsored, fromMembers);
if(members != null && members.length > 0)
{
// get lowercase first name only to compare against
java.util.StringTokenizer st = new java.util.StringTokenizer(name);
string compareName = toLower(st.nextToken());
for(int i = 0; i < members.length; ++i)
{
if(isIdValid(members[i]))
{
// lowercase first name compare only
java.util.StringTokenizer st2 = new java.util.StringTokenizer(guildGetMemberName(guildId, members[i]));
string memberName = toLower(st2.nextToken());
if(compareName == memberName)
return members[i];
}
}
}
return obj_id.NULL_ID;
}
// ----------------------------------------------------------------------
boolean hasSponsoredMembers(int guildId)
{
obj_id[] members = guildGetMemberIds(guildId);
if(members != null)
{
for(int i = 0; i < members.length; ++i)
{
if(!isIdValid(members[i]))
return false;
if (guildGetMemberPermissions(guildId, members[i]) == GUILD_PERMISSIONS_NONE)
return true;
}
}
return false;
}
// ----------------------------------------------------------------------
obj_id[] getMemberIds(int guildId, boolean fromSponsored, boolean fromMembers)
{
if(guildId == 0)
return null;
obj_id[] members = guildGetMemberIds(guildId);
int count = 0;
if(members != null && members.length > 0)
{
if(fromSponsored && fromMembers)
{
count = members.length;
}
else
{
for(int i = 0; i < members.length; ++i)
{
if(!isIdValid(members[i]))
{
LOG("GUILD", "getMemberIds::1::members[" + i + "] was null");
LOG("GUILD", "getMemberIds::1::guildId " + guildId);
//Thread.dumpStack();
continue;
}
if(guildGetMemberPermissions(guildId, members[i]) == GUILD_PERMISSIONS_NONE)
{
if(fromSponsored)
++count;
}
else if(fromMembers)
++count;
}
}
}
obj_id[] ret = new obj_id[count];
int index = 0;
members = guildGetMemberIds(guildId);
if(members != null && members.length > 0)
{
for(int i = 0; i < members.length; ++i)
{
if(!isIdValid(members[i]))
{
LOG("GUILD", "getMemberIds::2::members[" + i + "] was null");
LOG("GUILD", "getMemberIds::2::guildId " + guildId);
//Thread.dumpStack();
continue;
}
if(guildGetMemberPermissions(guildId, members[i]) == GUILD_PERMISSIONS_NONE)
{
if(fromSponsored)
ret[index++] = members[i];
}
else if(fromMembers)
ret[index++] = members[i];
}
}
return ret;
}
// ----------------------------------------------------------------------
string[] getMemberNames(int guildId, boolean fromSponsored, boolean fromMembers)
{
obj_id[] members = getMemberIds(guildId, fromSponsored, fromMembers);
int count = 0;
if(members != null)
count = members.length;
string[] ret = new string[count];
for(int i = 0; i < count; ++i)
{
if(isIdValid(members[i]))
{
string name = guildGetMemberName(guildId, members[i]);
if(name != null && !name.equals(""))
ret[i] = guildGetMemberName(guildId, members[i]);
}
}
if(ret != null && ret.length > 0)
Arrays.sort(ret);
return ret;
}
// ----------------------------------------------------------------------
string[] getMemberNamesAndTitles(int guildId)
{
obj_id[] members = getMemberIds(guildId, false, true);
int count = 0;
if(members != null)
count = members.length;
string[] ret = new string[count];
for(int i = 0; i < count; ++i)
{
string name = guildGetMemberName(guildId, members[i]);
string title = guildGetMemberTitle(guildId, members[i]);
if(title == "")
ret[i] = name;
else
ret[i] = name + " [" + title + "]";
}
Arrays.sort(ret);
return ret;
}
// ----------------------------------------------------------------------
string[] getEnemyNamesAndAbbrevs(int guildId)
{
int[] enemies_A_to_B = guildGetEnemies(guildId);
int[] enemies_B_to_A = getGuildsAtWarWith(guildId);
int count = 0;
if(enemies_A_to_B != null)
count = enemies_A_to_B.length;
if(enemies_B_to_A != null)
for(int i = 0; i < enemies_B_to_A.length; ++i)
if(findIntTableOffset(enemies_A_to_B, enemies_B_to_A[i]) == -1)
++count;
string[] ret = new string[count];
int pos = 0;
if (enemies_A_to_B != null)
{
for (int i = 0; i < enemies_A_to_B.length; ++i)
{
boolean atWarWith = false;
StringBuffer sb = new StringBuffer();
if (findIntTableOffset(enemies_B_to_A, enemies_A_to_B[i]) == -1)
{
sb.append("> ");
atWarWith = false;
}
else
{
sb.append("= ");
atWarWith = true;
}
sb.append(guildGetName(enemies_A_to_B[i]));
sb.append(" <");
sb.append(guildGetAbbrev(enemies_A_to_B[i]));
sb.append(">");
if (atWarWith)
{
// display the number of guild war PvP enabled members of the opposing guild
sb.append(" (");
sb.append(guildGetCountMembersGuildWarPvPEnabled(enemies_A_to_B[i]));
sb.append(")");
// get and display kill count statistics for this particular guild war
int killCountAtoB = guildGetGuildWarKillCount(guildId, enemies_A_to_B[i]);
int killCountAtoBupdateTime = guildGetGuildWarKillCountUpdateTime(guildId, enemies_A_to_B[i]);
int killCountBtoA = guildGetGuildWarKillCount(enemies_A_to_B[i], guildId);
int killCountBtoAupdateTime = guildGetGuildWarKillCountUpdateTime(enemies_A_to_B[i], guildId);
sb.append(" (");
sb.append(killCountAtoB);
sb.append(" kills vs ");
sb.append(killCountBtoA);
sb.append(" kills");
if ((killCountAtoBupdateTime > 0) || (killCountBtoAupdateTime > 0))
{
sb.append(" - last updated ");
sb.append(getCalendarTimeStringLocal(Math.max(killCountAtoBupdateTime, killCountBtoAupdateTime)));
}
sb.append(")");
}
ret[pos] = sb.toString();
++pos;
}
}
if (enemies_B_to_A != null)
{
for (int i = 0; i < enemies_B_to_A.length; ++i)
{
if (findIntTableOffset(enemies_A_to_B, enemies_B_to_A[i]) == -1)
{
StringBuffer sb = new StringBuffer();
sb.append("< ");
sb.append(guildGetName(enemies_B_to_A[i]));
sb.append(" <");
sb.append(guildGetAbbrev(enemies_B_to_A[i]));
sb.append(">");
// display the number of guild war PvP enabled members of the opposing guild
sb.append(" (");
sb.append(guildGetCountMembersGuildWarPvPEnabled(enemies_B_to_A[i]));
sb.append(")");
ret[pos] = sb.toString();
++pos;
}
}
}
//Arrays.sort(ret);
return ret;
}
// ----------------------------------------------------------------------
int[] getEnemyIds(int guildId)
{
int[] enemies_A_to_B = guildGetEnemies(guildId);
int[] enemies_B_to_A = getGuildsAtWarWith(guildId);
int count = 0;
if(enemies_A_to_B != null)
count = enemies_A_to_B.length;
if(enemies_B_to_A != null)
for(int i = 0; i < enemies_B_to_A.length; ++i)
if(findIntTableOffset(enemies_A_to_B, enemies_B_to_A[i]) == -1)
++count;
int[] ret = new int[count];
int pos = 0;
if(enemies_A_to_B != null)
for(int i = 0; i < enemies_A_to_B.length; ++i)
ret[pos++] = enemies_A_to_B[i];
if(enemies_B_to_A != null)
for(int i = 0; i < enemies_B_to_A.length; ++i)
if(findIntTableOffset(enemies_A_to_B, enemies_B_to_A[i]) == -1)
ret[pos++] = enemies_B_to_A[i];
return ret;
}
// ----------------------------------------------------------------------
void mailToGuild(int guildId, string subject, string_id textId, string substitute1, string substitute2, string substitute3)
{
obj_id[] members = getMemberIds(guildId, false, true);
if(members != null)
for(int i = 0; i < members.length; ++i)
mailToGuildMember(guildId, members[i], subject, textId, substitute1, substitute2, substitute3);
}
void mailToGuild(int guildId, string subject, string_id textId, string substitute1, string substitute2)
{
mailToGuild(guildId, subject, textId, substitute1, substitute2, "");
}
void mailToGuild(int guildId, string subject, string_id textId, string substitute1)
{
mailToGuild(guildId, subject, textId, substitute1, "", "");
}
void mailToGuild(int guildId, string subject, string_id textId)
{
mailToGuild(guildId, subject, textId, "", "", "");
}
// ----------------------------------------------------------------------
void mailToPerson(int guildId, string toName, string subject, string_id textId, string substitute1, string substitute2, string substitute3)
{
prose_package pp = new prose_package();
pp.stringId = textId;
pp.actor.set(substitute1);
pp.target.set(substitute2);
pp.other.set(substitute3);
chatSendPersistentMessage(
guildGetName(guildId),
toName,
subject,
null,
chatMakePersistentMessageOutOfBandBody(null, pp));
}
void mailToPerson(int guildId, string toName, string subject, string_id textId, string substitute1, string substitute2)
{
mailToPerson(guildId, toName, subject, textId, substitute1, substitute2, "");
}
void mailToPerson(int guildId, string toName, string subject, string_id textId, string substitute1)
{
mailToPerson(guildId, toName, subject, textId, substitute1, "", "");
}
void mailToPerson(int guildId, string toName, string subject, string_id textId)
{
mailToPerson(guildId, toName, subject, textId, "", "", "");
}
// ----------------------------------------------------------------------
void mailToGuildMember(int guildId, obj_id memberId, string subject, string_id textId, string substitute1, string substitute2, string substitute3)
{
mailToPerson(guildId, guildGetMemberName(guildId, memberId), subject, textId, substitute1, substitute2, substitute3);
}
void mailToGuildMember(int guildId, obj_id memberId, string subject, string_id textId, string substitute1, string substitute2)
{
mailToGuildMember(guildId, memberId, subject, textId, substitute1, substitute2, "");
}
void mailToGuildMember(int guildId, obj_id memberId, string subject, string_id textId, string substitute1)
{
mailToGuildMember(guildId, memberId, subject, textId, substitute1, "", "");
}
void mailToGuildMember(int guildId, obj_id memberId, string subject, string_id textId)
{
mailToGuildMember(guildId, memberId, subject, textId, "", "", "");
}
// ----------------------------------------------------------------------
int findIntTableOffset(int[] from, int find)
{
if(from != null)
for(int i = 0; i < from.length; ++i)
if(from[i] == find)
return i;
return -1;
}
// ----------------------------------------------------------------------
int findObjIdTableOffset(obj_id[] from, obj_id find)
{
if(from != null)
for(int i = 0; i < from.length; ++i)
if(from[i] == find)
return i;
return -1;
}
// ======================================================================
// ----------------------------------------------------------------------
void selectPermissions(obj_id self, obj_id player, string name, int guildId)
{
obj_id memberId = findMemberIdByName(guildId, name, true, true);
dictionary params = new dictionary();
params.put("player", player);
params.put("name", name);
params.put("terminalId", self);
params.put("guildId", guildId);
messageTo(self, "selectPermissionsMessage", params, 1, false);
}
void selectRank(obj_id self, obj_id player, string name, int guildId)
{
string[] allRanks = guildGetAllRanks();
if(allRanks == null || allRanks.length < 1)
{
return;
}
string[] rankDisplay = new string[allRanks.length];
obj_id memberId = guild.findMemberIdByName(guildId, name, false, true);
if(!isIdValid(memberId))
{
return;
}
for(int i = 0, j = allRanks.length; i < j; i++)
{
if(guildHasMemberRank(guildId, memberId, allRanks[i]))
{
rankDisplay[i] = "+ " + localize(new string_id("guild_rank_title", allRanks[i]));
}
else
{
rankDisplay[i] = "- " + localize(new string_id("guild_rank_title", allRanks[i]));
}
}
utils.setScriptVar(self, "guild.allRanks", allRanks);
dictionary params = new dictionary();
params.put("player", player);
params.put("guildMemberName", name);
params.put("guildId", guildId);
params.put("rankDisplay", rankDisplay);
messageTo(self, "selectRankMessage", params, 1, false);
}
// ----------------------------------------------------------------------
void showGuildMembers(obj_id terminal, obj_id player, int firstMember, int permission, string title, string name)
{
if(guild.hasWindowPid(player))
{
int pid = guild.getWindowPid(player);
forceCloseSUIPage(pid);
guild.removeWindowPid(player);
}
int guildId = getGuildId(player);
if(guildId <= 0)
{
return;
}
obj_id[] memberIds = getMemberIds(guildId, false, true);
if(memberIds == null || memberIds.length < 1)
{
return;
}
obj_id leader = guildGetLeader(guildId);
utils.setScriptVar(player, "guild.memberIds", memberIds);
string[][] memberData = new string[memberIds.length][6];
string rank = "";
int exclusionCount = 0;
int inclusionCount = 0;
for(int i = 0, j = memberIds.length; i < j; i++)
{
if(!isIdValid(memberIds[i]))
{
memberData[i][0] = "Unknown Player";
continue;
}
if(isIdValid(leader) && memberIds[i] == leader)
{
memberData[i][0] = "\\#00FF00" + guildGetMemberName(guildId, memberIds[i]) + "\\#DFDFDF";
}
else
{
memberData[i][0] = guildGetMemberName(guildId, memberIds[i]);
}
int level = guildGetMemberLevel(guildId, memberIds[i]);
if(level <= 0)
{
memberData[i][1] = "";
}
else
{
memberData[i][1] = "" + level;
}
string profession = guildGetMemberProfession(guildId, memberIds[i]);
if(profession != null && profession.length() > 0)
{
memberData[i][2] = "@ui_roadmap:" + profession;
}
else
{
memberData[i][2] = "Unavailable";
}
memberData[i][3] = guildGetMemberTitle(guildId, memberIds[i]);
string [] ranks = guildGetMemberRank(guildId, memberIds[i]);
rank = "";
if(ranks == null || ranks.length < 1)
{
rank = "None";
}
else
{
for(int k = 0, l = ranks.length; k < l; k++)
{
string rankText = new string(ranks[k]);
string_id id = new string_id("guild_rank_title", rankText);
string finalText = localize(id);
rank += finalText;
if(k + 1 < l)
{
rank += ", ";
}
}
}
memberData[i][4] = rank;
// Online/Offline status
if(!isPlayer(memberIds[i]))
{
memberData[i][5] = "Deleted";
}
else if(!isPlayerConnected(memberIds[i]))
{
int lastLoginTime = getPlayerLastLoginTime(memberIds[i]);
if(lastLoginTime > 0)
{
int timeDifference = getCalendarTime() - lastLoginTime;
if(timeDifference > 0)
{
memberData[i][5] = "Offline " + utils.padTimeDHMS(timeDifference);
}
else
{
memberData[i][5] = "Offline ????d:??h:??m:??s";
}
}
else
{
memberData[i][5] = "Unknown";
}
}
else
{
string locText = "Unknown";
dictionary playerLoc = getConnectedPlayerLocation(memberIds[i]);
string planet = playerLoc.getString("planet");
if(planet != null && planet.length() > 0)
{
locText = localize(new string_id("planet_n", planet));
}
string region = playerLoc.getString("region");
if(region != null && region.length() > 0)
{
locText += ":" + localize(new string_id(region.substring(1, region.indexOf(":")), region.substring(region.indexOf(":") + 1, region.length())));
}
string city = playerLoc.getString("playerCity");
if(city != null && city.length() > 0)
{
locText += ", " + city;
}
memberData[i][5] = "Online " + locText;
}
}
string [] table_titles = { "@guild:table_title_name", "@guild:table_title_level", "@guild:table_title_profession",
"@guild:table_title_title", "@guild:table_title_rank", "@guild:table_title_status" };
string [] table_types = { "text", "integer", "text", "text", "text", "text" };
string guildName = guildGetName(guildId);
string guildAbbreviation = guildGetAbbrev(guildId);
string guildTitle = "Guild Roster";
if(guildName != null && guildName.length() > 0 && guildAbbreviation != null && guildAbbreviation.length() > 0)
{
string memberCount = "";
if(memberData.length > 1)
{
memberCount = " - " + memberData.length + " members";
}
guildTitle = guildName + " [" + guildAbbreviation + "] Roster" + memberCount;
}
string guildInfoStr = "Guild Leader: " + guildGetMemberName(guildId, leader) + "\n" + "Members: " + memberIds.length;
int pid = sui.tableRowMajor(player, player, sui.OK_CANCEL, guildTitle, "onGuildMembersResponse", guildInfoStr, table_titles, table_types, memberData, true);
setWindowPid(player, pid);
}
void setWindowPid(obj_id player, int pid)
{
if (pid > -1) utils.setScriptVar(player, "guild.pid", pid);
}
int getWindowPid(obj_id player)
{
return utils.getIntScriptVar(player, "guild.pid");
}
boolean hasWindowPid(obj_id player)
{
return utils.hasScriptVar(player, "guild.pid");
}
void removeWindowPid(obj_id player)
{
utils.removeScriptVar(player, "guild.pid");
}
obj_id getGuildRemoteDevice(obj_id player)
{
if(utils.playerHasItemByTemplateInDataPad(player, STR_GUILD_REMOTE_DEVICE))
{
obj_id remote = utils.getItemPlayerHasByTemplateInDatapad(player, STR_GUILD_REMOTE_DEVICE);
return remote;
}
return null;
}
// ----------------------------------------------------------------------
string[] getAvailableMemberOptions(obj_id self, obj_id player)
{
int guildId = getGuildId(player);
obj_id guildMaster = guildGetLeader(guildId);
int count = 0;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_TITLE))
++count;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_KICK))
++count;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_RANK) || player == guildMaster || isGod(player))
++count;
if(player == guildMaster || isGod(player))
++count;
string[] ret = new string[count];
count = 0;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_TITLE))
ret[count++] = STR_GUILD_TITLE;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_KICK))
ret[count++] = STR_GUILD_KICK;
if(hasGuildPermission(guildId, player, GUILD_PERMISSION_RANK) || player == guildMaster || isGod(player))
ret[count++] = STR_GUILD_RANK;
if(player == guildMaster || isGod(player))
ret[count++] = STR_GUILD_PERMISSIONS;
return ret;
}
void toggleWarExclusion(obj_id player, int guildId, string name)
{
if(!isIdValid(player) || !exists(player) || guildId <= 0 || name == null || name.length() < 1)
{
return;
}
obj_id target = guild.findMemberIdByName(guildId, name, false, true);
if(!isIdValid(target))
{
return;
}
GuildLog(guildId, "togglePermission", player, target, "bit " + GUILD_PERMISSION_WAR_EXCLUSION);
guildSetMemberPermission(guildId, target, guildGetMemberPermissions(guildId, target) ^ GUILD_PERMISSION_WAR_EXCLUSION);
prose_package pp = new prose_package();
pp.target.set(name);
pp.stringId = SID_GUILD_WAR_EXCLUSION_TOGGLED;
sendSystemMessageProse(player, pp);
}
void toggleWarInclusion(obj_id player, int guildId, string name)
{
if(!isIdValid(player) || !exists(player) || guildId <= 0 || name == null || name.length() < 1)
{
return;
}
obj_id target = guild.findMemberIdByName(guildId, name, false, true);
if(!isIdValid(target))
{
return;
}
GuildLog(guildId, "togglePermission", player, target, "bit " + GUILD_PERMISSION_WAR_INCLUSION);
guildSetMemberPermission(guildId, target, guildGetMemberPermissions(guildId, target) ^ GUILD_PERMISSION_WAR_INCLUSION);
prose_package pp = new prose_package();
pp.target.set(name);
pp.stringId = SID_GUILD_WAR_INCLUSION_TOGGLED;
sendSystemMessageProse(player, pp);
}
// ----------------------------------------------------------------------
void chooseTitle(obj_id self, obj_id player, string name)
{
setMenuContextString(self, player, "guildTitlePlayerName", name);
int pid = sui.inputbox(
self,
player,
buildFakeLocalizedProse(STR_GUILD_TITLE_PROMPT, name, ""),
sui.OK_CANCEL,
STR_GUILD_TITLE_TITLE,
sui.INPUT_NORMAL,
null,
"onGuildTitleResponse");
setWindowPid(player, pid);
}
// ----------------------------------------------------------------------
void setMenuContextString(obj_id self, obj_id player, string varName, string value)
{
deltadictionary dd = self.getScriptVars();
dd.put("guildMenu." + player + "." + varName, value);
}
// ----------------------------------------------------------------------
void confirmKick(obj_id self, obj_id player, string name)
{
//setMenuContextString(self, player, "guildKickName", name);
utils.setScriptVar(self, "guildKickName", name);
int pid = sui.msgbox(
self,
player,
guild.buildFakeLocalizedProse(STR_GUILD_KICK_PROMPT, name, ""),
sui.YES_NO,
STR_GUILD_KICK_TITLE,
sui.MSG_NORMAL,
"onGuildKickResponse");
setWindowPid(player, pid);
}
// ---------------------------------------------------------------------
void setMenuContextIntArray(obj_id self, obj_id player, string varName, int[] value)
{
deltadictionary dd = self.getScriptVars();
dd.put("guildMenu." + player + "." + varName, value);
}
// ----------------------------------------------------------------------
string getMenuContextString(obj_id self, obj_id player, string varName)
{
deltadictionary dd = self.getScriptVars();
return dd.getString("guildMenu." + player + "." + varName);
}
// ----------------------------------------------------------------------
void removeMenuContextVar(obj_id self, obj_id player, string varName)
{
deltadictionary dd = self.getScriptVars();
dd.remove("guildMenu." + player + "." + varName);
}
// ----------------------------------------------------------------------
void showPermissionList(obj_id player, int guildId)
{
if(!isIdValid(player))
return;
if(guildId == 0)
return;
utils.setScriptVar(player, "guildShow.guildId", guildId);
int pid = sui.listbox(player, player, STR_GUILD_MEMBERS_PROMPT, sui.OK_CANCEL_REFRESH, STR_GUILD_MEMBERS_TITLE, PERMISSION_LIST, "onGuildMembersPermissionsResponse", false, true);
sui.listboxUseOtherButton(pid, STR_SUI_BACK_BUTTON);
sui.showSUIPage(pid);
setWindowPid(player, pid);
}
void showTitleList(obj_id player, int guildId)
{
if(!isIdValid(player))
return;
if(guildId == 0)
return;
string[] finalList = getGuildTitles(guildId);
if(finalList != null && finalList.length > 0)
{
utils.setScriptVar(player, "guildShow.guildId", guildId);
int pid = sui.listbox(player, player, STR_GUILD_MEMBERS_PROMPT, sui.OK_CANCEL_REFRESH, STR_GUILD_MEMBERS_TITLE, finalList, "onGuildMembersTitlesResponse", false, true);
sui.listboxUseOtherButton(pid, STR_SUI_BACK_BUTTON);
sui.showSUIPage(pid);
setWindowPid(player, pid);
}
else
{
if(hasWindowPid(player))
{
sendSystemMessage(player, SID_NO_TITLES_IN_GUILD);
removeWindowPid(player);
}
}
}
string[] getGuildTitles(int guildId)
{
if(guildId == 0)
return null;
obj_id[] members = getMemberIds(guildId, false, true);
int count = 0;
if (members != null)
count = members.length;
resizeable string[] titleList = new string[0];
for (int i = 0; i < count; ++i)
{
string title = guildGetMemberTitle(guildId, members[i]);
if (!title.equals(""))
{
boolean alreadyHave = false;
for(int j = 0; j < titleList.length; ++j)
{
if(title.equals(titleList[j]))
{
alreadyHave= true;
break;
}
}
if(!alreadyHave)
titleList.add(title);
}
}
string[] finalList = new string[titleList.size()];
titleList.toArray(finalList);
Arrays.sort(finalList);
return finalList;
}
boolean memberHasTitle(int guildId, obj_id memberId, string title)
{
string memberTitle = guildGetMemberTitle(guildId, memberId);
return toLower(memberTitle).equals(toLower(title));
}
string[] getMemberNamesByPermission(int guildId, int permission)
{
string[] rawNamesAndTitles = getMemberNamesAndTitles(guildId);
string[] rawMemberNames = getMemberNames(guildId, true, true);
resizeable string[] filteredNamesAndTitles = new string[0];
for(int i = 0; i < rawNamesAndTitles.length; ++i)
{
obj_id memberId = findMemberIdByName(guildId, rawMemberNames[i], true, true);
if(hasGuildPermission(guildId, memberId, permission))
{
filteredNamesAndTitles = utils.addElement(filteredNamesAndTitles, rawNamesAndTitles[i]);
}
}
string[] finalList = new string[filteredNamesAndTitles.size()];
filteredNamesAndTitles.toArray(finalList);
Arrays.sort(finalList);
return finalList;
}
string[] getMemberNamesByTitle(int guildId, string title)
{
obj_id[] members = getMemberIds(guildId, false, true);
resizeable string[] filteredNamesAndTitles = new string[0];
for(int i = 0; i < members.length; ++i)
{
if(memberHasTitle(guildId, members[i], title))
{
filteredNamesAndTitles = utils.addElement(filteredNamesAndTitles, guildGetMemberName(guildId, members[i]));
}
}
string[] finalList = new string[filteredNamesAndTitles.size()];
filteredNamesAndTitles.toArray(finalList);
Arrays.sort(finalList);
return finalList;
}
string[] getMemberNamesByName(int guildId, string name)
{
string[] memberNames = getMemberNames(guildId, false, true);
resizeable string[] filteredNamesAndTitles = new string[0];
for(int i = 0; i < memberNames.length; ++i)
{
if(toLower(memberNames[i]).indexOf(toLower(name)) > -1)
{
filteredNamesAndTitles = utils.addElement(filteredNamesAndTitles, memberNames[i]);
}
}
string[] finalList = new string[filteredNamesAndTitles.size()];
filteredNamesAndTitles.toArray(finalList);
Arrays.sort(finalList);
return finalList;
}
// ----------------------------------------------------------------------
void showGuildInfo(obj_id player)
{
// TODO - need to localize this when there is sui support for doing so
const int guildId = getGuildId(player);
const obj_id[] memberIds = guild.getMemberIds(guildId, false, true);
string guildInfoStr = "Guild Name: " + guildGetName(guildId);
const int factionId = guildGetCurrentFaction(guildId);
if (##"imperial" == factionId)
guildInfoStr += " (Imperial aligned)";
else if (##"rebel" == factionId)
guildInfoStr += " (Rebel aligned)";
guildInfoStr += "\n";
guildInfoStr += ("Guild Abbreviation: " + guildGetAbbrev(guildId) + "\n");
guildInfoStr += ("Guild Leader: " + guildGetMemberName(guildId, guildGetLeader(guildId)) + "\n");
const String gcwDefenderRegion = guildGetCurrentGcwDefenderRegion(guildId);
if ((gcwDefenderRegion != null) && (gcwDefenderRegion.length() > 0))
{
guildInfoStr += ("GCW Region Defender: " + localize(new string_id("gcw_regions", gcwDefenderRegion)));
const int timeJoinedGcwDefenderRegion = guildGetTimeJoinedCurrentGcwDefenderRegion(guildId);
if (timeJoinedGcwDefenderRegion > 0)
{
guildInfoStr += (" (started defending on " + getCalendarTimeStringLocal(timeJoinedGcwDefenderRegion) + ")\n");
const int gcwDaysRequiredForGcwRegionDefenderBonus = utils.stringToInt(getConfigSetting("GameServer", "gcwDaysRequiredForGcwRegionDefenderBonus"));
const int age = getCalendarTime() - timeJoinedGcwDefenderRegion;
if (age > (gcwDaysRequiredForGcwRegionDefenderBonus * 86400))
{
if (##"imperial" == factionId)
guildInfoStr += ("GCW Region Defender Bonus: " + getGcwDefenderRegionImperialBonus(gcwDefenderRegion) + "%\n");
else if (##"rebel" == factionId)
guildInfoStr += ("GCW Region Defender Bonus: " + getGcwDefenderRegionRebelBonus(gcwDefenderRegion) + "%\n");
else
guildInfoStr += "GCW Region Defender Bonus: (None - cannot determine factional alignment)\n";
}
else
{
guildInfoStr += ("GCW Region Defender Bonus: (None - hasn't defended for " + gcwDaysRequiredForGcwRegionDefenderBonus + " days)\n");
}
}
else
{
guildInfoStr += "\n";
guildInfoStr += "GCW Region Defender Bonus: (None - cannot determine time started defending)\n";
}
}
else
{
guildInfoStr += "GCW Region Defender: (None)\n";
guildInfoStr += "GCW Region Defender Bonus: (None)\n";
}
guildInfoStr += ("Members: " + memberIds.length);
sui.msgbox(
player,
player,
guildInfoStr,
sui.OK_ONLY,
STR_GUILD_INFO_TITLE,
sui.MSG_NORMAL,
"onGuildInfoResponse");
}
// ----------------------------------------------------------------------
void showGuildEnemies(obj_id player)
{
dictionary params = new dictionary();
params.put("player", player);
messageTo(player, "showGuildEnemiesMessage", params, 2, false);
}
// ----------------------------------------------------------------------
int[] getMenuContextIntArray(obj_id self, obj_id player, string varName)
{
deltadictionary dd = self.getScriptVars();
return dd.getIntArray("guildMenu." + player + "." + varName);
}
// ----------------------------------------------------------------------
void showGuildSponsored(obj_id player)
{
dictionary params = new dictionary();
params.put("player", player);
messageTo(player, "showGuildSponsoredMessage", params, 3, false);
}
boolean loadCartridge(obj_id player, obj_id cartridge)
{
if(!isIdValid(player) || !isIdValid(cartridge))
return false;
obj_id remoteDevice = getGuildRemoteDevice(player);
if(!isIdValid(remoteDevice))
return false;
if(hasObjVar(remoteDevice, GUILD_SCREEN_ID))
{
obj_id guildScreen = getObjIdObjVar(remoteDevice, GUILD_SCREEN_ID);
if(isIdValid(guildScreen))
{
string cartridgeTemplate = getStringObjVar(cartridge, GUILD_SCREEN_TYPE);
if(cartridgeTemplate != null && !cartridgeTemplate.equals(""))
{
setObjVar(remoteDevice, GUILD_SCREEN_TYPE, cartridgeTemplate);
messageTo(guildScreen, "handlerGuildNewLeader", null, 1, true);
if(hasObjVar(remoteDevice, GUILD_SCREEN_ID))
removeObjVar(remoteDevice, GUILD_SCREEN_ID);
return true;
}
}
}
else
{
string cartridgeTemplate = getStringObjVar(cartridge, GUILD_SCREEN_TYPE);
if(cartridgeTemplate != null && !cartridgeTemplate.equals(""))
{
setObjVar(remoteDevice, GUILD_SCREEN_TYPE, cartridgeTemplate);
return true;
}
}
return false;
}
int getVotingTime(int guildId)
{
return guildGetElectionNextEndTime(guildId);
}
int getGracePeriodTime(int guildId)
{
return guildGetElectionPreviousEndTime(guildId);
}
boolean isVotingEnabled(int guildId)
{
if(getCalendarTime() < getVotingTime(guildId) && getVotingTime(guildId) > getGracePeriodTime(guildId))
return true;
return false;
}
boolean isVotingGracePeriod(int guildId)
{
if(getCalendarTime() < getGracePeriodTime(guildId) && getVotingTime(guildId) < getGracePeriodTime(guildId))
return true;
return false;
}
boolean hasElectionEnded(obj_id player)
{
if(!isIdValid(player))
{
return false;
}
int guildId = getGuildId(player);
if(guildId <= 0)
{
return false;
}
int votingTime = getVotingTime(guildId);
int gracePeriodTime = getGracePeriodTime(guildId);
// Voting is over because the current time is greater than the voting time.
if(gracePeriodTime == 0 && votingTime > 0 && votingTime < getCalendarTime())
{
return true;
}
return false;
}
obj_id [] getCandidates(int guildId)
{
if(guildId <= 0)
{
return null;
}
obj_id [] memberIds = getMemberIds(guildId, false, true);
if(memberIds == null || memberIds.length < 1)
{
return null;
}
resizeable obj_id [] candidates = new obj_id[0];
for(int i = 0, j = memberIds.length; i < j; i++)
{
if(isCandidate(guildId, memberIds[i]))
{
utils.addElement(candidates, memberIds[i]);
}
}
return candidates;
}
string [] getGuildMemberNamesByArray(int guildId, obj_id [] memberIds)
{
if(guildId <= 0 || memberIds == null || memberIds.length < 1)
{
return null;
}
string [] names = new string[memberIds.length];
for(int i = 0, j = memberIds.length; i < j; i++)
{
names[i] = guildGetMemberName(guildId, memberIds[i]);
}
return names;
}
boolean isCandidate(int guildId, obj_id memberId)
{
if(guildId <= 0 || !isIdValid(memberId))
{
return false;
}
return hasGuildPermission(guildId, memberId, GUILD_PERMISSION_ELECTION_CANDIDATE);
}
void makeCandidate(int guildId, obj_id memberId)
{
if(guildId <= 0 || !isIdValid(memberId))
{
return;
}
//obj_id self = getTopMostContainer(getSelf());
//debugSpeakMsg(self, "makeCandidate guildId: " + guildId + " memberId: " + memberId + " perm: " + guildGetMemberPermissions(guildId, memberId) + " can: " + (guildGetMemberPermissions(guildId, memberId) & GUILD_PERMISSION_ELECTION_CANDIDATE));
guildSetMemberPermissionAndAllegiance(guildId, memberId, guildGetMemberPermissions(guildId, memberId) | GUILD_PERMISSION_ELECTION_CANDIDATE, memberId);
}
void removeCandidate(int guildId, obj_id memberId)
{
if(guildId <= 0 || !isIdValid(memberId))
{
return;
}
//obj_id self = getTopMostContainer(getSelf());
//debugSpeakMsg(self, "removeCandidate guildId: " + guildId + " memberId: " + memberId + " perm: " + guildGetMemberPermissions(guildId, memberId) + " can: " + (guildGetMemberPermissions(guildId, memberId) | GUILD_PERMISSION_ELECTION_CANDIDATE));
guildSetMemberPermissionAndAllegiance(guildId, memberId, guildGetMemberPermissions(guildId, memberId) & (~GUILD_PERMISSION_ELECTION_CANDIDATE), null);
}
// This function resets candidates except those that are excluded.
void resetCandidates(int guildId, obj_id [] excluded)
{
if(guildId <= 0)
{
return;
}
obj_id [] memberIds = getMemberIds(guildId, false, true);
if(memberIds == null || memberIds.length < 1)
{
return;
}
obj_id [] candidates = getCandidates(guildId);
int l = 0;
if(candidates != null)
{
l = candidates.length;
}
for(int i = 0, j = memberIds.length; i < j; i++)
{
obj_id votedFor = guildGetMemberAllegiance(guildId, memberIds[i]);
if(isIdValid(votedFor))
{
if(!isIdValid(memberIds[i]))
{
continue;
}
if(excluded != null && excluded.length > 0 && utils.isObjIdInArray(excluded, memberIds[i]))
{
continue;
}
if(candidates == null || candidates.length < 1)
{
guildSetMemberAllegiance(guildId, memberIds[i], null);
}
else
{
boolean candidateFound = false;
for(int k = 0; k < l; k++)
{
if(memberIds[i] == candidates[k])
{
candidateFound = true;
removeCandidate(guildId, memberIds[i]);
}
}
if(!candidateFound)
{
guildSetMemberAllegiance(guildId, memberIds[i], null);
}
}
}
}
}
obj_id getGuildMemberVote(int guildId, obj_id memberId)
{
if(guildId <= 0 || !isIdValid(memberId))
{
return null;
}
obj_id votedForWho = guildGetMemberAllegiance(guildId, memberId);
// Check to see if the person voted for is a candidate
if(isCandidate(guildId, votedForWho))
{
return votedForWho;
}
return null;
}
obj_id [] getGuildMemberVotes(int guildId)
{
if(guildId <= 0)
{
return null;
}
obj_id [] memberIds = getMemberIds(guildId, false, true);
if(memberIds == null || memberIds.length < 1)
{
return null;
}
obj_id [] memberVotedFor = new obj_id[memberIds.length];
for(int i = 0, j = memberIds.length; i < j; i++)
{
memberVotedFor[i] = getGuildMemberVote(guildId, memberIds[i]);
}
return memberVotedFor;
}
int [] getTalliedVotes(int guildId, obj_id [] candidates)
{
if(guildId <= 0)
{
return null;
}
if(candidates == null || candidates.length < 1)
{
return null;
}
obj_id [] voteList = getGuildMemberVotes(guildId);
if(voteList == null || voteList.length < 1)
{
return null;
}
int [] voteTotals = new int[candidates.length];
obj_id self = getTopMostContainer(getSelf());
for(int i = 0, j = candidates.length; i < j; i++)
{
for(int k = 0, l = voteList.length; k < l; k++)
{
if(candidates[i] == voteList[k])
{
voteTotals[i]++;
}
}
}
return voteTotals;
}
// ----------------------------------------------------------------------
void allegiance(obj_id actor, string who)
{
int guildId = getGuildId(actor);
if(!isIdValid(actor))
{
return;
}
if(guildId != 0)
{
obj_id allegianceId = findMemberIdByName(guildId, who, false, true);
if(isIdValid(allegianceId))
{
GuildLog(guildId, "allegiance", actor, allegianceId, "");
prose_package pp = new prose_package();
pp.actor.set(guildGetMemberName(guildId, allegianceId));
pp.target.set(guildGetName(guildId));
pp.stringId = SID_GUILD_ALLEGIANCE_SELF;
sendSystemMessageProse(actor, pp);
guildSetMemberAllegiance(guildId, actor, allegianceId);
}
else
{
sendSystemMessage(actor, SID_GUILD_ALLEGIANCE_UNCHANGED_SELF);
}
}
}
void stopElection(obj_id player)
{
if(!isIdValid(player))
{
return;
}
int guildId = getGuildId(player);
if(guildId == 0)
{
return;
}
guildSetElectionEndTime(guildId, getCalendarTime() + 1209600, 0);
obj_id newLeader = determineLeaderByAllegiance(guildId);
obj_id oldLeader = guildGetLeader(guildId);
string_id leaderChanged = SID_COMPLETED_ELECTIONS_EMAIL_BODY_LEADER_SAME;
if(isIdValid(newLeader) && newLeader != oldLeader)
{
guild.changeLeader(guildId, newLeader);
leaderChanged = SID_COMPLETED_ELECTIONS_EMAIL_BODY_LEADER_CHANGED;
}
// public_election_subject
obj_id[] members = guild.getMemberIds(guildId, false, true);
// Mail folks that the election is over and the outcome.
for(int i = 0; i < members.length; i++)
{
if(!isIdValid(members[i]))
{
continue;
}
string cname = guildGetMemberName(guildId, members[i]);
prose_package bodypp = prose.getPackage(leaderChanged, cname);
utils.sendMail(new string_id ("guild", "open_elections_email_subject"), bodypp, cname, "Guild Management");
}
obj_id [] exluded = { oldLeader, newLeader };
// We must reset candidates, but we cannot set data on the old leader and new leader at this point, so we exclude them.
resetCandidates(guildId, exluded);
}
// ----------------------------------------------------------------------
obj_id determineLeaderByAllegiance(int guildId)
{
// Leader is determined by a simple vote of allegiances.
// If there is a tie with the old leader, the old leader wins.
// Ties not involving the old leader are just based on order they appear.
// As long as there is someone in the guild, a leader will be determined.
if(guildId == 0)
{
return null;
}
obj_id [] candidates = getCandidates(guildId);
if(candidates == null || candidates.length < 1)
{
return null;
}
int [] talliedVotes = getTalliedVotes(guildId, candidates);
if(talliedVotes == null || talliedVotes.length != candidates.length)
{
return null;
}
obj_id guildMaster = guildGetLeader(guildId);
int guildMasterVotes = 0;
obj_id newLeader = null;
int leaderVotes = 0;
for(int i = 0, j = candidates.length; i < j; i++)
{
// Find the guild master's information
if(guildMaster == candidates[i])
{
guildMasterVotes = talliedVotes[i];
}
if(leaderVotes < talliedVotes[i])
{
newLeader = candidates[i];
leaderVotes = talliedVotes[i];
}
}
// Ties go to the guild master.
if(guildMasterVotes == leaderVotes)
{
newLeader = null;
}
return newLeader;
}
void showStandings(obj_id self, obj_id player)
{
if(!isIdValid(player) || !exists(player))
{
return;
}
if(guild.hasWindowPid(player))
{
int pid = guild.getWindowPid(player);
forceCloseSUIPage(pid);
guild.removeWindowPid(player);
}
int guildId = getGuildId(player);
if(guildId == 0)
{
return;
}
obj_id leader = guildGetLeader(guildId);
obj_id[] members = getMemberIds(guildId, false, true);
string name = guildGetMemberName(guildId, player);
if(!isIdValid(leader) || members == null)
{
return;
}
// Grab the current candidate list.
obj_id[] candidates = getCandidates(guildId);
if(candidates == null)
{
sendSystemMessage(player, SID_NO_CANDIDATES);
return;
}
int[] vote_counts = getTalliedVotes(guildId, candidates);
if(vote_counts == null)
{
return;
}
utils.setScriptVar(player, "guild.candidates", candidates);
obj_id votedFor = guildGetMemberAllegiance(guildId, player);
string [][] votingData = new string[candidates.length][3];
for(int i = 0; i < candidates.length; i++)
{
if(!isIdValid(candidates[i]))
{
votingData[i][0] = "Unknown Player";
continue;
}
if(candidates[i] == leader)
votingData[i][0] = "GM: " + guildGetMemberName(guildId, leader);
else
votingData[i][0] = guildGetMemberName(guildId, candidates[i]);
if(votedFor == candidates[i])
{
votingData[i][1] = "X";
}
else
{
votingData[i][1] = "";
}
votingData[i][2] = "" + vote_counts[i];
}
string [] table_titles = { "Name", "Voted For", "Votes" };
string [] table_types = { "text", "text", "integer" };
string guildName = guildGetName(guildId);
string guildAbbreviation = guildGetAbbrev(guildId);
string guildTitle = "Guild Candidates Running For Office";
if(guildName != null && guildName.length() > 0 && guildAbbreviation != null && guildAbbreviation.length() > 0)
{
guildTitle = guildName + " [" + guildAbbreviation + "] Voting";
}
utils.setScriptVar(player, "guildId", guildId);
int pid = sui.tableRowMajor(player, player, sui.OK_CANCEL, guildTitle, "onGuildVotingResponse", null, table_titles, table_types, votingData);
guild.setWindowPid(player, pid);
}
// ----------------------------------------------------------------------
void showMasterGuildWarTableDictionary(obj_id player)
{
if (!isIdValid(player) || !exists(player))
return;
if (utils.hasScriptVar(player, "guild.masterGuildWarTablePid"))
{
int existingPid = utils.getIntScriptVar(player, "guild.masterGuildWarTablePid");
utils.removeScriptVar(player, "guild.masterGuildWarTablePid");
forceCloseSUIPage(existingPid);
}
int newPid = -1;
dictionary dict = getMasterGuildWarTableDictionary();
if (dict != null)
{
string[] columnHeader = dict.getStringArray("column");
if ((columnHeader != null) && (columnHeader.length > 0))
{
string[] columnHeaderType = dict.getStringArray("columnType");
if ((columnHeaderType != null) && (columnHeaderType.length > 0) && (columnHeaderType.length == columnHeader.length))
{
boolean validColumnData = true;
string[][] columnData = new string[columnHeader.length][0];
for (int i = 0; i < columnHeader.length; ++i)
{
columnData[i] = dict.getStringArray("column" + i);
if ((columnData[i] == null) || (columnData[i].length <= 0))
{
validColumnData = false;
break;
}
}
if (validColumnData)
newPid = sui.tableColumnMajor(player, player, sui.OK_ONLY, "@guild:menu_list_of_guild_wars_active", "onMasterGuildWarTableDictionaryResponse", null, columnHeader, columnHeaderType, columnData);
}
}
}
if (newPid > 0)
utils.setScriptVar(player, "guild.masterGuildWarTablePid", newPid);
else
sendSystemMessage(player, "No data to display.", "");
}
// ----------------------------------------------------------------------
void closedMasterGuildWarTableDictionary(obj_id player)
{
if (!isIdValid(player) || !exists(player))
return;
if (utils.hasScriptVar(player, "guild.masterGuildWarTablePid"))
utils.removeScriptVar(player, "guild.masterGuildWarTablePid");
}
// ----------------------------------------------------------------------
void showInactiveGuildWarTableDictionary(obj_id player)
{
if (!isIdValid(player) || !exists(player))
return;
if (utils.hasScriptVar(player, "guild.inactiveGuildWarTablePid"))
{
int existingPid = utils.getIntScriptVar(player, "guild.inactiveGuildWarTablePid");
utils.removeScriptVar(player, "guild.inactiveGuildWarTablePid");
forceCloseSUIPage(existingPid);
}
int newPid = -1;
dictionary dict = getInactiveGuildWarTableDictionary();
if (dict != null)
{
string[] columnHeader = dict.getStringArray("column");
if ((columnHeader != null) && (columnHeader.length > 0))
{
string[] columnHeaderType = dict.getStringArray("columnType");
if ((columnHeaderType != null) && (columnHeaderType.length > 0) && (columnHeaderType.length == columnHeader.length))
{
boolean validColumnData = true;
string[][] columnData = new string[columnHeader.length][0];
for (int i = 0; i < columnHeader.length; ++i)
{
columnData[i] = dict.getStringArray("column" + i);
if ((columnData[i] == null) || (columnData[i].length <= 0))
{
validColumnData = false;
break;
}
}
if (validColumnData)
newPid = sui.tableColumnMajor(player, player, sui.OK_ONLY, "@guild:menu_list_of_guild_wars_inactive", "onInactiveGuildWarTableDictionaryResponse", null, columnHeader, columnHeaderType, columnData);
}
}
}
if (newPid > 0)
utils.setScriptVar(player, "guild.inactiveGuildWarTablePid", newPid);
else
sendSystemMessage(player, "No data to display.", "");
}
// ----------------------------------------------------------------------
void closedInactiveGuildWarTableDictionary(obj_id player)
{
if (!isIdValid(player) || !exists(player))
return;
if (utils.hasScriptVar(player, "guild.inactiveGuildWarTablePid"))
utils.removeScriptVar(player, "guild.inactiveGuildWarTablePid");
}
void showRankSummary(obj_id self, obj_id player)
{
if(!isIdValid(player) || !exists(player))
{
return;
}
if(guild.hasWindowPid(player))
{
int pid = guild.getWindowPid(player);
forceCloseSUIPage(pid);
guild.removeWindowPid(player);
}
int guildId = getGuildId(player);
if(guildId == 0)
{
return;
}
obj_id[] members = getMemberIds(guildId, false, true);
string name = guildGetMemberName(guildId, player);
if(members == null)
{
return;
}
// Grab the current candidate list.
string[] allRanks = guildGetAllRanks();
if(allRanks == null || allRanks.length < 1)
{
return;
}
utils.setScriptVar(player, "guild.allRanks", allRanks);
// Allocate memory to store this information for the table
string [][] rankData = new string[allRanks.length][3];
string [] table_titles = { "Rank", "Count", "Show" };
string [] table_types = { "text", "integer", "text" };
int [] rankTotals = new int[allRanks.length];
int [] ranksPreferred = getIntArrayObjVar(player, "guild.ranksPreferred");
// Total up the rank counts from all guild members.
for(int i = 0, j = members.length; i < j; i++)
{
if(!isIdValid(members[i]))
{
continue;
}
for(int k = 0, l = allRanks.length; k < l; k++)
{
// Initialize the rank name column
if(i == 0)
{
rankData[k][0] = localize(new string_id("guild_rank_title", allRanks[k]));
}
// Who has what?
if(guildHasMemberRank(guildId, members[i], allRanks[k]))
{
rankTotals[k]++;
}
// Last pass for this loop.
if(i == j - 1)
{
rankData[k][1] = "" + rankTotals[k];
}
}
}
if(ranksPreferred != null && ranksPreferred.length > 0)
{
for(int i = 0, j = ranksPreferred.length; i < j; i++)
{
rankData[ranksPreferred[i]][2] = "X";
}
}
// Build the table title
string guildName = guildGetName(guildId);
string guildAbbreviation = guildGetAbbrev(guildId);
string guildTitle = "Guild Rank Summary";
if(guildName != null && guildName.length() > 0 && guildAbbreviation != null && guildAbbreviation.length() > 0)
{
guildTitle = guildName + " [" + guildAbbreviation + "] Rank Summary";
}
utils.setScriptVar(player, "guildId", guildId);
// Display the rank summary table
int pid = sui.tableRowMajor(player, player, sui.OK_CANCEL, guildTitle, "onGuildRankSummaryResponse", STR_GUILD_RANK_SUMMARY_PROMPT, table_titles, table_types, rankData);
guild.setWindowPid(player, pid);
}
// ----------------------------------------------------------------------
void showRankList(obj_id self, obj_id player)
{
if(!isIdValid(player) || !exists(player))
{
return;
}
if(guild.hasWindowPid(player))
{
int pid = guild.getWindowPid(player);
forceCloseSUIPage(pid);
guild.removeWindowPid(player);
}
int guildId = getGuildId(player);
if(guildId == 0)
{
return;
}
obj_id[] members = getMemberIds(guildId, false, true);
string name = guildGetMemberName(guildId, player);
if(members == null)
{
return;
}
// Grab the current candidate list.
string[] allRanks = guildGetAllRanks();
if(allRanks == null || allRanks.length < 1)
{
return;
}
int [] ranksPreferred = getIntArrayObjVar(player, "guild.ranksPreferred");
int tableWidth = 0;
// Does this player have a preferred list of ranks to view?
if(ranksPreferred != null && ranksPreferred.length > 0)
{
tableWidth = ranksPreferred.length + 1;
}
else // No preferences. Default to 20 ranks width (plus name).
{
tableWidth = 21;
}
if(tableWidth > 21)
{
tableWidth = 21;
}
// Allocate memory to store this information for the table
string [][] rankData = new string[members.length][tableWidth];
string [] table_titles = new string[tableWidth];
string [] table_types = new string[tableWidth];
// Build the table of ranks
for(int i = 0, j = members.length; i < j; i++)
{
if(!isIdValid(members[i]))
{
rankData[i][0] = "Unknown Player";
continue;
}
// Player name column
rankData[i][0] = guildGetMemberName(guildId, members[i]);
// On the first pass, make the table column title for the player names.
if(i == 0)
{
table_titles[0] = "Name";
table_types[0] = "text";
}
// Loop through all the ranks we wish to display (preferred list or not)
for(int k = 0, l = tableWidth - 1; k < l; k++)
{
// The rank to display in the column depends on either preferences or a static index. This variable stores which one.
int rankIndex = -1;
if(ranksPreferred != null && ranksPreferred.length > 0)
{
rankIndex = ranksPreferred[k];
}
else
{
rankIndex = k;
}
// Build the header for the table
if(i == 0)
{
string rank = localize(new string_id("guild_rank_title", allRanks[rankIndex]));
// k + 1 because the first column is for player names...the rest are for ranks
table_titles[k + 1] = rank.substring(6, rank.length());
table_types[k + 1] = "text";
}
// If the player has the rank, X marks the spot.
if(guildHasMemberRank(guildId, members[i], allRanks[rankIndex]))
{
rankData[i][k + 1] = "X";
}
else
{
rankData[i][k + 1] = "";
}
}
}
// Build the table title
string guildName = guildGetName(guildId);
string guildAbbreviation = guildGetAbbrev(guildId);
string guildTitle = "Guild Ranks";
if(guildName != null && guildName.length() > 0 && guildAbbreviation != null && guildAbbreviation.length() > 0)
{
guildTitle = guildName + " [" + guildAbbreviation + "] Ranks";
}
utils.setScriptVar(player, "guildId", guildId);
utils.setScriptVar(player, "guild.memberIds", members);
// Display the massive table (500 players by 21 columns are 10500 cells maximum)
int pid = sui.tableRowMajor(player, player, sui.OK_CANCEL, guildTitle, "onGuildRankListResponse", null, table_titles, table_types, rankData);
guild.setWindowPid(player, pid);
}
void showPermissionSummary(obj_id self, obj_id player)
{
if(!isIdValid(player) || !exists(player))
{
return;
}
if(guild.hasWindowPid(player))
{
int pid = guild.getWindowPid(player);
forceCloseSUIPage(pid);
guild.removeWindowPid(player);
}
int guildId = getGuildId(player);
if(guildId == 0)
{
return;
}
obj_id[] members = getMemberIds(guildId, false, true);
string name = guildGetMemberName(guildId, player);
if(members == null)
{
return;
}
// Allocate memory to store this information for the table
string [][] permissionData = new string[members.length][12];
string [] table_titles = { "Name", "Sponsor", "Sponsor Accept", "Kick", "Mail", "Title", "Disband", "Guild Name Change", "Rank", "War", "War Excluded", "War Exclusive" };
string [] table_types = { "text", "text", "text", "text", "text", "text", "text", "text", "text", "text", "text", "text" };
int [] permissionFlags = PERMISSION_INTERFACE_FLAGS;
int [] permissionCounts = new int[11];
// Build the table of ranks
for(int i = 0, j = members.length; i < j; i++)
{
if(!isIdValid(members[i]))
{
permissionData[i][0] = "Unknown Player";
continue;
}
// Player name column
permissionData[i][0] = guildGetMemberName(guildId, members[i]);
// Loop through all the permissions we wish to display
for(int k = 0, l = 11; k < l; k++)
{
// If the player has the permission, X marks the spot.
if(hasGuildPermission(guildId, members[i], permissionFlags[k + 1]))
{
permissionData[i][k + 1] = "X";
permissionCounts[k]++;
}
else
{
permissionData[i][k + 1] = "";
}
// This is the final run through the loop? Append the count of each permission on the column title.
if(i == j - 1)
{
table_titles[k + 1] = table_titles[k + 1] + " [" + permissionCounts[k] + "]";
}
}
}
// Build the table title
string guildName = guildGetName(guildId);
string guildAbbreviation = guildGetAbbrev(guildId);
string guildTitle = "Guild Permissions";
if(guildName != null && guildName.length() > 0 && guildAbbreviation != null && guildAbbreviation.length() > 0)
{
guildTitle = guildName + " [" + guildAbbreviation + "] Permissions";
}
utils.setScriptVar(player, "guildId", guildId);
utils.setScriptVar(player, "guild.memberIds", members);
// Display the massive table (500 players by 12 columns are 6000 cells maximum)
int pid = sui.tableRowMajor(player, player, sui.OK_CANCEL, guildTitle, "onGuildPermissionListResponse", null, table_titles, table_types, permissionData);
guild.setWindowPid(player, pid);
}
void statusNotification(int guildId, obj_id who, boolean login)
{
if(guildId <= 0)
{
return;
}
obj_id[] members = getMemberIds(guildId, false, true);
if(members == null || members.length < 1)
{
return;
}
for(int i = 0, j = members.length; i < j; i++)
{
if(!isIdValid(members[i]))
{
continue;
}
if(isPlayerConnected(members[i]) && guild.hasGuildPermission(guildId, members[i], guild.GUILD_PERMISSION_ONLINE_STATUS))
{
dictionary params = new dictionary();
params.put("guildId", guildId);
params.put("player", who);
params.put("login", login);
messageTo(members[i], "handleStatusNotification", params, 1, false);
}
}
}
boolean inSameGuild(obj_id target1, obj_id target2)
{
int guildId1 = getGuildId(target1);
int guildId2 = getGuildId(target2);
if ( guildId1 <= 0 || guildId2 <= 0 )
{
return false;
}
else if ( guildId1 == guildId2 )
{
return true;
}
else
{
return false;
}
}
Reference in New Issue View Git Blame Copy Permalink