// ======================================================================
//
// 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;
	}
}