static void VerifySpecCheaters(BattleContext context, BalanceTeamsResult res)
{
try {
// find specs with same IP as some player and kick them
using (var db = new ZkDataContext()) {
var ids = context.Players.Select(y => (int?)y.LobbyID).ToList();
var ipByLobbyID = db.Accounts.Where(x => ids.Contains(x.AccountID))
.ToDictionary(x => x.AccountID, x => x.AccountIPs.OrderByDescending(y => y.LastLogin).Select(y => y.IP).FirstOrDefault());
// lobbyid -> ip mapping
var mode = context.GetMode();
// kick same ip specs for starred and non chickens
/*
* if (mode != AutohostMode.None && mode != AutohostMode.GameChickens) {
* foreach (var p in context.Players.Where(x => x.IsSpectator)) {
* var ip = ipByLobbyID[p.LobbyID];
* if (context.Players.Any(x => !x.IsSpectator && ipByLobbyID[x.LobbyID] == ip)) Global.Nightwatch.Tas.AdminKickFromLobby(p.Name, "Spectators from same location as players are not allowed here!");
* }
* }*/
foreach (var grp in context.Players.GroupBy(x => ipByLobbyID[x.LobbyID]).Where(x => x.Count() > 1))
{
res.Message += string.Format("\nThese people are in same location: {0}", string.Join(", ", grp.Select(x => x.Name)));
}
}
} catch (Exception ex) {
Trace.TraceError("Error checking speccheaters: {0}", ex);
}
}
public static PlayerJoinResult AutohostPlayerJoined(BattleContext context, int accountID)
{
var res = new PlayerJoinResult();
var db = new ZkDataContext();
AutohostMode mode = context.GetMode();
if (mode == AutohostMode.Planetwars)
{
Planet planet = db.Galaxies.Single(x => x.IsDefault).Planets.SingleOrDefault(x => x.Resource.InternalName == context.Map);
if (planet == null)
{
res.PublicMessage = "Invalid map";
return(res);
}
Account account = db.Accounts.Find(accountID); // accountID is in fact lobbyID
if (account != null)
{
var config = context.GetConfig();
if (account.Level < config.MinLevel)
{
res.PrivateMessage = string.Format("Sorry, PlanetWars is competive online campaign for experienced players. You need to be at least level {0} to play here. To increase your level, play more games on other hosts or open multiplayer game and play against computer AI bots. You can still spectate this game, however.", config.MinLevel);
res.ForceSpec = true;
return(res);
}
string owner = "";
if (planet.Account != null)
{
owner = planet.Account.Name;
}
string facRoles = string.Join(",",
account.AccountRolesByAccountID.Where(x => !x.RoleType.IsClanOnly).Select(x => x.RoleType.Name).ToList());
if (!string.IsNullOrEmpty(facRoles))
{
facRoles += " of " + account.Faction.Name + ", ";
}
string clanRoles = string.Join(",",
account.AccountRolesByAccountID.Where(x => x.RoleType.IsClanOnly).Select(x => x.RoleType.Name).ToList());
if (!string.IsNullOrEmpty(clanRoles))
{
clanRoles += " of " + account.Clan.ClanName;
}
res.PublicMessage = string.Format("Greetings {0} {1}{2}, welcome to {3} planet {4} {6}/PlanetWars/Planet/{5}",
account.Name,
facRoles,
clanRoles,
owner,
planet.Name,
planet.PlanetID,
GlobalConst.BaseSiteUrl);
return(res);
}
}
Account acc = db.Accounts.Find(accountID); // accountID is in fact lobbyID
if (acc != null)
{
AutohostConfig config = context.GetConfig();
if (acc.Level < config.MinLevel)
{
res.PrivateMessage = string.Format("Sorry, you need to be at least level {0} to play here. To increase your level, play more games on other hosts or open multiplayer game and play against computer AI bots. You can still spectate this game, however.",
config.MinLevel);
res.ForceSpec = true;
return(res);
}
else if (acc.Level > config.MaxLevel)
{
res.PrivateMessage = string.Format("Sorry, your level must be {0} or lower to play here. Pick on someone your own size! You can still spectate this game, however.",
config.MaxLevel);
res.ForceSpec = true;
return(res);
}
// FIXME: use 1v1 Elo for 1v1
if (acc.EffectiveElo < config.MinElo)
{
res.PrivateMessage = string.Format("Sorry, you need to have an Elo rating of at least {0} to play here. Win games against human opponents to raise your Elo. You can still spectate this game, however.",
config.MinElo);
res.ForceSpec = true;
return(res);
}
else if (acc.EffectiveElo > config.MaxElo)
{
res.PrivateMessage = string.Format("Sorry, your Elo rating must be {0} or lower to play here. Pick on someone your own size! You can still spectate this game, however.",
config.MaxElo);
res.ForceSpec = true;
return(res);
}
}
return(null);
}
static BalanceTeamsResult PerformBalance(BattleContext context,
bool isGameStart,
int?allyCount,
bool?clanWise,
AutohostConfig config,
int playerCount)
{
var res = new BalanceTeamsResult();
var mode = context.GetMode();
using (var db = new ZkDataContext()) {
if (!CheckPlayersMinimumConditions(context, db, config, ref res.Message))
{
res.CanStart = false;
return(res);
}
switch (mode)
{
case AutohostMode.None:
{
if (!isGameStart)
{
res = new Balancer().LegacyBalance(allyCount ?? 2, clanWise == true ? BalanceMode.ClanWise : BalanceMode.Normal, context);
}
}
break;
case AutohostMode.Generic:
{
if (allyCount == null && res.Bots != null && res.Bots.Any())
{
res.Players = context.Players.ToList();
res.Bots = context.Bots.Where(x => x.Owner != context.AutohostName).ToList();
foreach (var p in res.Players)
{
p.AllyID = 0;
}
foreach (var b in res.Bots)
{
b.AllyID = 1;
}
}
else
{
var map = db.Resources.Single(x => x.InternalName == context.Map);
res = new Balancer().LegacyBalance(allyCount ?? map.MapFFAMaxTeams ?? 2,
clanWise == false ? BalanceMode.Normal : BalanceMode.ClanWise,
context);
res.DeleteBots = mode == AutohostMode.Teams;
}
return(res);
}
case AutohostMode.Teams:
{
var map = db.Resources.Single(x => x.InternalName == context.Map);
res = new Balancer().LegacyBalance(allyCount ?? map.MapFFAMaxTeams ?? 2, clanWise == false ? BalanceMode.Normal : BalanceMode.ClanWise, context);
res.DeleteBots = mode == AutohostMode.Teams;
return(res);
}
case AutohostMode.Game1v1:
{
res = new Balancer().LegacyBalance(allyCount ?? 2, clanWise == false ? BalanceMode.Normal : BalanceMode.ClanWise, context);
res.DeleteBots = true;
}
break;
case AutohostMode.GameChickens:
{
res.Players = context.Players.ToList();
res.Bots = context.Bots.Where(x => x.Owner != context.AutohostName).ToList();
foreach (var p in res.Players)
{
p.AllyID = 0;
}
foreach (var b in res.Bots)
{
b.AllyID = 1;
}
if (!res.Bots.Any() && res.Players.Count > 0)
{
res.Message = "Add some bot (computer player) as your enemy. Use button on bottom left. Chicken or CAI is recommended.";
res.CanStart = false;
/*else
* {
* res.Bots.Add(new BotTeam() { AllyID = 1, TeamID = 16, BotName = "default_Chicken", BotAI = "Chicken: Normal", });
* res.Message = "Adding a normal chickens bot for you";
* }*/
}
}
break;
case AutohostMode.GameFFA:
{
var map = db.Resources.Single(x => x.InternalName == context.Map);
if (map.MapFFAMaxTeams != null)
{
res = new Balancer().LegacyBalance(allyCount ?? map.MapFFAMaxTeams.Value,
clanWise == false ? BalanceMode.Normal : BalanceMode.ClanWise,
context);
}
else
{
res = new Balancer().LegacyBalance(allyCount ?? map.MapFFAMaxTeams ?? 8,
clanWise == false ? BalanceMode.Normal : BalanceMode.ClanWise,
context);
}
return(res);
}
case AutohostMode.Planetwars:
return(new Balancer().PlanetwarsBalance(context));
}
return(res);
}
}
public static BalanceTeamsResult BalanceTeams(BattleContext context, bool isGameStart, int?allyCount, bool?clanWise)
{
var config = context.GetConfig();
var playerCount = context.Players.Count(x => !x.IsSpectator);
// game is managed, is bigger than split limit and wants to start -> split into two and issue starts
if (isGameStart && context.GetMode() != AutohostMode.None && config.SplitBiggerThan != null && config.SplitBiggerThan < playerCount)
{
new Thread(() =>
{
try {
SplitAutohost(context, true);
} catch (Exception ex) {
Trace.TraceError("Error when splitting game:{0}", ex);
}
}).Start();
return(new BalanceTeamsResult
{
CanStart = false,
Message =
string.Format("Game too big - splitting into two - max players is {0} here",
config.SplitBiggerThan)
});
}
if (clanWise == null && (config.AutohostMode == AutohostMode.Generic || config.AutohostMode == AutohostMode.Teams))
{
clanWise = true;
}
var res = PerformBalance(context, isGameStart, allyCount, clanWise, config, playerCount);
if (context.GetMode() != AutohostMode.Planetwars) // planetwars skip other checks
{
if (isGameStart)
{
if (playerCount < (config.MinToStart ?? 0))
{
res.Message = string.Format("This host needs at least {0} people to start", config.MinToStart);
res.CanStart = false;
return(res);
}
if (playerCount > (config.MaxToStart ?? 99))
{
res.Message = string.Format("This host can only start with at most {0} players", config.MaxToStart);
res.CanStart = false;
return(res);
}
// dont allow to start alone
if (playerCount <= 1)
{
if (res.DeleteBots)
{
return new BalanceTeamsResult
{
CanStart = false,
Message = "You cannot play alone on this host, wait for players or join another game room and play with bots."
}
}
;
if (!context.Bots.Any())
{
return new BalanceTeamsResult
{
CanStart = false,
Message = "Cannot play alone, you can add bots using button on bottom left."
}
}
;
}
}
}
if (isGameStart)
{
VerifySpecCheaters(context, res);
}
return(res);
}
public static void SplitAutohost(BattleContext context, bool forceStart = false)
{
var tas = Global.Nightwatch.Tas;
try {
//find first one that isnt running and is using same mode (by name)
var splitTo =
tas.ExistingBattles.Values.FirstOrDefault(
x =>
!x.Founder.IsInGame && x.NonSpectatorCount == 0 && x.Founder.Name != context.AutohostName && !x.IsPassworded &&
x.Founder.Name.TrimNumbers() ==
context.AutohostName.TrimNumbers());
if (splitTo != null)
{
// set same map
tas.Say(SayPlace.User, splitTo.Founder.Name, "!map " + context.Map, false);
var db = new ZkDataContext();
var ids = context.Players.Where(y => !y.IsSpectator).Select(x => (int?)x.LobbyID).ToList();
var users = db.Accounts.Where(x => ids.Contains(x.AccountID)).ToList();
var toMove = new List <Account>();
var moveCount = Math.Ceiling(users.Count / 2.0);
/*if (users.Count%2 == 0 && users.Count%4 != 0) {
* // in case of say 18 people, move 10 nubs out, keep 8 pros
* moveCount = users.Count/2 + 1;
* }*/
// split while keeping clan groups together
// note disabled splittinhg by clan - use "x.ClanID ?? x.LobbyID" for clan balance
foreach (var clanGrp in users.GroupBy(x => x.ClanID ?? x.AccountID).OrderBy(x => x.Average(y => y.EffectiveElo)))
{
toMove.AddRange(clanGrp);
if (toMove.Count >= moveCount)
{
break;
}
}
try {
foreach (var m in toMove)
{
tas.ForceJoinBattle(m.Name, splitTo.BattleID);
}
Thread.Sleep(5000);
tas.Say(SayPlace.User, context.AutohostName, "!lock 180", false);
tas.Say(SayPlace.User, splitTo.Founder.Name, "!lock 180", false);
if (context.GetMode() == AutohostMode.Planetwars)
{
tas.Say(SayPlace.User, context.AutohostName, "!map", false);
Thread.Sleep(500);
tas.Say(SayPlace.User, splitTo.Founder.Name, "!map", false);
}
else
{
tas.Say(SayPlace.User, splitTo.Founder.Name, "!map " + context.Map, false);
}
if (forceStart)
{
tas.Say(SayPlace.User, splitTo.Founder.Name, "!balance", false);
tas.Say(SayPlace.User, context.AutohostName, "!balance", false);
tas.Say(SayPlace.User, splitTo.Founder.Name, "!forcestart", false);
tas.Say(SayPlace.User, context.AutohostName, "!forcestart", false);
}
tas.Say(SayPlace.User, context.AutohostName, "!endvote", false);
tas.Say(SayPlace.User, splitTo.Founder.Name, "!endvote", false);
tas.Say(SayPlace.User, context.AutohostName, "!start", false);
tas.Say(SayPlace.User, splitTo.Founder.Name, "!start", false);
} catch (Exception ex) {
Trace.TraceError("Error when splitting: {0}", ex);
}
}
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
}
}
/// <summary>
/// Picks a map and writes a message if applicable
/// </summary>
/// <param name="context">The battle whose map needs selection</param>
/// <param name="pickNew">If false and not in PlanetWars, don't pick a new map</param>
/// <remarks>
/// <para>For Planetwars, picks the map given by the Planetwars matchmaker; else picks a featured map with the appropriate tags</para>
/// <para>For team and chickens games, picks a map of appropriate size based on current player count</para>
/// <para>For FFA, prefer maps that have a number of boxes equal to player count, or at least a number of boxes that is a multiple of player count</para>
/// </remarks>
public static RecommendedMapResult GetRecommendedMap(BattleContext context, bool pickNew)
{
var mode = context.GetMode();
var config = context.GetConfig();
var res = new RecommendedMapResult();
using (var db = new ZkDataContext()) {
if (mode == AutohostMode.Planetwars)
{
var info = Global.PlanetWarsMatchMaker.GetBattleInfo(context.AutohostName);
if (info != null)
{
res.MapName = info.Map;
res.Message = String.Format("Welcome to planet {0} {2}/PlanetWars/Planet/{1} attacked", info.Name, info.PlanetID, GlobalConst.BaseSiteUrl);
}
else
{
res.MapName = context.Map;
}
}
else
{
if (!pickNew)
{
// autohost is not managed or has valid featured map - check disabled
res.MapName = context.Map;
return(res);
}
List <Resource> list = null;
var players = context.Players.Count(x => !x.IsSpectator);
if (config != null && config.SplitBiggerThan != null && players > config.SplitBiggerThan)
{
players = players / 2; // expect the split
}
switch (mode)
{
case AutohostMode.Generic:
case AutohostMode.Teams:
case AutohostMode.None:
var ret = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIsTeams != false && x.MapIsSpecial != true);
if (players > 11)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) > 16 * 16);
}
else if (players > 8)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) > 16 * 16 && (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 24 * 24);
}
else if (players > 5)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 24 * 24 || x.MapIs1v1 == true);
}
else
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 16 * 16 || x.MapIs1v1 == true);
}
list = ret.ToList();
break;
case AutohostMode.Game1v1:
list = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIs1v1 == true && x.MapIsSpecial != true).ToList();
break;
case AutohostMode.GameChickens:
ret = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIsSpecial != true && (x.MapIsChickens == true || x.MapWaterLevel == 1));
if (players > 5)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) > 16 * 16);
}
else if (players > 4)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) > 16 * 16 && (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 24 * 24);
}
else if (players > 2)
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 24 * 24 || x.MapIs1v1 == true);
}
else
{
ret = ret.Where(x => (x.MapHeight * x.MapHeight + x.MapWidth * x.MapWidth) <= 16 * 16 || x.MapIs1v1 == true);
}
list = ret.ToList();
break;
case AutohostMode.GameFFA:
list = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIsFfa == true && x.MapFFAMaxTeams == players).ToList();
if (!list.Any())
{
list = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIsFfa == true && (players % x.MapFFAMaxTeams == 0)).ToList();
}
if (!list.Any())
{
list = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.FeaturedOrder != null && x.MapIsFfa == true).ToList();
}
break;
}
if (list != null)
{
var r = new Random();
if (list.Count > 0)
{
res.MapName = list[r.Next(list.Count)].InternalName;
}
}
}
}
return(res);
}
public static string SubmitSpringBattleResult(BattleContext context,
string password,
BattleResult result,
List <BattlePlayerResult> players,
List <string> extraData)
{
try
{
Account acc = AuthServiceClient.VerifyAccountPlain(context.AutohostName, password);
if (acc == null)
{
throw new Exception("Account name or password not valid");
}
AutohostMode mode = context.GetMode();
var db = new ZkDataContext();
if (extraData == null)
{
extraData = new List <string>();
}
var sb = new SpringBattle
{
HostAccountID = acc.AccountID,
Duration = result.Duration,
EngineGameID = result.EngineBattleID,
MapResourceID = db.Resources.Single(x => x.InternalName == result.Map).ResourceID,
ModResourceID = db.Resources.Single(x => x.InternalName == result.Mod).ResourceID,
HasBots = result.IsBots,
IsMission = result.IsMission,
PlayerCount = players.Count(x => !x.IsSpectator),
StartTime = result.StartTime,
Title = result.Title,
ReplayFileName = result.ReplayName,
EngineVersion = result.EngineVersion,
};
db.SpringBattles.InsertOnSubmit(sb);
foreach (BattlePlayerResult p in players)
{
sb.SpringBattlePlayers.Add(new SpringBattlePlayer
{
AccountID = db.Accounts.First(x => x.AccountID == p.LobbyID).AccountID,
AllyNumber = p.AllyNumber,
CommanderType = p.CommanderType,
IsInVictoryTeam = p.IsVictoryTeam,
IsSpectator = p.IsSpectator,
LoseTime = p.LoseTime
});
}
db.SubmitChanges();
// awards
foreach (string line in extraData.Where(x => x.StartsWith("award")))
{
string[] partsSpace = line.Substring(6).Split(new[] { ' ' }, 3);
string name = partsSpace[0];
string awardType = partsSpace[1];
string awardText = partsSpace[2];
SpringBattlePlayer player = sb.SpringBattlePlayers.FirstOrDefault(x => x.Account.Name == name);
if (player != null)
{
db.AccountBattleAwards.InsertOnSubmit(new AccountBattleAward
{
AccountID = player.AccountID,
SpringBattleID = sb.SpringBattleID,
AwardKey = awardType,
AwardDescription = awardText
});
}
}
var text = new StringBuilder();
bool isPlanetwars = false;
if (mode == AutohostMode.Planetwars && sb.SpringBattlePlayers.Count(x => !x.IsSpectator) >= 2 && sb.Duration >= GlobalConst.MinDurationForPlanetwars)
{
// test that factions are not intermingled (each faction only has one ally number) - if they are it wasnt actually PW balanced
if (
sb.SpringBattlePlayers.Where(x => !x.IsSpectator && x.Account.Faction != null)
.GroupBy(x => x.Account.Faction)
.All(grp => grp.Select(x => x.AllyNumber).Distinct().Count() < 2))
{
isPlanetwars = true;
List <int> winnerTeams =
sb.SpringBattlePlayers.Where(x => x.IsInVictoryTeam && !x.IsSpectator).Select(x => x.AllyNumber).Distinct().ToList();
int?winNum = null;
if (winnerTeams.Count == 1)
{
winNum = winnerTeams[0];
if (winNum > 1)
{
winNum = null;
text.AppendLine("ERROR: Invalid winner");
}
}
PlanetWarsTurnHandler.EndTurn(result.Map, extraData, db, winNum, sb.SpringBattlePlayers.Where(x => !x.IsSpectator).Select(x => x.Account).ToList(), text, sb, sb.SpringBattlePlayers.Where(x => !x.IsSpectator && x.AllyNumber == 0).Select(x => x.Account).ToList());
Global.PlanetWarsMatchMaker.RemoveFromRunningBattles(context.AutohostName);
}
else
{
text.AppendLine("Battle wasn't PlanetWars balanced, it counts as a normal team game only");
}
}
bool noElo = (extraData.FirstOrDefault(x => x.StartsWith("noElo")) != null);
try
{
db.SubmitChanges();
}
catch (System.Data.Linq.DuplicateKeyException ex)
{
Trace.TraceError(ex.ToString());
}
Dictionary <int, int> orgLevels = sb.SpringBattlePlayers.Select(x => x.Account).ToDictionary(x => x.AccountID, x => x.Level);
sb.CalculateAllElo(noElo, isPlanetwars);
foreach (var u in sb.SpringBattlePlayers.Where(x => !x.IsSpectator))
{
u.Account.CheckLevelUp();
}
db.SubmitAndMergeChanges();
try
{
foreach (Account a in sb.SpringBattlePlayers.Where(x => !x.IsSpectator).Select(x => x.Account))
{
Global.Server.PublishAccountUpdate(a);
}
}
catch (Exception ex)
{
Trace.TraceError("error updating extension data: {0}", ex);
}
foreach (Account account in sb.SpringBattlePlayers.Select(x => x.Account))
{
if (account.Level > orgLevels[account.AccountID])
{
try
{
string message =
string.Format("Congratulations {0}! You just leveled up to level {1}. {3}/Users/Detail/{2}",
account.Name,
account.Level,
account.AccountID,
GlobalConst.BaseSiteUrl);
//text.AppendLine(message);
Global.Server.GhostPm(account.Name, message);
}
catch (Exception ex)
{
Trace.TraceError("Error sending level up lobby message: {0}", ex);
}
}
}
text.AppendLine(string.Format("BATTLE DETAILS AND REPLAY ----> {1}/Battles/Detail/{0} <-----", sb.SpringBattleID, GlobalConst.BaseSiteUrl));
/*
* // create debriefing room, join players there and output message
* string channelName = "B" + sb.SpringBattleID;
* var joinplayers = new List<string>();
* joinplayers.AddRange(context.Players.Select(x => x.Name)); // add those who were there at start
* joinplayers.AddRange(sb.SpringBattlePlayers.Select(x => x.Account.Name)); // add those who played
* Battle bat = Global.Server.Battles.Values.FirstOrDefault(x => x.Founder.Name == context.AutohostName); // add those in lobby atm
*
*
* var conf = context.GetConfig();
* if (bat != null && (conf == null || conf.MinToJuggle == null)) // if not qm room do not join those who are in battle
* {
* List<string> inbatPlayers = bat.Users.Keys.ToList();
* joinplayers.RemoveAll(x => inbatPlayers.Contains(x));
* }
* foreach (string jp in joinplayers.Distinct().Where(x => x != context.AutohostName)) tas.ForceJoinChannel(jp, channelName);
* tas.JoinChannel(channelName); // join nightwatch and say it
* tas.Say(SayPlace.Channel, channelName, text.ToString(), true);
* tas.LeaveChannel(channelName);*/
//text.Append(string.Format("Debriefing in #{0} - zk://chat/channel/{0} ", channelName));
return(text.ToString());
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
return(ex.ToString());
}
}
static bool listOnlyThatLevelsModules = false; // may cause bugs
/// <summary>
/// Sets up all the things that Springie needs to know for the battle: how to balance, who to get extra commanders, what PlanetWars structures to create, etc.
/// </summary>
public static SpringBattleStartSetup GetSpringBattleStartSetup(BattleContext context)
{
try {
AutohostMode mode = context.GetMode();
var ret = new SpringBattleStartSetup();
if (mode == AutohostMode.Planetwars)
{
ret.BalanceTeamsResult = Balancer.BalanceTeams(context, true, null, null);
context.Players = ret.BalanceTeamsResult.Players;
}
var commanderTypes = new LuaTable();
var db = new ZkDataContext();
// calculate to whom to send extra comms
var accountIDsWithExtraComms = new List <int>();
if (mode == AutohostMode.Planetwars || mode == AutohostMode.Generic || mode == AutohostMode.GameFFA ||
mode == AutohostMode.Teams)
{
IOrderedEnumerable <IGrouping <int, PlayerTeam> > groupedByTeam =
context.Players.Where(x => !x.IsSpectator).GroupBy(x => x.AllyID).OrderByDescending(x => x.Count());
IGrouping <int, PlayerTeam> biggest = groupedByTeam.FirstOrDefault();
if (biggest != null)
{
foreach (var other in groupedByTeam.Skip(1))
{
int cnt = biggest.Count() - other.Count();
if (cnt > 0)
{
foreach (Account a in
other.Select(x => db.Accounts.First(y => y.AccountID == x.LobbyID)).OrderByDescending(x => x.Elo * x.EloWeight).Take(
cnt))
{
accountIDsWithExtraComms.Add(a.AccountID);
}
}
}
}
}
bool is1v1 = context.Players.Where(x => !x.IsSpectator).ToList().Count == 2 && context.Bots.Count == 0;
// write Planetwars details to modoptions (for widget)
Faction attacker = null;
Faction defender = null;
Planet planet = null;
if (mode == AutohostMode.Planetwars)
{
planet = db.Galaxies.First(x => x.IsDefault).Planets.First(x => x.Resource.InternalName == context.Map);
attacker =
context.Players.Where(x => x.AllyID == 0 && !x.IsSpectator)
.Select(x => db.Accounts.First(y => y.AccountID == x.LobbyID))
.Where(x => x.Faction != null)
.Select(x => x.Faction)
.First();
defender = planet.Faction;
if (attacker == defender)
{
defender = null;
}
ret.ModOptions.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "attackingFaction", Value = attacker.Shortcut
});
if (defender != null)
{
ret.ModOptions.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "defendingFaction", Value = defender.Shortcut
});
}
ret.ModOptions.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "planet", Value = planet.Name
});
}
// write player custom keys (level, elo, is muted, etc.)
foreach (PlayerTeam p in context.Players)
{
Account user = db.Accounts.Find(p.LobbyID);
if (user != null)
{
var userParams = new List <SpringBattleStartSetup.ScriptKeyValuePair>();
ret.UserParameters.Add(new SpringBattleStartSetup.UserCustomParameters {
LobbyID = p.LobbyID, Parameters = userParams
});
bool userBanMuted = user.PunishmentsByAccountID.Any(x => !x.IsExpired && x.BanMute);
if (userBanMuted)
{
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "muted", Value = "1"
});
}
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair
{
Key = "faction", Value = user.Faction != null ? user.Faction.Shortcut : ""
});
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair
{
Key = "clan", Value = user.Clan != null ? user.Clan.Shortcut : ""
});
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "level", Value = user.Level.ToString()
});
double elo = mode == AutohostMode.Planetwars ? user.EffectivePwElo : (is1v1 ? user.Effective1v1Elo : user.EffectiveElo);
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "elo", Value = Math.Round(elo).ToString()
}); // elo for ingame is just ordering for auto /take
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "avatar", Value = user.Avatar
});
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "admin", Value = (user.IsZeroKAdmin ? "1" : "0")
});
if (!p.IsSpectator)
{
// set valid PW structure attackers
if (mode == AutohostMode.Planetwars)
{
bool allied = user.Faction != null && defender != null && user.Faction != defender &&
defender.HasTreatyRight(user.Faction, x => x.EffectPreventIngamePwStructureDestruction == true, planet);
if (!allied && user.Faction != null && (user.Faction == attacker || user.Faction == defender))
{
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "canAttackPwStructures", Value = "1"
});
}
}
var pu = new LuaTable();
bool userUnlocksBanned = user.PunishmentsByAccountID.Any(x => !x.IsExpired && x.BanUnlocks);
bool userCommandersBanned = user.PunishmentsByAccountID.Any(x => !x.IsExpired && x.BanCommanders);
if (!userUnlocksBanned)
{
if (mode != AutohostMode.Planetwars || user.Faction == null)
{
foreach (Unlock unlock in user.AccountUnlocks.Select(x => x.Unlock))
{
pu.Add(unlock.Code);
}
}
else
{
foreach (Unlock unlock in
user.AccountUnlocks.Select(x => x.Unlock).Union(user.Faction.GetFactionUnlocks().Select(x => x.Unlock)).Where(x => x.UnlockType == UnlockTypes.Unit))
{
pu.Add(unlock.Code);
}
}
}
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "unlocks", Value = pu.ToBase64String()
});
if (accountIDsWithExtraComms.Contains(user.AccountID))
{
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "extracomm", Value = "1"
});
}
var pc = new LuaTable();
if (!userCommandersBanned)
{
// set up commander data
foreach (Commander c in user.Commanders.Where(x => x.Unlock != null && x.ProfileNumber <= GlobalConst.CommanderProfileCount))
{
try {
if (string.IsNullOrEmpty(c.Name) || c.Name.Any(x => x == '"'))
{
c.Name = c.CommanderID.ToString();
}
LuaTable morphTable = new LuaTable();
pc["[\"" + c.Name + "\"]"] = morphTable;
// process decoration icons
LuaTable decorations = new LuaTable();
foreach (Unlock d in
c.CommanderDecorations.Where(x => x.Unlock != null).OrderBy(
x => x.SlotID).Select(x => x.Unlock))
{
CommanderDecorationIcon iconData = db.CommanderDecorationIcons.FirstOrDefault(x => x.DecorationUnlockID == d.UnlockID);
if (iconData != null)
{
string iconName = null, iconPosition = null;
// FIXME: handle avatars and preset/custom icons
if (iconData.IconType == (int)DecorationIconTypes.Faction)
{
iconName = user.Faction != null ? user.Faction.Shortcut : null;
}
else if (iconData.IconType == (int)DecorationIconTypes.Clan)
{
iconName = user.Clan != null ? user.Clan.Shortcut : null;
}
if (iconName != null)
{
iconPosition = CommanderDecoration.GetIconPosition(d);
LuaTable entry = new LuaTable();
entry.Add("image", iconName);
decorations.Add("icon_" + iconPosition.ToLower(), entry);
}
}
else
{
decorations.Add(d.Code);
}
}
string prevKey = null;
for (int i = 0; i <= GlobalConst.NumCommanderLevels; i++)
{
string key = string.Format("c{0}_{1}_{2}", user.AccountID, c.ProfileNumber, i);
morphTable.Add(key); // TODO: maybe don't specify morph series in player data, only starting unit
var comdef = new LuaTable();
commanderTypes[key] = comdef;
comdef["chassis"] = c.Unlock.Code + i;
var modules = new LuaTable();
comdef["modules"] = modules;
comdef["decorations"] = decorations;
comdef["name"] = c.Name.Substring(0, Math.Min(25, c.Name.Length)) + " level " + i;
//if (i < GlobalConst.NumCommanderLevels)
//{
// comdef["next"] = string.Format("c{0}_{1}_{2}", user.AccountID, c.ProfileNumber, i+1);
//}
//comdef["owner"] = user.Name;
if (i > 0)
{
comdef["cost"] = c.GetTotalMorphLevelCost(i);
if (listOnlyThatLevelsModules)
{
if (prevKey != null)
{
comdef["prev"] = prevKey;
}
prevKey = key;
foreach (Unlock m in
c.CommanderModules.Where(x => x.CommanderSlot.MorphLevel == i && x.Unlock != null).OrderBy(
x => x.Unlock.UnlockType).ThenBy(x => x.SlotID).Select(x => x.Unlock))
{
modules.Add(m.Code);
}
}
else
{
foreach (Unlock m in
c.CommanderModules.Where(x => x.CommanderSlot.MorphLevel <= i && x.Unlock != null).OrderBy(
x => x.Unlock.UnlockType).ThenBy(x => x.SlotID).Select(x => x.Unlock))
{
modules.Add(m.Code);
}
}
}
}
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
throw new ApplicationException(
string.Format("Error processing commander: {0} - {1} of player {2} - {3}",
c.CommanderID,
c.Name,
user.AccountID,
user.Name),
ex);
}
}
}
else
{
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "jokecomm", Value = "1"
});
}
userParams.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "commanders", Value = pc.ToBase64String()
});
}
}
}
ret.ModOptions.Add(new SpringBattleStartSetup.ScriptKeyValuePair {
Key = "commanderTypes", Value = commanderTypes.ToBase64String()
});
// set PW structures
if (mode == AutohostMode.Planetwars)
{
string owner = planet.Faction != null ? planet.Faction.Shortcut : "";
var pwStructures = new LuaTable();
foreach (PlanetStructure s in planet.PlanetStructures.Where(x => x.StructureType != null && !string.IsNullOrEmpty(x.StructureType.IngameUnitName)))
{
pwStructures.Add("s" + s.StructureTypeID,
new LuaTable
{
{ "unitname", s.StructureType.IngameUnitName },
//{ "isDestroyed", s.IsDestroyed ? true : false },
{ "name", string.Format("{0} {1} ({2})", owner, s.StructureType.Name, s.Account != null ? s.Account.Name:"unowned") },
{ "description", s.StructureType.Description }
});
}
ret.ModOptions.Add(new SpringBattleStartSetup.ScriptKeyValuePair
{
Key = "planetwarsStructures", Value = pwStructures.ToBase64String()
});
}
return(ret);
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
throw;
}
}