public PlanetWarsHandler(string host, int port, AutoHost autoHost, TasClient tas, MainConfig config)
{
this.autoHost = autoHost;
this.tas = tas;
this.host = host;
account = new AuthInfo(config.AccountName, config.PlanetWarsServerPassword);
server = (ISpringieServer) Activator.GetObject(typeof (ISpringieServer), String.Format("tcp://{0}:{1}/IServer", host, port));
// fill factions for channel monitoring and join channels
planetWarsChannels = new List<string>();
var factions = server.GetFactions(account);
foreach (var fact in factions) {
string name = fact.Name.ToLower();
planetWarsChannels.Add(name);
if (!config.JoinChannels.Contains(name)) {
var list = new List<string>(config.JoinChannels);
list.Add(name);
config.JoinChannels = list.ToArray();
if (tas != null && tas.IsConnected && tas.IsLoggedIn) tas.JoinChannel(name);
}
}
timer.Interval = 2000;
timer.Elapsed += timer_Elapsed;
timer.AutoReset = true;
timer.Start();
}
public static string AddPlayer()
{
ConnectIfNecessary();
var faction = Program.SpringieServer.GetFactions(springieAuth).TakeRandom();
var auth = new AuthInfo(Resources.names.Replace("\r\n", "\n").Split('\n').TakeRandom(), "1");
var result = Program.SpringieServer.Register(springieAuth, auth, faction.Name, null);
if (result.StartsWith("Welcome to PlanetWars!")) {
auths.Add(auth);
return result + " (success)";
}
return result + " (failed)";
}
public string GetStartupModOptions(AuthInfo springieLogin, string mapName, ICollection<IPlayer> players)
{
if (mapName == null) {
throw new ArgumentNullException("mapName");
}
if (players == null) {
throw new ArgumentNullException("players");
}
var planet = Galaxy.Planets.Single(p => p.MapName == mapName);
if (!GetAttackOptions(springieLogin).Any(p => p.ID == planet.ID)) {
throw new ApplicationException("You cannot attack this planet right now");
}
var planetOwner = Galaxy.GetPlayer(planet.OwnerName);
var leaderName = players.Any(p => p.Name == planetOwner.Name)
? planetOwner.Name
: (from p in players
where p.FactionName == planetOwner.FactionName
orderby p.RankOrder
select p.Name).First();
var factions = players.Select(p => p.FactionName).Distinct().ToList();
var difference = players.Count(p => p.FactionName == factions[1]) - players.Count(p => p.FactionName == factions[0]);
var outNumberedFaction = difference > 0 ? factions[0] : factions[1];
var playersToReinforce = players // fixme: dont hardcode units and factions
.Where(p => p.FactionName == outNumberedFaction).OrderBy(p => p.RankOrder).Take(Math.Abs(difference))
// FIXME: might not give enough comms
.ToDictionary(p => p.Name, p => 1); // fixme: use right number of comms instead of 1
File.AppendAllText("modOptionsLog.txt", "Factions: " + String.Join(" ", factions.ToArray()) + "\n");
File.AppendAllText("modOptionsLog.txt", "Difference: " + difference + "\n");
File.AppendAllText("modOptionsLog.txt", "Outnumbered faction: " + outNumberedFaction + "\n");
File.AppendAllText(
"modOptionsLog.txt", "Players to reinforce: " + String.Join(" ", playersToReinforce.Keys.ToArray()) + "\n");
if (players.Contains(planetOwner) && planetOwner.Name != leaderName) {
throw new Exception("Owner is in battle but is not leader");
}
// get list of blocked factions
var blockedFactions = new List<string>();
var factionFleets =
Galaxy.Fleets.Where(f => f.TargetPlanetID == planet.ID && f.Arrives <= Galaxy.Turn).GroupBy(
f => Galaxy.GetPlayer(f.OwnerName).FactionName).OrderByDescending(g => g.Count()).ToList();
for (var i = 0; i < factionFleets.Count(); i++) {
blockedFactions.AddRange(Galaxy.Factions.Where(f => f.Name != factionFleets[i].Key).Select(f => f.Name.ToUpper()));
// disable enemy factions
if (i < factionFleets.Count() - 1 && factionFleets[i].Count() > factionFleets[i + 1].Count()) {
break; // more ships than other faction, no other factions block upgrades
}
}
var main = new LuaTable();
var teams = new LuaTable();
main["teams"] = teams;
var teamID = 0;
var isWithoutUpgrades = disabledUpgradesHosts.Contains(springieLogin.Login);
foreach (var player in players) {
var plTable = new LuaTable();
var mobiles = new LuaTable();
var structures = new LuaTable();
var purchases = new LuaTable();
var galPlayer = Galaxy.GetPlayer(player.Name);
teams.Add("[" + teamID++ + "]", plTable);
plTable["mobiles"] = mobiles;
plTable["structures"] = structures;
plTable["purchases"] = purchases;
plTable["money"] = galPlayer.MetalAvail;
plTable["name"] = galPlayer.Name;
// extra commanders
int reinforcementNumber;
if (playersToReinforce.TryGetValue(player.Name, out reinforcementNumber) && reinforcementNumber > 0) {
var unit = player.FactionName.ToUpper() == "ARM" ? "armcom" : "corcom";
for (var i = 0; i < reinforcementNumber; i++) {
mobiles.Add(new LuaTable {{"unitname", unit}});
}
}
if (isWithoutUpgrades) {
continue;
}
var isAllyOwnedPlanet = player.FactionName.ToUpper() == planetOwner.FactionName.ToUpper();
List<UpgradeDef> playerUpgrades;
if (UpgradeData.TryGetValue(player.Name, out playerUpgrades)) {
if (!blockedFactions.Contains(player.FactionName.ToUpper())) {
foreach (var upgrade in playerUpgrades.Where(u => !u.IsBuilding || isAllyOwnedPlanet)) {
purchases.Add(new LuaTable {{"unitname", upgrade.UnitChoice}, {"owner", player.Name}});
if (!upgrade.IsBuilding && upgrade.QuantityMobiles > 0) {
for (var i = 0; i < upgrade.QuantityMobiles; i++) {
mobiles.Add(new LuaTable {{"unitname", upgrade.UnitChoice}, {"owner", player.Name}});
}
}
}
}
if (isAllyOwnedPlanet) {
foreach (var upgrade in playerUpgrades.Where(u => u.IsBuilding)) {
foreach (var d in upgrade.DeployLocations) {
if (d.PlanetID == planet.ID) {
structures.Add(
new LuaTable
{
{"unitname", upgrade.UnitChoice},
{"x", d.X},
{"z", d.Z},
{"orientation", d.Orientation},
{"owner", player.Name}
});
}
}
}
}
}
// deploy other structures present on the planet to the leader
if (player.Name == leaderName) {
foreach (var kvp in UpgradeData) {
if (players.Any(x => x.Name == kvp.Key) || Galaxy.GetPlayer(kvp.Key).FactionName != planetOwner.FactionName) {
continue; //skip players which play
}
foreach (var upg in kvp.Value.Where(u => u.IsBuilding)) {
// give allied deployed units
foreach (var d in upg.DeployLocations.Where(p => p.PlanetID == planet.ID)) {
structures.Add(
new LuaTable
{{"unitname", upg.UnitChoice}, {"x", d.X}, {"z", d.Z}, {"orientation", d.Orientation}, {"owner", kvp.Key}});
}
}
}
}
}
main["allyteams"] = new LuaTable();
main["hostname"] = springieLogin.Login;
var optionsString = "return " + main;
File.AppendAllText("modOptionsLog.txt", optionsString);
return Convert.ToBase64String(Encoding.ASCII.GetBytes(optionsString)).Replace("\t", " ").Replace("=", "_");
}
public string Register(AuthInfo springieLogin, AuthInfo account, string side, string planet)
{
return s.Register(springieLogin, account, side, planet);
}
public IFaction GetOffensiveFaction(AuthInfo springieLogin)
{
return s.GetOffensiveFaction(springieLogin);
}
public ICollection<IFaction> GetFactions(AuthInfo springieLogin)
{
return s.GetFactions(springieLogin);
}
public bool ChangePlayerPassword(string newPassword, AuthInfo authorization, out string message)
{
return s.ChangePlayerPassword(newPassword, authorization, out message);
}
public bool ChangeCommanderInChiefTitle(string newTitle, AuthInfo authorization, out string message)
{
return s.ChangeCommanderInChiefTitle(newTitle, authorization, out message);
}
public void AddAward(AuthInfo springieLogin, string playerName, string awardType, string awardText, string mapName)
{
s.AddAward(springieLogin, playerName, awardType, awardText, mapName);
}
public bool SendBlockadeFleet(AuthInfo login, int targetPlanetID, out string message)
{
return s.SendBlockadeFleet(login, targetPlanetID, out message);
}
public void BuyUpgrade(AuthInfo login, int upgradeDefID, string choice)
{
s.BuyUpgrade(login, upgradeDefID, choice);
}
public bool SetTimeZone(TimeZoneInfo LocalTimeZone, AuthInfo authorization, out string message)
{
return s.SetTimeZone(LocalTimeZone, authorization, out message);
}
public bool SetReminderOptions(ReminderEvent reminderEvent, ReminderLevel reminderLevel, ReminderRoundInitiative reminderRoundInitiative, AuthInfo authorization, out string message)
{
return s.SetReminderOptions(reminderEvent, reminderLevel, reminderRoundInitiative, authorization, out message);
}
public SendBattleResultOutput SendBattleResult(AuthInfo springieLogin, string mapName, ICollection<EndGamePlayerInfo> participants)
{
return s.SendBattleResult(springieLogin, mapName, participants);
}
public SendBattleResultOutput SendBattleResult(AuthInfo springieLogin,
string mapName,
ICollection<EndGamePlayerInfo> usersInGame)
{
var ret = new SendBattleResultOutput();
ret.RankNotifications = new List<RankNotification>();
if (springieLogin == null) {
throw new ArgumentNullException("springieLogin");
}
if (usersInGame == null) {
throw new ArgumentNullException("usersInGame");
}
if (!ValidateSpringieLogin(springieLogin)) {
return ret; // silently ignore other than valid springie
}
var invalids = usersInGame.Where(x => !x.Spectator && Galaxy.GetPlayer(x.Name) == null).ToList();
foreach (var u in invalids) {
ret.MessageToDisplay += "Invalid players " + u.Name + " ignored";
usersInGame.Remove(u);
}
if (!usersInGame.Any(p => p.OnVictoryTeam)) {
ret.MessageToDisplay += "No losing players";
return ret;
}
if (!usersInGame.Any(p => !p.OnVictoryTeam)) {
ret.MessageToDisplay += "Only losing players";
return ret;
}
if (!usersInGame.All(u => u.Spectator || Galaxy.GetPlayer(u.Name) != null)) {
throw new Exception("Player is not registered.");
}
if (
!usersInGame.All(
u =>
u.Spectator ||
String.Equals(Galaxy.GetPlayer(u.Name).FactionName, u.Side, StringComparison.InvariantCultureIgnoreCase))) {
throw new Exception("Faction mismatch.");
}
var isWithoutUpgrades = disabledUpgradesHosts.Contains(springieLogin.Login);
Faction victoriousFaction = null;
foreach (var user in usersInGame) {
if (user.Spectator) {
continue;
}
var player = Galaxy.Players.Single(p => p.Name == user.Name);
if (user.OnVictoryTeam) {
player.Victories++;
player.MeasuredVictories++;
player.MetalEarned += Settings.Default.MetalForVictory;
if (victoriousFaction == null) {
victoriousFaction = Galaxy.Factions.Single(f => f.Name == player.FactionName);
}
} else {
player.Defeats++;
player.MeasuredDefeats++;
player.MetalEarned += Settings.Default.MetalForDefeat;
}
}
if (victoriousFaction == null) {
ret.MessageToDisplay += "No winners";
return ret;
}
var planet = Galaxy.Planets.Single(p => p.MapName == mapName);
var isConquest = planet.FactionName != victoriousFaction.Name;
planet.FactionName = victoriousFaction.Name;
if (!isWithoutUpgrades) {
KillFleetsAndUpgrades(victoriousFaction, planet);
}
LastChanged = DateTime.Now;
var sb = new StringBuilder();
var encircledPlanetIDs = new List<int>();
if (isConquest) {
var encircledPlanets =
Galaxy.Planets.Where(p => p.FactionName != victoriousFaction.Name && Galaxy.IsPlanetEncircled(p));
foreach (var p in encircledPlanets) {
p.FactionName = victoriousFaction.Name;
sb.AppendFormat(",{0} ", p.Name);
encircledPlanetIDs.Add(p.ID);
}
if (sb.Length != 0) {
sb.Append("have fallen due to lack of supply.");
}
}
if (!SpringieStates.ContainsKey(springieLogin.Login)) {
throw new Exception("No springie state found!");
}
var attackingFaction = SpringieStates[springieLogin.Login].GameStartedStatus.OffensiveFactionName;
var defendingFaction = Galaxy.Factions.Single(f => f.Name != attackingFaction).Name;
Galaxy.Turn++;
Galaxy.OffensiveFactionInternal = victoriousFaction.Name;
List<PlayerRankChangedEvent> changedRanks;
Galaxy.CalculatePlayerRanks(out changedRanks);
Galaxy.SwapUnusedPlanets();
CalculateEndTurnMetal();
foreach (var e in changedRanks) {
if (e.NewRank > e.OldRank) {
new RankNotification(e.PlayerName, string.Format("Congratulations, you have been promoted to {0}!", e.NewRank));
} else {
new RankNotification(e.PlayerName, string.Format("You have just lost a rank! Conquer planets to regain it!"));
}
}
var spaceFleetOwners = from f in Galaxy.Fleets
where f.IsAtDestination(Galaxy.Turn)
select f.OwnerName;
var battleEvent = new BattleEvent(
DateTime.Now,
usersInGame.Where(u => !u.Spectator).ToList(),
mapName,
attackingFaction,
defendingFaction,
victoriousFaction.Name,
disabledUpgradesHosts.Contains(springieLogin.Login),
State.Galaxy,
encircledPlanetIDs,
spaceFleetOwners);
State.Galaxy.Events.Add(battleEvent);
Galaxy.CalculateBattleElo(battleEvent);
var enemyPlanetCount = Galaxy.Planets.Count(p => p.FactionName != victoriousFaction.Name);
if (enemyPlanetCount == 0) {
State.Galaxy = Galaxy.AdvanceRound(Settings.Default.GalaxyTemplatePath);
ForceSaveState();
ret.MessageToDisplay += string.Format(
"{0} HAS FINALLY CONQUERED THE GALAXY! (New round is starting)", victoriousFaction.Name);
return ret;
}
ForceSaveState();
ret.MessageToDisplay += string.Format(
"Congratulations, planet {0} {2} by {1} {3}",
planet.Name,
victoriousFaction.Name,
isConquest ? "conquered" : "held",
sb);
return ret;
}
public bool ChangePlanetName(string newName, AuthInfo authorization, out string message)
{
return s.ChangePlanetName(newName, authorization, out message);
}
public bool ChangePlanetDescription(string newDescription, AuthInfo authorization, out string message)
{
return s.ChangePlanetDescription(newDescription, authorization, out message);
}
public void SendChatLine(AuthInfo springieLogin, string channel, string playerName, string text)
{
s.SendChatLine(springieLogin, channel, playerName, text);
}
public bool SendAid(string toPlayer, double ammount, AuthInfo authorization, out string message)
{
return s.SendAid(toPlayer, ammount, authorization, out message);
}
public void UnitDeployed(AuthInfo springieLogin, string mapName, string playerName, string unit, int x, int z, string rotation)
{
s.UnitDeployed(springieLogin, mapName, playerName, unit, x, z, rotation);
}
public ICollection<IPlanet> GetAttackOptions(AuthInfo springieLogin)
{
return s.GetAttackOptions(springieLogin);
}
public string ResetPassword(AuthInfo springieLogin, string loginName)
{
return s.ResetPassword(springieLogin, loginName);
}
public ICollection<string> GetPlayersToNotify(AuthInfo springieLogin, string mapName, ReminderEvent reminderEvent)
{
return s.GetPlayersToNotify(springieLogin, mapName, reminderEvent);
}
public void UnitDied(AuthInfo springieLogin, string playerName, string unitName, int x, int z)
{
s.UnitDied(springieLogin, playerName, unitName, x, z);
}
public IPlayer GetPlayerInfo(AuthInfo springieLogin, string name)
{
return s.GetPlayerInfo(springieLogin, name);
}
public void UnitPurchased(AuthInfo springieLogin, string playerName, string unitName, double cost, int x, int z)
{
s.UnitPurchased(springieLogin, playerName, unitName, cost, x, z);
}
public string GetStartupModOptions(AuthInfo springieLogin, string mapName, ICollection<IPlayer> players)
{
return s.GetStartupModOptions(springieLogin, mapName, players);
}
public Galaxy GetGalaxyMap(AuthInfo authorization)
{
return s.GetGalaxyMap(authorization);
}
public bool ChangePlanetMap(string mapName, AuthInfo authorization, out string message)
{
return s.ChangePlanetMap(mapName, authorization, out message);
}
public string Register(AuthInfo springieLogin, AuthInfo account, string side, string planetName)
{
if (account == null) {
throw new ArgumentNullException("account");
}
if (springieLogin == null) {
throw new ArgumentNullException("springieLogin");
}
if (!ValidateSpringieLogin(springieLogin)) {
return string.Empty; // silently ignore other than valid springie
}
if (Galaxy.Players.Any(p => p.Name == account.Login)) {
return "Name already taken.";
}
var faction =
Galaxy.Factions.SingleOrDefault(f => string.Equals(f.Name, side, StringComparison.InvariantCultureIgnoreCase));
if (faction == null) {
return "Invalid faction chosen.";
}
var teams = (from p in Galaxy.Players
where p.FactionName != faction.Name && (p.Victories > 0 || p.Defeats > 0)
group p by p.FactionName
into gr select gr.Count());
var smallestTeam = teams.Count() > 0 ? teams.Min() : 0;
var myFaction = Galaxy.Players.Count(p => p.FactionName == faction.Name && (p.Victories > 0 || p.Defeats > 0));
if (myFaction - smallestTeam > Settings.Default.MaxFactionSizeDifference) {
return "Selected faction already has too many active players.";
}
string result;
Event playerEvent;
var planets = Galaxy.GetClaimablePlanets(faction).ToArray();
if (planets.Any()) {
var planet = string.IsNullOrEmpty(planetName)
? planets.TakeRandom()
: planets.SingleOrDefault(p => p.Name.ToUpper() == planetName.ToUpper());
if (planet == null) {
return string.Format("Planet {0} is occupied or not in the galaxy.", planetName);
}
var mapName = Galaxy.GetAvailableMaps().TakeRandom();
planet.OwnerName = account.Login;
planet.MapName = mapName;
planet.FactionName = faction.Name;
playerEvent = new PlayerRegisteredEvent(DateTime.Now, account.Login, planet.ID, State.Galaxy);
result = string.Format("Welcome to PlanetWars! Your planet is {0}, with map {1}.", planet.Name, planet.MapName);
} else {
result = "Welcome to PlanetWars! You are in, but you don't own any planet (no free planets left.)";
playerEvent = new PlayerRegisteredEvent(DateTime.Now, account.Login, null, State.Galaxy);
}
State.Accounts[account.Login] = Hash.HashString(account.Password);
Galaxy.Players.Add(new Player(account.Login, faction.Name));
State.Galaxy.Events.Add(playerEvent);
SaveState();
return result;
}
