static bool Prefix(UIElement __instance, ref Vector2 pos)
{
if (MPModPrivateData.MatchMode == ExtMatchMode.RACE)
{
Race.DrawMpMiniScoreboard(ref pos, __instance);
return(false);
}
if (NetworkMatch.GetMode() == MatchMode.ANARCHY || MPTeams.NetworkMatchTeamCount == 2)
{
return(true);
}
int match_time_remaining = NetworkMatch.m_match_time_remaining;
int match_time = (int)NetworkMatch.m_match_elapsed_seconds;
pos.y -= 15f;
__instance.DrawDigitsTime(pos + Vector2.right * 95f, (float)match_time_remaining, 0.45f,
(match_time <= 10 || match_time_remaining >= 10) ? UIManager.m_col_ui2 : UIManager.m_col_em5,
__instance.m_alpha, false);
pos.y -= 3f;
MpTeam myTeam = GameManager.m_local_player.m_mp_team;
foreach (var team in MPTeams.TeamsByScore)
{
pos.y += 28f;
int score = NetworkMatch.GetTeamScore(team);
MPTeams.DrawTeamScoreSmall(__instance, pos, team, score, 98f, team == myTeam);
}
pos.y += 6f;
return(false);
}
static bool Prefix(UIElement __instance)
{
if (!MenuManager.m_mp_lan_match)
{
return(true);
}
var uie = __instance;
uie.DrawMenuBG();
Vector2 position = uie.m_position;
position.y = UIManager.UI_TOP + 75f;
uie.DrawHeaderLarge(position, Loc.LS("SCOREBOARD"));
position.y += 42f;
MatchMode mode = NetworkMatch.GetMode();
string s = NetworkMatch.GetModeString(mode) + " - " + GameplayManager.Level.DisplayName;
uie.DrawSubHeader(s, position);
position.y += 20f;
uie.DrawMenuSeparator(position);
position.y += 20f;
position.x = 0f;
position.y += 10f;
_UIElement_DrawMpScoreboardRaw_Method.Invoke(uie, new object[] { position });
position.y = UIManager.UI_BOTTOM - 30f;
uie.SelectAndDrawItem(Loc.LS("MULTIPLAYER MENU"), position, 100, false);
position.y -= 62f;
uie.SelectAndDrawItem(Loc.LS(NetworkMatch.m_match_req_password == "" ? "CREATE AGAIN" : "JOIN AGAIN"), position, 2, false);
return(false);
}
private static bool Prefix(MpTeam team, ref LevelData.SpawnPoint __result)
{
// Check mode, bail if not Anarchy or Team Anarchy.
var mode = NetworkMatch.GetMode();
if (mode != MatchMode.ANARCHY && mode != MatchMode.TEAM_ANARCHY)
{
return(true);
}
var respawnPointCandidates = GetRespawnPointCandidates(team);
if (respawnPointCandidates.Count == 0)
{
__result = (LevelData.SpawnPoint)_NetworkSpawnPoints_GetRandomRespawnPointWithoutFiltering_Method.Invoke(null, new object[] { });
}
else if (NetworkManager.m_Players.Count == 0)
{
__result = respawnPointCandidates[UnityEngine.Random.Range(0, respawnPointCandidates.Count)];
}
else
{
var scores = GetRespawnPointScores(team, respawnPointCandidates, true);
__result = scores.OrderByDescending(s => s.Value).First().Key;
}
lastRespawn[__result] = DateTime.Now;
return(false);
}
public static JObject GetGameData()
{
return(JObject.FromObject(new
{
creator = NetworkMatch.m_name.Split('\0')[0],
forceModifier1 = NetworkMatch.m_force_modifier1 == 4 ? "OFF" : Player.GetMpModifierName(NetworkMatch.m_force_modifier1, true),
forceModifier2 = NetworkMatch.m_force_modifier2 == 4 ? "OFF" : Player.GetMpModifierName(NetworkMatch.m_force_modifier2, false),
forceMissile1 = NetworkMatch.m_force_m1.ToString()?.Replace('_', ' '),
forceMissile2 = NetworkMatch.m_force_m2 == MissileType.NUM ? "NONE" : NetworkMatch.m_force_m2.ToString()?.Replace('_', ' '),
forceWeapon1 = NetworkMatch.m_force_w1.ToString(),
forceWeapon2 = NetworkMatch.m_force_w2 == WeaponType.NUM ? "NONE" : NetworkMatch.m_force_w2.ToString(),
forceLoadout = MenuManager.GetToggleSetting(NetworkMatch.m_force_loadout),
powerupFilterBitmask = NetworkMatch.m_powerup_filter_bitmask,
powerupBigSpawn = GetPowerupBigSpawnString(NetworkMatch.m_powerup_big_spawn),
powerupInitial = GetPowerupInitialString(NetworkMatch.m_powerup_initial),
turnSpeedLimit = GetTurnSpeedLimitString(NetworkMatch.m_turn_speed_limit),
powerupSpawn = GetPowerupSpawnString(NetworkMatch.m_powerup_spawn),
friendlyFire = NetworkMatch.m_team_damage,
matchMode = GetMatchModeString(NetworkMatch.GetMode()),
maxPlayers = NetworkMatch.GetMaxPlayersForMatch(),
showEnemyNames = NetworkMatch.m_show_enemy_names.ToString()?.Replace('_', ' '),
timeLimit = NetworkMatch.m_match_time_limit_seconds,
scoreLimit = NetworkMatch.m_match_score_limit,
respawnTimeSeconds = NetworkMatch.m_respawn_time_seconds,
respawnShieldTimeSeconds = NetworkMatch.m_respawn_shield_seconds,
level = GetCurrentLevelName(),
joinInProgress = MPJoinInProgress.NetworkMatchEnabled,
rearViewAllowed = RearView.MPNetworkMatchEnabled,
teamCount = MPTeams.NetworkMatchTeamCount,
players = NetworkMatch.m_players.Values.Where(x => !x.m_name.StartsWith("OBSERVER")).Select(x => x.m_name),
hasPassword = MPModPrivateData.HasPassword,
matchNotes = MPModPrivateData.MatchNotes
//Overload.NetworkManager.m_Players.Where(x => !x.m_spectator).Select(x => x.m_mp_name)
}));
}
private static void Prefix()
{
if (NetworkMatch.GetMode() == MatchMode.MONSTERBALL)
{
UnityEngine.Object.DestroyObject(NetworkMatch.m_monsterball);
}
}
private static void Postfix()
{
var isMonsterball = NetworkMatch.GetMode() == MatchMode.MONSTERBALL;
Physics.IgnoreLayerCollision(31, (int)Overload.UnityObjectLayers.ITEMS, isMonsterball);
Physics.IgnoreLayerCollision(31, (int)Overload.UnityObjectLayers.ITEM_LEVEL, isMonsterball);
}
public static void MaybeSubtractPointForTeam(MpTeam team)
{
if (NetworkMatch.GetMode() != MatchMode.MONSTERBALL && NetworkMatch.GetMode() != CTF.MatchModeCTF)
{
NetworkMatch.SubtractPointForTeam(team);
}
}
private static bool Prefix(Projectile __instance, Collider other, float ___m_strength)
{
if (!other || other.isTrigger)
{
return(true);
}
var proj = __instance;
if (NetworkMatch.GetMode() == MatchMode.MONSTERBALL && other.gameObject.layer == 31)
{
if (proj.m_owner_player)
{
MonsterballAddon.SetPlayer(proj.m_owner_player);
}
if (proj.m_type == ProjPrefab.proj_thunderbolt)
{
Vector3 vector = other.transform.position - proj.transform.position;
other.attachedRigidbody.AddForce(vector.normalized * 340f * ___m_strength + vector.normalized * 60f, ForceMode.Impulse);
ParticleElement particleElement = ParticleManager.psm[3].StartParticle((int)proj.m_death_particle_default, proj.c_transform.localPosition, proj.c_transform.localRotation, null, null, false);
particleElement.SetExplosionOwner(proj.m_owner);
particleElement.SetParticleScaleAndSimSpeed(1f + ___m_strength * 0.25f, 1f - ___m_strength * 0.15f);
GameManager.m_audio.PlayCuePos(255, proj.c_transform.localPosition, 0.7f, UnityEngine.Random.Range(-0.15f, 0.15f), 0f, 1f);
return(false);
}
}
return(true);
}
private static void Postfix()
{
if (!GameplayManager.IsDedicatedServer())
{
return;
}
Debug.Log("MPTweaksLoadScene");
RobotManager.ReadMultiplayerModeFile();
Debug.Log("MPTweaks loaded mode file");
var tweaks = new Dictionary <string, string>()
{
};
if (NetworkMatch.GetMode() == CTF.MatchModeCTF)
{
tweaks.Add("ctf.returntimer", CTF.ReturnTimeAmountDefault.ToStringInvariantCulture());
}
if (!MPCustomModeFile.PickupCheck)
{
tweaks.Add("item.pickupcheck", Boolean.FalseString);
}
tweaks.Add("nocompress.reliable_timestamps", Boolean.TrueString);
if (tweaks.Any())
{
Debug.LogFormat("MPTweaks: sending tweaks {0}", tweaks.Join());
MPTweaks.Set(tweaks);
MPTweaks.Send();
}
}
private static void SendMatchState(int connectionId)
{
if (NetworkMatch.IsTeamMode(NetworkMatch.GetMode()))
{
foreach (var team in MPTeams.ActiveTeams)
{
NetworkServer.SendToClient(connectionId, CustomMsgType.SetScoreForTeam, new ScoreForTeamMessage
{
team = (int)team,
score = NetworkMatch.m_team_scores[(int)team]
});
}
}
//if (!MPTweaks.ClientHasMod(connectionId))
// return;
var n = Overload.NetworkManager.m_Players.Count;
var msg = new MatchStateMessage()
{
m_match_elapsed_seconds = NetworkMatch.m_match_elapsed_seconds,
m_player_states = new PlayerMatchState[n]
};
int i = 0;
foreach (var player in Overload.NetworkManager.m_Players)
{
msg.m_player_states[i++] = new PlayerMatchState()
{
m_net_id = player.netId, m_kills = player.m_kills, m_deaths = player.m_deaths, m_assists = player.m_assists
}
}
;
NetworkServer.SendToClient(connectionId, ModCustomMsg.MsgSetMatchState, msg);
}
private static bool Prefix(ref int __result)
{
if (NetworkMatch.GetMode() != CTF.MatchModeCTF)
{
return(true);
}
__result = MPTeams.HighestScore();
return(false);
}
static bool Prefix(ref int __result)
{
if (NetworkMatch.GetMode() == MatchMode.ANARCHY || MPTeams.NetworkMatchTeamCount == 2)
{
return(true);
}
__result = MPTeams.HighestScore();
return(false);
}
static bool Prefix(UIElement __instance, ref Vector2 pos)
{
if (!GameplayManager.IsMultiplayerActive || NetworkMatch.GetMode() == MatchMode.ANARCHY || MPTeams.NetworkMatchTeamCount == 2)
{
return(true);
}
var uie = __instance;
pos.x -= 4f;
pos.y -= 5f;
Vector2 temp_pos;
temp_pos.y = pos.y;
temp_pos.x = pos.x - 100f;
uie.DrawStringSmall(NetworkMatch.GetModeString(MatchMode.NUM), temp_pos, 0.4f, StringOffset.LEFT, UIManager.m_col_ub0, 1f, 130f);
temp_pos.x = pos.x + 95f;
int match_time_remaining = NetworkMatch.m_match_time_remaining;
int num3 = (int)NetworkMatch.m_match_elapsed_seconds;
uie.DrawDigitsTime(temp_pos, (float)match_time_remaining, 0.45f,
(num3 <= 10 || match_time_remaining >= 10) ? UIManager.m_col_ui2 : UIManager.m_col_em5, uie.m_alpha, false);
temp_pos.x = pos.x - 100f;
temp_pos.y = temp_pos.y - 20f;
uie.DrawPing(temp_pos);
pos.y += 24f;
MpTeam myTeam = GameManager.m_local_player.m_mp_team;
foreach (var team in MPTeams.TeamsByScore)
{
MPTeams.DrawTeamScoreSmall(__instance, pos, team, NetworkMatch.GetTeamScore(team), 98f, team == myTeam);
pos.y += 28f;
}
pos.y += 6f - 28f;
pos.y += 22f;
pos.x += 100f;
uie.DrawRecentKillsMP(pos);
if (GameManager.m_player_ship.m_wheel_select_state == WheelSelectState.QUICK_CHAT)
{
pos.y = UIManager.UI_TOP + 128f;
pos.x = -448f;
uie.DrawQuickChatWheel(pos);
}
else
{
pos.y = UIManager.UI_TOP + 60f;
pos.x = UIManager.UI_LEFT + 5f;
uie.DrawQuickChatMP(pos);
}
return(false);
}
static bool Prefix(UIElement __instance, Vector2 pos)
{
if (!MenuManager.mp_display_player_list ||
((!NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) || MPTeams.NetworkMatchTeamCount == 2))) // &&
//NetworkMatch.GetMaxPlayersForMatch() <= 8))
{
return(true);
}
MPTeams.DrawLobby(__instance, pos);
return(false);
}
static bool Prefix(UIElement __instance, ref Vector2 pos)
{
var mode = NetworkMatch.GetMode();
var fitSingle = MPTeams.NetworkMatchTeamCount == 2 && NetworkMatch.m_players.Count <= 8;
if (MPModPrivateData.MatchMode == ExtMatchMode.RACE)
{
return(true);
}
if (mode == MatchMode.ANARCHY || ((mode == MatchMode.TEAM_ANARCHY || mode == MatchMode.MONSTERBALL) && fitSingle))
{
return(true);
}
float colReduce = fitSingle ? 0 : 50f;
float col1 = fitSingle ? -330f : -250f;
float col2 = 100f - colReduce;
float col3 = 190f - colReduce;
float col4 = 280f - colReduce;
float col5 = 350f - colReduce;
MpTeam myTeam = GameManager.m_local_player.m_mp_team;
int col = 0;
float x = pos.x;
float y = pos.y;
float[] ys = new float[2] {
pos.y, pos.y
};
foreach (var team in MPTeams.TeamsByScore)
{
pos.x = x + (fitSingle ? 0 : col == 0 ? -325f : 325f);
pos.y = ys[col];
MPTeams.DrawTeamScore(__instance, pos, team, NetworkMatch.GetTeamScore(team), col5, team == myTeam);
pos.y += 35f;
if (ys[col] == y || fitSingle) // only draw header for first team in column
{
MPTeams.DrawScoreHeader(__instance, pos, col1, col2, col3, col4, col5, false);
pos.y += 15f;
__instance.DrawVariableSeparator(pos, 350f);
pos.y += 20f;
}
int num = MPTeams.DrawScoresForTeam(__instance, team, pos, col1, col2, col3, col4, col5);
pos.y += (float)num * 25f + 35f;
ys[col] = pos.y;
if (!fitSingle)
{
col = 1 - col;
}
}
pos.y = Mathf.Max(ys[0], ys[1]);
return(false);
}
static bool Prefix(UIElement __instance)
{
if (!NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) || (MPTeams.NetworkMatchTeamCount == 2 && NetworkMatch.m_players.Count <= 8))
{
return(true);
}
if (GameManager.m_local_player.m_hitpoints < 0f)
{
MPTeams.DrawPostgame(__instance);
}
return(false);
}
public static bool Prefix()
{
if (
NetworkMatch.m_match_elapsed_seconds > NetworkMatch.m_match_time_limit_seconds &&
(NetworkMatch.GetMode() == MatchMode.MONSTERBALL || NetworkMatch.GetMode() == CTF.MatchModeCTF) &&
MPSuddenDeath.SuddenDeathMatchEnabled &&
NetworkMatch.m_team_scores[(int)MpTeam.TEAM0] == NetworkMatch.m_team_scores[(int)MpTeam.TEAM1]
)
{
if (!MPSuddenDeath.InOvertime)
{
Debug.Log("Sudden Death!");
MPSuddenDeath.InOvertime = true;
MPHUDMessage.SendToAll("Sudden Death!");
}
return(false);
}
return(true);
}
private static void Postfix()
{
if (!GameplayManager.IsDedicatedServer())
{
return;
}
Debug.Log("MPTweaksLoadScene");
RobotManager.ReadMultiplayerModeFile();
Debug.Log("MPTweaks loaded mode file");
bool nobodySupportsProj = !NetworkMatch.m_players.Keys.Any(connId =>
MPTweaks.ClientInfos.TryGetValue(connId, out var clientInfo) &&
clientInfo.SupportsTweaks.Contains("proj"));
var tweaks = new Dictionary <string, string>()
{
};
if (nobodySupportsProj) // use stock hunters for all stock client match
{
Debug.LogFormat("MPTweaks: not tweaking hunter: unsupported by all clients");
}
else
{
tweaks.Add("proj.missile_hunter.m_init_speed_min", "17.5");
}
if (NetworkMatch.GetMode() == CTF.MatchModeCTF)
{
tweaks.Add("ctf.returntimer", CTF.ReturnTimeAmountDefault.ToStringInvariantCulture());
}
if (!MPCustomModeFile.PickupCheck)
{
tweaks.Add("item.pickupcheck", Boolean.FalseString);
}
if (tweaks.Any())
{
Debug.LogFormat("MPTweaks: sending tweaks {0}", tweaks.Join());
MPTweaks.Set(tweaks);
MPTweaks.Send();
}
}
static bool Prefix(ref MpTeam __result, int connection_id)
{
if (!NetworkMatch.IsTeamMode(NetworkMatch.GetMode()))
{
__result = MpTeam.ANARCHY;
return(false);
}
if (NetworkMatch.GetMode() == MatchMode.ANARCHY || (MPTeams.NetworkMatchTeamCount == 2 &&
!MPJoinInProgress.NetworkMatchEnabled)) // use this simple balancing method for JIP to hopefully solve JIP team imbalances
{
return(true);
}
if (NetworkMatch.m_players.TryGetValue(connection_id, out var connPlayer)) // keep team if player already exists (when called from OnUpdateGameSession)
{
__result = connPlayer.m_team;
return(false);
}
int[] team_counts = new int[(int)MPTeams.MPTEAM_NUM];
foreach (var player in NetworkMatch.m_players.Values)
{
team_counts[(int)player.m_team]++;
}
MpTeam min_team = MpTeam.TEAM0;
foreach (var team in MPTeams.Teams)
{
if (team_counts[(int)team] < team_counts[(int)min_team] ||
(team_counts[(int)team] == team_counts[(int)min_team] &&
NetworkMatch.m_team_scores[(int)team] < NetworkMatch.m_team_scores[(int)min_team]))
{
min_team = team;
}
}
__result = min_team;
Debug.LogFormat("GetTeamForPlayer: result {0}, conn {1}, counts {2}, scores {3}", (int)min_team, connection_id,
team_counts.Join(), NetworkMatch.m_team_scores.Join());
return(false);
}
static bool Prefix(Player player, Vector2 offset)
{
if (NetworkMatch.GetMode() == MatchMode.ANARCHY && isActive)
{
Color c = GetPlayerColor(player);
c.a = player.m_mp_data.vis_fade;
offset.y -= 2.2f;
UIManager.DrawStringAlignCenter(player.m_mp_name, offset, player_name_scale, c, -1f);
if (UIManager.ShouldDrawPlatformId(player.m_mp_platform))
{
Vector2 position = offset;
position.x += UIManager.GetStringWidth(player.m_mp_name, 0.8f, 0, -1) * 0.5f + 1f;
UIManager.DrawSpriteUI(position, 0.011f, 0.011f, c, player.m_mp_data.vis_fade, (int)(226 + player.m_mp_platform));
}
if (player.m_mp_status != string.Empty)
{
offset.y -= 2.2f;
UIManager.DrawStringAlignCenter("[" + Loc.LS(player.m_mp_status) + "]", offset, 0.8f, c, -1f);
}
return(false);
}
return(true);
}
private static void OnJIPJustJoinedMessage(NetworkMessage rawMsg)
{
if (Server.IsActive())
{
return;
}
var msg = rawMsg.ReadMessage <JIPJustJoinedMessage>();
var player = Overload.NetworkManager.m_Players.Find(p => p.netId == msg.playerId);
if (!player)
{
return;
}
MPJoinInProgress.SetReady(player, msg.ready);
// Check if we should be using 1v1 scoring
if (NetworkMatch.GetMode() == MatchMode.ANARCHY)
{
NetworkMatch.m_head_to_head = (NetworkMatch.m_players.Count(x => !x.Value.m_name.StartsWith("OBSERVER")) < 3);
}
}
public static bool MatchNeedsMod()
{
return((int)NetworkMatch.GetMode() > (int)MatchMode.TEAM_ANARCHY ||
(NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) && MPTeams.NetworkMatchTeamCount > 2));
}
static void DrawDeathSummary(UIElement uie)
{
Vector2 pos;
if (MPDeathReview.stickyDeathReview)
{
pos = new Vector2(UIManager.UI_LEFT + 160f, UIManager.UI_TOP + 250f);
}
else
{
pos = new Vector2((UIManager.UI_LEFT + UIManager.UI_RIGHT) / 2f, UIManager.UI_TOP + 180f);
}
var killer = Overload.NetworkManager.m_Players.FirstOrDefault(x => x.netId == MPDeathReview.lastDeathReview.m_killer_id);
var assister = Overload.NetworkManager.m_Players.FirstOrDefault(x => x.netId == MPDeathReview.lastDeathReview.m_assister_id);
var c = UIManager.m_col_red;
var alpha_mod = 1f;
var w = 120f;
if ((!MPDeathReview.stickyDeathReview || MPDeathReview.showDeathReviewDetails) && killer && killer != GameManager.m_local_player)
{
UIManager.DrawQuadBarHorizontal(pos - Vector2.down * 24f, 103f, 36f, 36f, 0.3f * UIManager.m_col_black, 199);
c = NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) ? MPTeams.TeamColor(killer.m_mp_team, 0) : UIManager.m_col_red;
var damages = MPDeathReview.lastDeathReview.players.FirstOrDefault(x => x.Key == killer.netId).Value;
DrawHeader(uie, pos, $"KILLER: {killer.m_mp_name}", $"[{(damages.Sum(x => x.damage) / MPDeathReview.lastDeathReview.players.SelectMany(x => x.Value).Sum(x => x.damage)):P0}]", w, c, 0.35f);
pos.y += 32f;
DrawDamageSummary(uie, pos, c, 0.45f, alpha_mod, damages);
pos.y += 40f;
}
if (MPDeathReview.showDeathReviewDetails && assister != null && assister.netId != killer.netId)
{
UIManager.DrawQuadBarHorizontal(pos - Vector2.down * 24f, 103f, 36f, 36f, 0.3f * UIManager.m_col_black, 199);
c = NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) ? MPTeams.TeamColor(assister.m_mp_team, 0) : UIManager.m_col_white;
var damages = MPDeathReview.lastDeathReview.players.FirstOrDefault(x => x.Key == assister.netId).Value;
DrawHeader(uie, pos, $"ASSIST: {assister.m_mp_name}", $"[{(damages.Sum(x => x.damage) / MPDeathReview.lastDeathReview.players.SelectMany(x => x.Value).Sum(x => x.damage)):P0}]", w, c, 0.35f);
pos.y += 32f;
DrawDamageSummary(uie, pos, c, 0.45f, alpha_mod, damages);
pos.y += 40f;
}
// Other enemy damage not contributed by killer/assister
var otherIds = Overload.NetworkManager.m_Players.Where(x => x.netId != GameManager.m_local_player.netId && x != killer && x != assister && (x.m_mp_team == MpTeam.ANARCHY || x.m_mp_team != GameManager.m_local_player.m_mp_team)).Select(x => x.netId);
if (MPDeathReview.showDeathReviewDetails && MPDeathReview.lastDeathReview.players.Any(x => otherIds.Contains(x.Key)))
{
UIManager.DrawQuadBarHorizontal(pos - Vector2.down * 24f, 103f, 36f, 36f, 0.3f * UIManager.m_col_black, 199);
var otherDamages = MPDeathReview.lastDeathReview.players.Where(x => otherIds.Contains(x.Key)).SelectMany(x => x.Value);
c = NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) ? MPTeams.TeamColor(GameManager.m_local_player.m_mp_team, 0) : UIManager.m_col_white;
DrawHeader(uie, pos, "OTHER", $"[{(otherDamages.Sum(x => x.damage) / MPDeathReview.lastDeathReview.players.SelectMany(x => x.Value).Sum(x => x.damage)):P0}]", w, c, 0.35f);
pos.y += 32f;
DrawDamageSummary(uie, pos, c, 0.45f, alpha_mod, otherDamages);
pos.y += 40f;
}
// Self and misc damage
var selfIds = Overload.NetworkManager.m_Players.Where(x => x.netId == GameManager.m_local_player.netId || (NetworkMatch.GetMode() == MatchMode.TEAM_ANARCHY && x.m_mp_team == GameManager.m_local_player.m_mp_team)).Select(x => x.netId);
if ((MPDeathReview.showDeathReviewDetails || killer == GameManager.m_local_player && !MPDeathReview.stickyDeathReview) && MPDeathReview.lastDeathReview.players.Any(x => selfIds.Contains(x.Key)))
{
UIManager.DrawQuadBarHorizontal(pos - Vector2.down * 24f, 103f, 36f, 36f, 0.3f * UIManager.m_col_black, 199);
var selfDamages = MPDeathReview.lastDeathReview.players.Where(x => selfIds.Contains(x.Key)).SelectMany(x => x.Value);
c = NetworkMatch.IsTeamMode(NetworkMatch.GetMode()) ? MPTeams.TeamColor(GameManager.m_local_player.m_mp_team, 0) : UIManager.m_col_white;
DrawHeader(uie, pos, "SELF/MISC", $"[{(selfDamages.Sum(x => x.damage) / MPDeathReview.lastDeathReview.players.SelectMany(x => x.Value).Sum(x => x.damage)):P0}]", w, c, 0.35f);
pos.y += 32f;
DrawDamageSummary(uie, pos, c, 0.45f, alpha_mod, selfDamages);
pos.y += 40f;
}
if (MPDeathReview.stickyDeathReview || (!MPDeathReview.showDeathReviewDetails && ((assister != null && assister.netId != killer.netId) || MPDeathReview.lastDeathReview.players.Any(x => otherIds.Contains(x.Key)) || (killer != GameManager.m_local_player && MPDeathReview.lastDeathReview.players.Any(x => selfIds.Contains(x.Key))))))
{
if (MPDeathReview.stickyDeathReview && !MPDeathReview.showDeathReviewDetails)
{
pos.y = 100f;
}
uie.DrawStringSmall(ScriptTutorialMessage.ControlString(CCInput.USE_BOOST) + " - SHOW MORE DETAILS", pos + Vector2.down * 18f, 0.3f, StringOffset.CENTER, UIManager.m_col_ui5 * 0.7f, alpha_mod, -1f);
}
}
private static IEnumerator MatchStart(int connectionId)
{
var newPlayer = Server.FindPlayerByConnectionId(connectionId);
float pregameWait = 3f;
if (!newPlayer.m_mp_name.StartsWith("OBSERVER"))
{
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (MPTweaks.ClientHasTweak(player.connectionToClient.connectionId, "jip"))
{
NetworkServer.SendToClient(player.connectionToClient.connectionId, MessageTypes.MsgJIPJustJoined, new JIPJustJoinedMessage {
playerId = newPlayer.netId, ready = false
});
}
}
MPJoinInProgress.SetReady(newPlayer, false);
}
pregameWait = SendPreGame(connectionId, pregameWait);
yield return(new WaitForSeconds(pregameWait));
Server.SendLoadoutDataToClients();
if (newPlayer.m_mp_name.StartsWith("OBSERVER"))
{
Debug.LogFormat("Enabling spectator for {0}", newPlayer.m_mp_name);
newPlayer.Networkm_spectator = true;
Debug.LogFormat("Enabled spectator for {0}", newPlayer.m_mp_name);
yield return(null); // make sure spectator change is received before sending MatchStart
}
else
{
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (MPTweaks.ClientHasTweak(player.connectionToClient.connectionId, "jip"))
{
NetworkServer.SendToClient(player.connectionToClient.connectionId, MessageTypes.MsgJIPJustJoined, new JIPJustJoinedMessage {
playerId = newPlayer.netId, ready = true
});
}
}
MPJoinInProgress.SetReady(newPlayer, true);
}
if (NetworkMatch.GetMatchState() != MatchState.PLAYING)
{
yield break;
}
IntegerMessage modeMsg = new IntegerMessage((int)NetworkMatch.GetMode());
NetworkServer.SendToClient(connectionId, CustomMsgType.MatchStart, modeMsg);
SendMatchState(connectionId);
NetworkSpawnPlayer.Respawn(newPlayer.c_player_ship);
MPTweaks.Send(connectionId);
//if (!newPlayer.m_spectator && RearView.MPNetworkMatchEnabled)
// newPlayer.CallTargetAddHUDMessage(newPlayer.connectionToClient, "REARVIEW ENABLED", -1, true);
CTF.SendJoinUpdate(newPlayer);
Race.SendJoinUpdate(newPlayer);
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (player.connectionToClient.connectionId == connectionId)
{
continue;
}
// Resend mode for existing player to move h2h -> anarchy
NetworkServer.SendToClient(player.connectionToClient.connectionId, CustomMsgType.MatchStart, modeMsg);
if (!newPlayer.m_spectator)
{
player.CallTargetAddHUDMessage(player.connectionToClient, String.Format(Loc.LS("{0} JOINED MATCH"), newPlayer.m_mp_name), -1, true);
}
//Debug.Log("JIP: spawning on new client net " + player.netId + " lobby " + player.connectionToClient.connectionId);
NetworkServer.SendToClient(connectionId, CustomMsgType.Respawn, new RespawnMessage
{
m_net_id = player.netId,
lobby_id = player.connectionToClient.connectionId,
m_pos = player.transform.position,
m_rotation = player.transform.rotation,
use_loadout1 = player.m_use_loadout1
});
}
ServerStatLog.Connected(newPlayer.m_mp_name);
}
private static void SendMatchState(int connectionId)
{
if (NetworkMatch.IsTeamMode(NetworkMatch.GetMode()))
{
foreach (var team in MPTeams.ActiveTeams)
{
NetworkServer.SendToClient(connectionId, CustomMsgType.SetScoreForTeam, new ScoreForTeamMessage
{
team = (int)team,
score = NetworkMatch.m_team_scores[(int)team]
});
}
}
//if (!MPTweaks.ClientHasMod(connectionId))
// return;
// Process any disconnected scoreboard entries, add them to active pilot, and remove stale scoreboard objects
foreach (var player in Overload.NetworkManager.m_Players)
{
// Add any previous records for pilot on join
var playersSameName = Overload.NetworkManager.m_PlayersForScoreboard.Where(x => !String.IsNullOrEmpty(x.m_mp_name) && x.m_mp_name == player.m_mp_name).ToList();
player.m_kills = playersSameName.Sum(x => x.m_kills);
player.m_deaths = playersSameName.Sum(x => x.m_deaths);
player.m_assists = playersSameName.Sum(x => x.m_assists);
// Remove previously DC'd players of same name from server scoreboard list
playersSameName.Where(x => x != player).ToList().ForEach(x => Overload.NetworkManager.m_PlayersForScoreboard.Remove(x));
}
var n = Overload.NetworkManager.m_Players.Count;
var msg = new MatchStateMessage()
{
m_match_elapsed_seconds = NetworkMatch.m_match_elapsed_seconds,
m_player_states = new PlayerMatchState[n]
};
int i = 0;
foreach (var player in Overload.NetworkManager.m_Players)
{
msg.m_player_states[i++] = new PlayerMatchState()
{
m_net_id = player.netId,
m_kills = player.m_kills,
m_deaths = player.m_deaths,
m_assists = player.m_assists
}
}
;
NetworkServer.SendToClient(connectionId, MessageTypes.MsgSetMatchState, msg);
// Send disconnected pilot stats as separate message
if (MPTweaks.ClientHasTweak(connectionId, "jip"))
{
var dcPlayers = Overload.NetworkManager.m_PlayersForScoreboard.Where(x => !Overload.NetworkManager.m_Players.Contains(x));
var dcmsg = new DisconnectedPlayerMatchStateMessage()
{
m_player_states = new DisconnectedPlayerMatchState[dcPlayers.Count()]
};
int j = 0;
foreach (var player in dcPlayers)
{
dcmsg.m_player_states[j++] = new DisconnectedPlayerMatchState()
{
m_net_id = NetworkInstanceId.Invalid,
m_kills = player.m_kills,
m_deaths = player.m_deaths,
m_assists = player.m_assists,
m_mp_name = player.m_mp_name,
m_mp_team = player.m_mp_team
};
}
NetworkServer.SendToClient(connectionId, MessageTypes.MsgSetDisconnectedMatchState, dcmsg);
}
}
private static IEnumerator MatchStart(int connectionId)
{
if (!MPTweaks.ClientHasMod(connectionId) && MPTweaks.MatchNeedsMod())
{
yield break;
}
var newPlayer = Server.FindPlayerByConnectionId(connectionId);
if (newPlayer.m_mp_name.StartsWith("OBSERVER"))
{
Debug.LogFormat("Enabling spectator for {0}", newPlayer.m_mp_name);
newPlayer.Networkm_spectator = true;
Debug.LogFormat("Enabled spectator for {0}", newPlayer.m_mp_name);
}
int pregameWait = newPlayer.Networkm_spectator ? 0 : 3;
//Debug.Log("SendLoadoutDataToClients: " + NetworkMatch.m_player_loadout_data.Join());
// restore lobby_id which got wiped out in Client.OnSetLoadout
foreach (var idData in NetworkMatch.m_player_loadout_data)
{
idData.Value.lobby_id = idData.Key;
}
Server.SendLoadoutDataToClients();
IntegerMessage durationMsg = new IntegerMessage(pregameWait * 1000);
NetworkServer.SendToClient(connectionId, CustomMsgType.StartPregameCountdown, durationMsg);
Debug.Log("JIP: sending start pregame countdown");
yield return(new WaitForSeconds(pregameWait));
IntegerMessage modeMsg = new IntegerMessage((int)NetworkMatch.GetMode());
NetworkServer.SendToClient(connectionId, CustomMsgType.MatchStart, modeMsg);
SendMatchState(connectionId);
NetworkSpawnPlayer.Respawn(newPlayer.c_player_ship);
MPTweaks.Send(connectionId);
if (!newPlayer.m_spectator && RearView.MPNetworkMatchEnabled)
{
newPlayer.CallTargetAddHUDMessage(newPlayer.connectionToClient, "REARVIEW ENABLED", -1, true);
}
CTF.SendJoinUpdate(newPlayer);
Race.SendJoinUpdate(newPlayer);
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (player.connectionToClient.connectionId == connectionId)
{
continue;
}
// Resend mode for existing player to move h2h -> anarchy
NetworkServer.SendToClient(player.connectionToClient.connectionId, CustomMsgType.MatchStart, modeMsg);
if (!newPlayer.m_spectator)
{
player.CallTargetAddHUDMessage(player.connectionToClient, String.Format(Loc.LS("{0} JOINED MATCH"), newPlayer.m_mp_name), -1, true);
}
//Debug.Log("JIP: spawning on new client net " + player.netId + " lobby " + player.connectionToClient.connectionId);
NetworkServer.SendToClient(connectionId, CustomMsgType.Respawn, new RespawnMessage
{
m_net_id = player.netId,
lobby_id = player.connectionToClient.connectionId,
m_pos = player.transform.position,
m_rotation = player.transform.rotation,
use_loadout1 = player.m_use_loadout1
});
}
ServerStatLog.Connected(newPlayer.m_mp_name);
}
public static float GetRespawnPointScore(MpTeam team, LevelData.SpawnPoint spawnPoint, List <float> distances, float max)
{
var playerPositions = (List <Vector3>)_NetworkSpawnPoints_m_player_pos_Field.GetValue(null);
var playerTeams = (List <MpTeam>)_NetworkSpawnPoints_m_player_team_Field.GetValue(null);
var count = playerPositions.Count;
// For each spawn, find the closest player, and the two players that have the least line of sight to one or the other.
var closest = float.MaxValue;
var leastLoS = float.MaxValue;
var scale = 1f;
var seesEnemy = false;
var seesTeammate = false;
var closestTeammate = float.MaxValue;
for (int i = 0; i < count; i++)
{
var dist = Math.Abs(distances[i]);
Vector3 vector;
vector.x = playerPositions[i].x - spawnPoint.position.x;
vector.y = playerPositions[i].y - spawnPoint.position.y;
vector.z = playerPositions[i].z - spawnPoint.position.z;
var vectorDist = Mathf.Max(0.1f, vector.magnitude);
vector.x /= vectorDist;
vector.y /= vectorDist;
vector.z /= vectorDist;
if (team != playerTeams[i] || NetworkMatch.GetMode() == MatchMode.ANARCHY)
{
closest = Math.Min(closest, dist);
if (VisibilityRaycast(spawnPoint.position, vector, vectorDist))
{
var angle = Math.Min(Vector3.Angle(playerPositions[i] - spawnPoint.position, spawnPoint.orientation * Vector3.forward), Vector3.Angle(spawnPoint.position - playerPositions[i], m_player_rot[i] * Vector3.forward));
leastLoS = Math.Min(leastLoS, angle);
seesEnemy = true;
}
}
else
{
if (dist <= 30f && VisibilityRaycast(spawnPoint.position, vector, vectorDist))
{
seesTeammate = true;
closestTeammate = Math.Min(dist, closestTeammate);
}
}
if (dist < 15f)
{
scale = (float)Math.Pow(Math.Min(scale, dist / 15f), 2);
}
}
if (closest > 80f)
{
scale *= 80f / closest;
}
// Score the spawn point.
var score = Math.Min(closest / Math.Max(max, 1f), 1f) * Math.Min(leastLoS / 60f, 1f) * scale;
// Avoid respawning two ships on the same respawn point within a short amount of time.
if (lastRespawn.ContainsKey(spawnPoint) && lastRespawn[spawnPoint] > DateTime.Now.AddSeconds(-2))
{
score -= (float)(lastRespawn[spawnPoint] - DateTime.Now.AddSeconds(-2)).TotalSeconds;
}
else if (NetworkMatch.GetMode() == MatchMode.TEAM_ANARCHY)
{
// If the spawn point is not being avoided, give a bonus in team anarchy if the spawn point sees teammates and no enemies and doesn't have a teammate on the spawn point and no enemy is within 8 cubes.
if (seesTeammate && !seesEnemy && closestTeammate > 5f && closest > 32f)
{
score += 0.5f * scale;
}
}
return(score);
}
// there's a mode argument but in actual usage this is always NetworkMatch.GetMode()
// so ignore it here, since the default value MatchMode.NUM means CTF now :(
static bool Prefix(MatchMode mode, ref string __result)
{
__result = MPModPrivateData.GetModeString(NetworkMatch.GetMode());
return(false);
}
private static IEnumerator MatchStart(int connectionId)
{
var newPlayer = Server.FindPlayerByConnectionId(connectionId);
MPBanEntry newPlayerEntry = new MPBanEntry(newPlayer);
// prevent banned players from JIP into our match
// there is already a delayed Disconnect going on, just
// prevent this player from entering the JIP code
if (MPBanPlayers.IsBanned(newPlayerEntry))
{
yield break;
}
float pregameWait = 3f;
if (!newPlayer.m_mp_name.StartsWith("OBSERVER"))
{
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (MPTweaks.ClientHasTweak(player.connectionToClient.connectionId, "jip"))
{
NetworkServer.SendToClient(player.connectionToClient.connectionId, MessageTypes.MsgJIPJustJoined, new JIPJustJoinedMessage {
playerId = newPlayer.netId, ready = false
});
}
}
MPJoinInProgress.SetReady(newPlayer, false, true); // special case: do not disable the player completely, as this would prevent this player to be sent to new clients joining before we finally switch to ready
}
pregameWait = SendPreGame(connectionId, pregameWait);
yield return(new WaitForSeconds(pregameWait));
Server.SendLoadoutDataToClients();
if (newPlayer.m_mp_name.StartsWith("OBSERVER"))
{
Debug.LogFormat("Enabling spectator for {0}", newPlayer.m_mp_name);
newPlayer.Networkm_spectator = true;
Debug.LogFormat("Enabled spectator for {0}", newPlayer.m_mp_name);
yield return(null); // make sure spectator change is received before sending MatchStart
}
else
{
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (MPTweaks.ClientHasTweak(player.connectionToClient.connectionId, "jip"))
{
NetworkServer.SendToClient(player.connectionToClient.connectionId, MessageTypes.MsgJIPJustJoined, new JIPJustJoinedMessage {
playerId = newPlayer.netId, ready = true
});
}
}
MPJoinInProgress.SetReady(newPlayer, true);
}
if (NetworkMatch.GetMatchState() != MatchState.PLAYING)
{
yield break;
}
IntegerMessage modeMsg = new IntegerMessage((int)NetworkMatch.GetMode());
NetworkServer.SendToClient(connectionId, CustomMsgType.MatchStart, modeMsg);
SendMatchState(connectionId);
NetworkSpawnPlayer.Respawn(newPlayer.c_player_ship);
MPTweaks.Send(connectionId);
//if (!newPlayer.m_spectator && RearView.MPNetworkMatchEnabled)
// newPlayer.CallTargetAddHUDMessage(newPlayer.connectionToClient, "REARVIEW ENABLED", -1, true);
CTF.SendJoinUpdate(newPlayer);
Race.SendJoinUpdate(newPlayer);
foreach (Player player in Overload.NetworkManager.m_Players)
{
if (player.connectionToClient.connectionId == connectionId)
{
continue;
}
// Resend mode for existing player to move h2h -> anarchy
NetworkServer.SendToClient(player.connectionToClient.connectionId, CustomMsgType.MatchStart, modeMsg);
if (!newPlayer.m_spectator)
{
player.CallTargetAddHUDMessage(player.connectionToClient, String.Format(Loc.LS("{0} JOINED MATCH"), newPlayer.m_mp_name), -1, true);
}
//Debug.Log("JIP: spawning on new client net " + player.netId + " lobby " + player.connectionToClient.connectionId);
NetworkServer.SendToClient(connectionId, CustomMsgType.Respawn, new RespawnMessage
{
m_net_id = player.netId,
lobby_id = player.connectionToClient.connectionId,
m_pos = player.transform.position,
m_rotation = player.transform.rotation,
use_loadout1 = player.m_use_loadout1
});
}
ServerStatLog.Connected(newPlayer.m_mp_name);
MPBanPlayers.ApplyAllBans(); // make sure the newly connected player gets proper treatment if he is BANNED
}
private static void Prefix()
{
// Check mode, bail if not Anarchy or Team Anarchy.
var mode = NetworkMatch.GetMode();
if (mode != MatchMode.ANARCHY && mode != MatchMode.TEAM_ANARCHY)
{
return;
}
// Bail if we have spawn points.
if (MPRespawn.spawnPointDistances.Count > 0)
{
return;
}
// If enabled, get all of the item spawn points and check to see if they can be reused as player spawn points.
if (MPRespawn.EnableItemSpawnsAsPlayerSpawns)
{
for (int i = 0; i < GameManager.m_level_data.m_item_spawn_points.Length; i++)
{
// TODO: Figure out how to bail when supers are involved.
// if (spawn point is super) {
// continue;
// }
var itemSpawnPoint = GameManager.m_level_data.m_item_spawn_points[i];
float largestDistance = 0f;
Quaternion largestQuaternion = Quaternion.identity;
for (float angle = 0f; angle < 360f; angle += 15f)
{
var quaternion = Quaternion.Euler(0, angle, 0);
if (Physics.Raycast(itemSpawnPoint.position, quaternion * Vector3.forward, out RaycastHit hitInfo, 9999f))
{
var distance = hitInfo.distance;
if (distance > largestDistance)
{
largestDistance = distance;
largestQuaternion = quaternion;
}
}
}
if (largestDistance > 20f)
{
MPRespawn.spawnPointsFromItems.Add(new MPRespawn.ItemSpawnPoint(i, largestQuaternion));
}
}
}
// Generate a lookup of the distance between spawn points.
var spawnPoints = new List <LevelData.SpawnPoint>();
spawnPoints.AddRange(MPRespawn.spawnPointsFromItems.Select(s => s.spawnPoint));
spawnPoints.AddRange(GameManager.m_level_data.m_player_spawn_points);
foreach (var spawn1 in spawnPoints)
{
var position = spawn1.position;
var segnum = GameManager.m_level_data.FindSegmentContainingWorldPosition(position);
MPRespawn.spawnPointDistances.Add(spawn1, new Dictionary <LevelData.SpawnPoint, float>());
foreach (var spawn2 in spawnPoints)
{
if (spawn1 == spawn2)
{
continue;
}
var position2 = spawn2.position;
var segnum2 = GameManager.m_level_data.FindSegmentContainingWorldPosition(position2);
var distance = RUtility.FindVec3Distance(position - position2);
MPRespawn.spawnPointDistances[spawn1].Add(spawn2, distance);
}
}
}
