public void Init(MyObjectBuilder_FactionCollection builder)
{
if (!MySession.Static.Battle)
{
foreach (var factionBuilder in builder.Factions)
{
MySession.Static.Factions.Add(new MyFaction(factionBuilder));
}
}
foreach (var player in builder.Players.Dictionary)
{
m_playerFaction.Add(player.Key, player.Value);
}
foreach (var relation in builder.Relations)
{
m_relationsBetweenFactions.Add(new MyFactionPair(relation.FactionId1, relation.FactionId2), relation.Relation);
}
foreach (var request in builder.Requests)
{
var set = new HashSet <long>();
foreach (var entry in request.FactionRequests)
{
set.Add(entry);
}
m_factionRequests.Add(request.FactionId, set);
}
}
public static Boolean CheckPlayerSameFaction(long playerId, long compareId)
{
if (compareId == playerId)
{
return(true);
}
MyObjectBuilder_FactionCollection m_factionCollection = (MyObjectBuilder_FactionCollection)InvokeEntityMethod(FactionsManager.Instance.BackingObject, FactionsManager.FactionManagerGetFactionCollectionMethod);
if (m_factionCollection == null)
{
Console.WriteLine("No faction collection");
return(false);
}
if (m_factionCollection.Factions == null)
{
Console.WriteLine("No factions");
return(false);
}
MyObjectBuilder_Faction faction = m_factionCollection.Factions.FirstOrDefault(f => f.Members.FirstOrDefault(m => m.PlayerId == playerId).PlayerId != 0);
if (faction != null)
{
if (faction.Members.FirstOrDefault(m => m.PlayerId == compareId).PlayerId != 0)
{
return(true);
}
}
return(false);
}
public static long GetCapturedAstroids()
{
long NumCapturedAstoids = 0;
try // Fix for NullRefException in Shop Buy
{
MyObjectBuilder_FactionCollection factionlist = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
foreach (MyObjectBuilder_Faction faction in factionlist.Factions)
{
List <MyObjectBuilder_FactionMember> currentfacitonmembers = faction.Members;
foreach (MyObjectBuilder_FactionMember currentmember in currentfacitonmembers)
{
var leaders = GMConquest.Instance.Leaderboard.GroupBy(x => x.Value).Select(group => new { group.Key, Total = group.Count() }).OrderByDescending(x => x.Total);
foreach (var p in leaders)
{
if (p.Key == currentmember.PlayerId)
{
NumCapturedAstoids += p.Total;
}
}
}
}
return(NumCapturedAstoids);
}
catch (NullReferenceException)
{
return(0);
}
}
public static MyObjectBuilder_Faction getFaction(long factionID)
{
MyObjectBuilder_FactionCollection factionlist = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
foreach (MyObjectBuilder_Faction faction in factionlist.Factions)
{
if (faction.FactionId == factionID)
{
return(faction);
}
}
return(null);
}
public static long getFactionIDfromTag(string factag)
{
MyObjectBuilder_FactionCollection factioncollection = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
foreach (MyObjectBuilder_Faction faction in factioncollection.Factions)
{
if (faction.Tag == factag)
{
return(faction.FactionId);
}
}
return(0);
}
public static long getFactionID(ulong steamId)
{
long playerID = PlayerMap.Instance.GetPlayerIdsFromSteamId(steamId)[0];
MyObjectBuilder_FactionCollection factioncollection = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
foreach (MyObjectBuilder_Faction faction in factioncollection.Factions)
{
List <MyObjectBuilder_FactionMember> currentfaction = faction.Members;
foreach (MyObjectBuilder_FactionMember currentmember in currentfaction)
{
if (currentmember.PlayerId == playerID)
{
return(faction.FactionId);
}
}
}
return(0);
}
public MyObjectBuilder_FactionCollection GetObjectBuilder()
{
var builder = new MyObjectBuilder_FactionCollection();
builder.Factions = new List <MyObjectBuilder_Faction>(m_factions.Count);
foreach (var faction in m_factions)
{
builder.Factions.Add(faction.Value.GetObjectBuilder());
}
builder.Players = new SerializableDictionary <long, long>();
foreach (var entry in m_playerFaction)
{
builder.Players.Dictionary.Add(entry.Key, entry.Value);
}
builder.Relations = new List <MyObjectBuilder_FactionRelation>(m_relationsBetweenFactions.Count);
foreach (var entry in m_relationsBetweenFactions)
{
var relation = new MyObjectBuilder_FactionRelation();
relation.FactionId1 = entry.Key.FactionId1;
relation.FactionId2 = entry.Key.FactionId2;
relation.Relation = entry.Value;
builder.Relations.Add(relation);
}
builder.Requests = new List <MyObjectBuilder_FactionRequests>();
foreach (var entryFrom in m_factionRequests)
{
var list = new List <long>(entryFrom.Value.Count);
foreach (var entryTo in m_factionRequests[entryFrom.Key])
{
list.Add(entryTo);
}
builder.Requests.Add(new MyObjectBuilder_FactionRequests()
{
FactionId = entryFrom.Key, FactionRequests = list
});
}
return(builder);
}
public override bool HandleCommand(ulong userId, string[] words)
{
// Display Faction Leaderboard
string flstring = "";
MyObjectBuilder_FactionCollection factionlist = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
List <FactionScores> factionleaderboard = new List <FactionScores>();
int position = 1;
foreach (MyObjectBuilder_Faction faction in factionlist.Factions)
{
long faction_score = 0;
List <MyObjectBuilder_FactionMember> currentfaction = faction.Members;
foreach (MyObjectBuilder_FactionMember currentmember in currentfaction)
{
var leaders = GMConquest.Instance.Leaderboard.GroupBy(x => x.Value).Select(group => new { group.Key, Total = group.Count() }).OrderByDescending(x => x.Total);
foreach (var p in leaders)
{
if (p.Key == currentmember.PlayerId)
{
faction_score += p.Total;
}
}
}
if (faction_score > 0)
{
factionleaderboard.Add(new FactionScores(faction.Name, faction_score));
}
}
factionleaderboard = factionleaderboard.OrderByDescending(x => x.FactionScore).ToList();
foreach (FactionScores score in factionleaderboard)
{
flstring += string.Format("#{0}: {1} with {2} asteroids.\r\n", position, score.FactionName, score.FactionScore);
position++;
}
ChatUtil.DisplayDialog(userId, "Faction Leaderbored", "Current Leader", flstring);
return(true);
}
public override void Handle()
{
// * Faction Points System: Every 60 minutes, Give each faction (owned asteroids) number of credits. Save faction balances to file.
// ----------------------
try
{
MyObjectBuilder_FactionCollection factionlist = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
int num_factions = factionlist.Factions.Count; //get number of factions
ulong[,] fcleaderboard = new ulong[num_factions, 2];
foreach (MyObjectBuilder_Faction faction in factionlist.Factions)
{
int faction_score = 0;
List <MyObjectBuilder_FactionMember> currentfaction = faction.Members;
foreach (MyObjectBuilder_FactionMember currentmember in currentfaction)
{
var leaders = GMConquest.Instance.Leaderboard.GroupBy(x => x.Value).Select(group => new { group.Key, Total = group.Count() }).OrderByDescending(x => x.Total);
foreach (var p in leaders)
{
if (p.Key == currentmember.PlayerId)
{
faction_score += p.Total;
}
}
}
// Add faction_score to factions current credits.
FactionPoints.AddFP(faction.FactionId, faction_score);
}
}
catch (InvalidOperationException)
{
// Log Invalid Operation
Log.Info("Caught Invalid Operation in FactionPoints Process.");
}
// ----------------------
base.Handle();
}
private void FactionCleanup()
{
HashSet <long> owners = GetAllOwners();
MyObjectBuilder_FactionCollection factionCollection = MyAPIGateway.Session.GetWorld().Checkpoint.Factions;
List <MyObjectBuilder_Faction> removeList = new List <MyObjectBuilder_Faction>();
foreach (MyObjectBuilder_Faction faction in factionCollection.Factions)
{
bool hasMembers = false;
foreach (MyObjectBuilder_FactionMember member in faction.Members)
{
if (owners.Contains(member.PlayerId))
{
hasMembers = true;
//break;
}
else
{
Log.Info(string.Format("Removing member with no player info: {0}", member.PlayerId));
MyAPIGateway.Session.Factions.KickMember(faction.FactionId, member.PlayerId);
}
}
if (!hasMembers)
{
removeList.Add(faction);
}
}
foreach (MyObjectBuilder_Faction faction in removeList)
{
MyAPIGateway.Session.Factions.RemoveFaction(faction.FactionId);
}
Log.Info(string.Format("Removed {0} factions", removeList.Count));
}
public MyObjectBuilder_FactionCollection GetSubTypeEntity( )
{
m_factionCollection = (MyObjectBuilder_FactionCollection)BaseObject.InvokeEntityMethod(BackingObject, FactionManagerGetFactionCollectionMethod);
return(m_factionCollection);
}
public override bool Invoke(ulong steamId, long playerId, string messageText)
{
var matchFactionChat = Regex.Match(messageText, @"(=|/fch|/factionchat)\s+(?<Message>.+)", RegexOptions.IgnoreCase);
if (matchFactionChat.Success)
{
IMyPlayer player = MyAPIGateway.Session.Player;
var plFaction = MyAPIGateway.Session.Factions.TryGetPlayerFaction(player.IdentityId);
if (plFaction != null)
{
SendToFaction(matchFactionChat.Groups["Message"].Value, plFaction, FactionMessageType.OwnFaction);
MyAPIGateway.Utilities.ShowMessage(String.Format("[F] {0}", player.DisplayName), matchFactionChat.Groups["Message"].Value);
}
else
{
MyAPIGateway.Utilities.ShowMessage("Faction chat", "You are not a member of any faction.");
}
return(true);
}
var matchAlliedFactionChat = Regex.Match(messageText, @"-\s+(?<Message>.+)", RegexOptions.IgnoreCase);
if (matchAlliedFactionChat.Success)
{
IMyPlayer player = MyAPIGateway.Session.Player;
var plFaction = MyAPIGateway.Session.Factions.TryGetPlayerFaction(player.IdentityId);
if (plFaction != null)
{
MyObjectBuilder_FactionCollection factionCollection = MyAPIGateway.Session.Factions.GetObjectBuilder();
var factionsList = factionCollection.Factions;
foreach (MyObjectBuilder_Faction currBuilderFaction in factionsList)
{
var currFaction = MyAPIGateway.Session.Factions.TryGetFactionById(currBuilderFaction.FactionId);
if (!MyAPIGateway.Session.Factions.AreFactionsEnemies(plFaction.FactionId, currFaction.FactionId))
{
SendToFaction(matchAlliedFactionChat.Groups["Message"].Value, currFaction, FactionMessageType.AlliedFacitons);
}
}
MyAPIGateway.Utilities.ShowMessage(String.Format("[A] {0}", player.DisplayName), matchAlliedFactionChat.Groups["Message"].Value);
}
else
{
MyAPIGateway.Utilities.ShowMessage("Faction chat", "You are not a member of any faction.");
}
return(true);
}
var matchHubChat = Regex.Match(messageText, @"\+\s+(?<Message>.+)", RegexOptions.IgnoreCase);
if (matchHubChat.Success)
{
IMyPlayer player = MyAPIGateway.Session.Player;
var plFaction = MyAPIGateway.Session.Factions.TryGetPlayerFaction(player.IdentityId);
if (plFaction != null)
{
MyObjectBuilder_FactionCollection factionCollection = MyAPIGateway.Session.Factions.GetObjectBuilder();
var factionsList = factionCollection.Factions;
var chatFactionBuilder = factionsList.FirstOrDefault(f => f.Tag.Equals("CHT"));
if (chatFactionBuilder == null)
{
MyAPIGateway.Utilities.ShowMessage("Faction chat", "There is no CHT faction for broadcasting.");
return(true);
}
var chatFaction = MyAPIGateway.Session.Factions.TryGetFactionById(chatFactionBuilder.FactionId);
if (!MyAPIGateway.Session.Factions.AreFactionsEnemies(plFaction.FactionId, chatFaction.FactionId))
{
foreach (MyObjectBuilder_Faction currBuilderFaction in factionsList)
{
var currFaction = MyAPIGateway.Session.Factions.TryGetFactionById(currBuilderFaction.FactionId);
if (!MyAPIGateway.Session.Factions.AreFactionsEnemies(chatFaction.FactionId, currFaction.FactionId))
{
SendToFaction(matchHubChat.Groups["Message"].Value, currFaction, FactionMessageType.AlliedWithHub);
}
}
MyAPIGateway.Utilities.ShowMessage(String.Format("[H] {0}", player.DisplayName), matchHubChat.Groups["Message"].Value);
}
else
{
MyAPIGateway.Utilities.ShowMessage("Faction chat", "You are not allied with CHT.");
}
return(true);
}
MyAPIGateway.Utilities.ShowMessage("Faction chat", "You are not a member of any faction.");
return(true);
}
var matchBroadcast = Regex.Match(messageText, @"!\s+(?<Message>.+)", RegexOptions.IgnoreCase);
if (matchBroadcast.Success)
{
IMyPlayer player = MyAPIGateway.Session.Player;
if (player.IsAdmin())
{
List <IMyPlayer> listplayers = new List <IMyPlayer>();
MyAPIGateway.Players.GetPlayers(listplayers);
foreach (IMyPlayer receiver in listplayers.Where(p => p != player))
{
SendFactionMessage(receiver, matchBroadcast.Groups["Message"].Value, FactionMessageType.Broadcast);
}
MyAPIGateway.Utilities.ShowMessage(String.Format("[B] {0}", player.DisplayName), matchBroadcast.Groups["Message"].Value);
}
else
{
MyAPIGateway.Utilities.ShowMessage("Faction chat", "You do not have administrator privileges for broadcasting to everybody.");
}
return(true);
}
return(false);
}
