private void ServerRemote_LeaderSetOfficerRoleTitle(
FactionMemberRole role,
FactionOfficerRoleTitle roleTitle)
{
var leaderCharacter = ServerRemoteContext.Character;
ServerValidateHasAccessRights(leaderCharacter,
FactionMemberAccessRights.Leader,
out var faction);
SharedValidateIsOfficerRole(role);
var binding = Faction.GetPrivateState(faction).OfficerRoleTitleBinding;
if (binding.TryGetValue(role, out var currentRoleTitle) &&
currentRoleTitle == roleTitle)
{
return;
}
binding[role] = roleTitle;
ServerAddLogEntry(faction,
new FactionLogEntryRoleRenamed(byOfficer: leaderCharacter,
previousRoleTitle: currentRoleTitle,
newRoleTitle: roleTitle));
Logger.Important($"Officer role title changed: {role} -> {roleTitle}");
}
public string Execute([CurrentCharacterIfNull] ICharacter player, FactionMemberRole role)
{
var faction = FactionSystem.ServerGetFaction(player);
if (faction is null)
{
return($"Player {player.Name} has no faction");
}
if (!Api.IsEditor)
{
var currentRole = FactionSystem.ServerGetRole(player);
if (currentRole == FactionMemberRole.Leader)
{
return("Cannot change the role of the faction leader");
}
if (role == FactionMemberRole.Leader)
{
return("Cannot assign a leader role to anyone");
}
}
FactionSystem.ServerSetMemberRoleNoChecks(player.Name, faction, role);
return("Role changed to " + role);
}
private static void SharedValidateIsOfficerRole(FactionMemberRole role)
{
if (role < FactionMemberRole.Officer1 ||
role > FactionMemberRole.Officer3)
{
throw new Exception("Not an officer role: ");
}
}
public FactionLogEntryMemberRoleChanged(
ICharacter member,
ICharacter byOfficer,
FactionMemberRole newRole,
FactionOfficerRoleTitle?newRoleTitle)
: base(byOfficer)
{
this.MemberName = member.Name;
this.NewRole = newRole;
this.NewRoleTitle = newRoleTitle;
}
public ViewModelFactionRoleTitleEditor(
FactionMemberRole factionMemberRole,
FactionOfficerRoleTitle selectedTitle,
Action selectedTitleChanged)
{
this.AllTitles = EnumHelper.EnumValuesToViewModel <FactionOfficerRoleTitle>()
.OrderBy(e => e.Description, StringComparer.OrdinalIgnoreCase)
.ToArray();
this.FactionMemberRole = factionMemberRole;
this.selectedTitle = selectedTitle;
this.selectedTitleChanged = selectedTitleChanged;
}
private void ServerRemote_LeaderSetRoleAccessRights(
FactionMemberRole role,
FactionMemberAccessRights accessRights)
{
if (role == FactionMemberRole.Member ||
role == FactionMemberRole.Leader ||
!SharedIsValidRole(role))
{
throw new Exception("Invalid role: " + role);
}
var officer = ServerRemoteContext.Character;
ServerValidateHasAccessRights(officer,
FactionMemberAccessRights.Leader,
out var faction);
ServerValidateRoleAccessRights(accessRights);
var currentAccessRights = SharedGetRoleAccessRights(faction, role);
if (currentAccessRights == accessRights)
{
// no change required
return;
}
var accessRightsBinding = Faction.GetPrivateState(faction).AccessRightsBinding;
accessRightsBinding[role] = accessRights;
Logger.Important($"Changed faction role access rights - {role}: {accessRights}");
var roleTitle = ServerGetOfficerRoleTitle(faction, role)
?? FactionOfficerRoleTitle.Deputy; // the null should be impossible but still
ServerAddLogEntry(faction,
new FactionLogEntryRoleAccessRightsChanged(byOfficer: officer,
roleTitle,
accessRights));
// process all faction members of this role
foreach (var entry in ServerGetFactionMembersReadOnly(faction))
{
if (entry.Role == role)
{
ServerOnFactionMemberAccessRightsChanged(faction,
entry.Name,
SharedGetRoleAccessRights(faction, role));
}
}
}
public static void ClientOfficerSetMemberRole(string memberName, FactionMemberRole role)
{
if (!ClientIsFactionMember(memberName))
{
throw new Exception("Faction member is not found: " + memberName);
}
if (memberName == ClientCurrentCharacterHelper.Character.Name)
{
// cannot change self role
return;
}
ClientValidateHasAccessRights(FactionMemberAccessRights.SetMemberRole);
Instance.CallServer(
_ => _.ServerRemote_OfficerSetMemberRole(memberName, role));
}
public static void ClientLeaderSetOfficerRoleTitle(
FactionMemberRole role,
FactionOfficerRoleTitle roleTitle)
{
ClientValidateHasAccessRights(FactionMemberAccessRights.Leader);
SharedValidateIsOfficerRole(role);
var binding = Faction.GetPrivateState(ClientCurrentFaction).OfficerRoleTitleBinding;
if (binding.TryGetValue(role, out var currentRoleTitle) &&
currentRoleTitle == roleTitle)
{
return;
}
Instance.CallServer(
_ => _.ServerRemote_LeaderSetOfficerRoleTitle(role, roleTitle));
Logger.Important($"Officer role title changed: {role} -> {roleTitle}");
}
/// <summary>
/// Important: the validity of this action must be checked first
/// as this method will only change (only) the role.
/// (E.g. if checks are not made it's possible there will be more than a single leader
/// or an officer may strip the leader of its role)
/// </summary>
public static void ServerSetMemberRoleNoChecks(
string memberName,
ILogicObject faction,
FactionMemberRole role)
{
if (!SharedIsValidRole(role))
{
throw new Exception("Invalid role: " + role);
}
var members = ServerGetFactionMembersEditable(faction);
for (var index = 0; index < members.Count; index++)
{
var entry = members[index];
if (!string.Equals(entry.Name, memberName, StringComparison.Ordinal))
{
continue;
}
// member found
if (entry.Role == role)
{
// already has the role
continue;
}
members[index] = new FactionMemberEntry(memberName, role);
Logger.Important(
string.Format("Faction member role changed: {0} in {1} - role: {2}",
memberName,
faction,
role));
ServerOnFactionMemberAccessRightsChanged(faction,
memberName,
SharedGetRoleAccessRights(faction, role));
return;
}
Logger.Warning($"Faction member is not found: {memberName} in {faction}");
}
private void ServerRemote_OfficerSetMemberRole(string memberName, FactionMemberRole role)
{
var officer = ServerRemoteContext.Character;
ServerValidateHasAccessRights(officer,
FactionMemberAccessRights.SetMemberRole,
out var faction);
if (memberName == officer.Name)
{
throw new Exception($"Cannot change self role: {memberName} in {faction}");
}
var memberEntry = SharedGetMemberEntry(memberName, faction);
if (memberEntry is null)
{
throw new Exception($"Faction member is not found: {memberName} in {faction}");
}
if (memberEntry.Value.Role == FactionMemberRole.Leader)
{
throw new Exception("Cannot change the role of the faction leader");
}
var member = Server.Characters.GetPlayerCharacter(memberName)
?? throw new Exception("Character not found");
ServerSetMemberRoleNoChecks(memberName, faction, role);
var newRoleTitle = ServerGetOfficerRoleTitle(faction, role);
ServerAddLogEntry(faction,
new FactionLogEntryMemberRoleChanged(member,
officer,
newRole: role,
newRoleTitle: newRoleTitle));
}
public static void ClientLeaderSetMemberRoleAccessRight(
FactionMemberRole role,
FactionMemberAccessRights accessRights,
bool isAssigned)
{
ClientValidateHasAccessRights(FactionMemberAccessRights.Leader);
var currentAccessRights = SharedGetRoleAccessRights(ClientCurrentFaction, role);
FactionMemberAccessRights newAccessRights;
if (isAssigned)
{
if (currentAccessRights.HasFlag(accessRights))
{
return;
}
newAccessRights = currentAccessRights | accessRights;
}
else // remove
{
if (!currentAccessRights.HasFlag(accessRights))
{
return;
}
newAccessRights = currentAccessRights & ~accessRights;
}
Instance.CallServer(
_ => _.ServerRemote_LeaderSetRoleAccessRights(role, newAccessRights));
Logger.Important(string.Format("Changed member role access right: {0} {1} {2}{3}New rights: {4}",
role,
isAssigned ? "assigned" : "removed",
accessRights,
Environment.NewLine,
newAccessRights));
}
private static bool SharedIsValidRole(FactionMemberRole role)
{
return(Enum.IsDefined(typeof(FactionMemberRole), role));
}
private static void ServerAddMember(
ICharacter character,
ILogicObject faction,
FactionMemberRole role)
{
Api.Assert(!character.IsNpc, "NPC cannot join a faction");
if (!SharedIsValidRole(role))
{
throw new Exception("Invalid role: " + role);
}
var currentFaction = ServerGetFaction(character);
if (currentFaction == faction)
{
// already in faction
return;
}
if (currentFaction is not null)
{
throw new Exception($"Player already has a faction: {character} in {faction}");
}
// faction members cannot have a newbie protection
NewbieProtectionSystem.ServerDisableNewbieProtection(character);
var members = ServerGetFactionMembersEditable(faction);
var factionPublicState = Faction.GetPublicState(faction);
var maxMembers = FactionConstants.SharedGetFactionMembersMax(factionPublicState.Kind);
if (members.Count >= maxMembers)
{
throw new Exception("Faction size exceeded - max " + maxMembers);
}
if (role == FactionMemberRole.Leader)
{
foreach (var otherMember in members)
{
if (otherMember.Role == FactionMemberRole.Leader)
{
throw new Exception("Faction can have only a single leader");
}
}
}
members.Add(new FactionMemberEntry(character.Name, role));
ServerCharacterFactionDictionary[character] = faction;
PlayerCharacter.GetPublicState(character).ClanTag = factionPublicState.ClanTag;
factionPublicState.PlayersNumberCurrent++;
Logger.Important($"Player joined faction: {character} in {faction} - role: {role}",
character);
ServerInvitations.RemoveAllInvitationsFor(character);
Api.SafeInvoke(
() => ServerCharacterJoinedOrLeftFaction?.Invoke(character,
faction,
isJoined: true));
// add this with some delay to prevent from the bug when the player name listed twice due to the late delta-replication
ServerTimersSystem.AddAction(delaySeconds: 0.1,
() => ServerSendCurrentFaction(character));
}
public FactionMemberEntry(string name, FactionMemberRole role)
{
this.Name = name;
this.Role = role;
}
public FactionRoleTitleEditor(FactionMemberRole role, FactionOfficerRoleTitle title)
{
this.role = role;
this.title = title;
}
