void SendClientEndGame1Plus()
{
TeamMatchData matchData = new TeamMatchData();
matchData.acc_id = MainPlayer.Instance.AccountID;
PlayerMatchData homeData = new PlayerMatchData();
homeData.acc_id = m_match.m_homeTeam.GetMember(0).m_roleInfo.acc_id;
homeData.exit_type = ExitMatchType.EMT_END;
matchData.player_data.Add(homeData);
foreach (Player player in m_match.m_homeTeam)
{
matchData.role_data.Add(player.mStatistics.data);
}
PlayerMatchData awayData = new PlayerMatchData();
awayData.acc_id = m_match.m_awayTeam.GetMember(0).m_roleInfo.acc_id;
awayData.exit_type = ExitMatchType.EMT_END;
matchData.player_data.Add(awayData);
foreach (Player player in m_match.m_awayTeam)
{
matchData.role_data.Add(player.mStatistics.data);
}
GameMsgSender.SendTeamMatchData(matchData);
}
/// <summary>
/// 是否数据一致
/// </summary>
protected override bool toDataEquals(BaseData data)
{
PlayerMatchData mData = (PlayerMatchData)data;
if (mData.showData != null)
{
if (this.showData == null)
{
return(false);
}
if (!this.showData.dataEquals(mData.showData))
{
return(false);
}
}
else
{
if (this.showData != null)
{
return(false);
}
}
if (this.value != mData.value)
{
return(false);
}
return(true);
}
private void Start()
{
playerMatchData = GetComponent <PlayerMatchData>();
if (!playerMatchData)
{
throw new Exception("Player has no PlayerMatchData! WTF!!!!");
}
}
/// <summary>
/// 复制(潜拷贝)
/// </summary>
protected override void toShadowCopy(BaseData data)
{
if (!(data is PlayerMatchData))
{
return;
}
PlayerMatchData mData = (PlayerMatchData)data;
this.showData = mData.showData;
this.value = mData.value;
}
/// <summary>
/// 转文本输出
/// </summary>
protected override void toWriteDataString(DataWriter writer)
{
base.toWriteDataString(writer);
writer.writeTabs();
writer.sb.Append("index");
writer.sb.Append(':');
writer.sb.Append(this.index);
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("matchDatas");
writer.sb.Append(':');
writer.sb.Append("Array<PlayerMatchData>");
if (this.matchDatas != null)
{
PlayerMatchData[] matchDatasT = this.matchDatas;
int matchDatasLen = matchDatasT.Length;
writer.sb.Append('(');
writer.sb.Append(matchDatasLen);
writer.sb.Append(')');
writer.writeEnter();
writer.writeLeftBrace();
for (int matchDatasI = 0; matchDatasI < matchDatasLen; ++matchDatasI)
{
PlayerMatchData matchDatasV = matchDatasT[matchDatasI];
writer.writeTabs();
writer.sb.Append(matchDatasI);
writer.sb.Append(':');
if (matchDatasV != null)
{
matchDatasV.writeDataString(writer);
}
else
{
writer.sb.Append("PlayerMatchData=null");
}
writer.writeEnter();
}
writer.writeRightBrace();
}
else
{
writer.sb.Append("=null");
}
writer.writeEnter();
}
void SendClientEndGame3V3()
{
TeamMatchData matchData = new TeamMatchData();
matchData.acc_id = MainPlayer.Instance.AccountID;
foreach (Player player in GameSystem.Instance.mClient.mPlayerManager)
{
PlayerMatchData accData = new PlayerMatchData();
accData.acc_id = player.m_roleInfo.acc_id;
accData.exit_type = ExitMatchType.EMT_END;
matchData.player_data.Add(accData);
matchData.role_data.Add(player.mStatistics.data);
}
GameMsgSender.SendTeamMatchData(matchData);
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.index = stream.readInt();
int matchDatasLen = stream.readLen();
if (this.matchDatas == null || this.matchDatas.Length != matchDatasLen)
{
this.matchDatas = new PlayerMatchData[matchDatasLen];
}
PlayerMatchData[] matchDatasT = this.matchDatas;
for (int matchDatasI = 0; matchDatasI < matchDatasLen; ++matchDatasI)
{
PlayerMatchData matchDatasV;
BaseData matchDatasVT = stream.readDataFullNotNull();
if (matchDatasVT != null)
{
if (matchDatasVT is PlayerMatchData)
{
matchDatasV = (PlayerMatchData)matchDatasVT;
}
else
{
matchDatasV = new PlayerMatchData();
if (!(matchDatasVT.GetType().IsAssignableFrom(typeof(PlayerMatchData))))
{
stream.throwTypeReadError(typeof(PlayerMatchData), matchDatasVT.GetType());
}
matchDatasV.shadowCopy(matchDatasVT);
}
}
else
{
matchDatasV = null;
}
matchDatasT[matchDatasI] = matchDatasV;
}
stream.endReadObj();
}
public static IHtmlContent FormatRatingChange(this IHtmlHelper html, PlayerMatchData data)
{
string result;
int ratingChange = data.RatingChange;
if (data.Match != null && data.Match.IsTraining)
{
result = "training";
}
else if (ratingChange < 0)
{
result = $"<span class='dire'>{ratingChange}</span>";
}
else
{
result = $"<span class='radiant'>+{ratingChange}</span>";
}
return(new HtmlString(result));
}
/// <summary>
/// 复制(深拷贝)
/// </summary>
protected override void toCopy(BaseData data)
{
if (!(data is PlayerMatchData))
{
return;
}
PlayerMatchData mData = (PlayerMatchData)data;
if (mData.showData != null)
{
this.showData = (RoleShowData)mData.showData.clone();
}
else
{
this.showData = null;
nullObjError("showData");
}
this.value = mData.value;
}
public MatchResponse(PlayerMatchData playerData, int order)
{
Match match = playerData.Match;
Id = match.MatchId;
Data = new
{
Id = match.MatchId,
IsTraining = match.IsTraining,
Date = match.Date,
Won = playerData.Won,
RatingChange = playerData.RatingChange,
Duration = match.Duration,
Builder = playerData.Fraction.Name,
};
// IsTraining = match.IsTraining;
// Date = match.Date;
// Won = match.Winner == playerData.Team;
// RatingChange = playerData.RatingChange;
// Duration = match.Duration;
Order = order;
}
private async Task <PlayerMatchData> CreatePlayerMatchData(Player player, Match match, string fraction, int team,
bool abandoned, int earnedTangos, int earnedGold)
{
PlayerMatchData result = new PlayerMatchData
{
Player = player,
Match = match,
Abandoned = abandoned,
Team = team,
Fraction = await GetOrCreateFraction(fraction),
EarnedTangos = earnedTangos,
EarnedGold = earnedGold
};
_db.Entry(player).State = EntityState.Modified;
_db.Entry(match).State = EntityState.Modified;
_db.Entry(result.Fraction).State = EntityState.Modified;
_db.PlayerMatchData.Add(result);
await _db.SaveChangesAsync();
return(result);
}
private void Start()
{
playerMatchData = GetComponent <PlayerMatchData>();
raycastableForInSightLayerMask = playerMatchData.raycastableForInSightLayerMask;
detectableLayerMask = playerMatchData.detectableLayerMask;
}
public async Task <ActionResult> SaveMatchData(int?winner, string playerDataString, float duration,
int lastWave, string duelDataString)
{
if (!winner.HasValue || string.IsNullOrWhiteSpace(playerDataString))
{
return(Json(new MissingArgumentFailure()));
}
try
{
var strategy = _db.Database.CreateExecutionStrategy();
var matchId = await strategy.ExecuteAsync(async() =>
{
using var transaction = await _db.Database.BeginTransactionAsync();
//Creating Match
Match match = new Match
{
Winner = winner.Value,
Duration = duration,
LastWave = lastWave,
Date = DateTime.UtcNow,
IsTraining = true,
Duels = new List <Duel>(),
PlayerData = new List <PlayerMatchData>()
};
_db.Matches.Add(match);
await _db.SaveChangesAsync();
using var loggingContext = new LoggingContext($"#{match.MatchId}");
LoggingUtil.Log($"Adding Match {match.MatchId}");
//Adding Duels
int createdDuels = 0;
if (duelDataString.TryToJson(out JsonDocument duelDocument) &&
duelDocument.RootElement.ValueKind == JsonValueKind.Object)
{
foreach (var duelProp in duelDocument.RootElement.EnumerateObject())
{
var order = int.Parse(duelProp.Name);
var time = duelProp.Value.GetFloatOrDefault("time");
var duelWinner = duelProp.Value.GetIntOrDefault("winner");
Duel duel = new Duel
{
Match = match,
MatchId = match.MatchId,
Order = order,
Winner = duelWinner,
TimeStamp = time
};
match.Duels.Add(duel);
_db.Duels.Add(duel);
createdDuels += 1;
}
}
else
{
LoggingUtil.Warn($"No duel data available for Game");
}
await _db.SaveChangesAsync();
//Adding player Data
var playerObjs = playerDataString.ToJsonElement();
var steamIds = playerObjs.EnumerateObject().Select(p => long.Parse(p.Name)).ToList();
var players = await _db.GetOrCreateAsync(
steamIds,
p => p.SteamId,
steamId => new Player
{
SteamId = steamId,
Matches = new List <PlayerMatchData>()
},
query: players => players
.Include(p => p.Matches)
.ThenInclude(m => m.Match)
); // We request the match history to calculate the rating change
try
{
var steamInfo = await _steamApi.RequestPlayerInformation(steamIds);
players.ForEach(p => p.Update(steamInfo[p.SteamId]));
}
catch (Exception)
{
LoggingUtil.Warn("Couldn't retrieve steam info.");
}
await _db.SaveChangesAsync();
// Enter player match data
var playerData = new List <PlayerMatchData>();
foreach (var(steamId, player) in steamIds.Zip(players))
{
var data = playerObjs.GetProperty(steamId.ToString());
var rawUnitData = data.GetProperty("unit_data");
var unitData = new Dictionary <string, UnitData>();
if (rawUnitData.ValueKind == JsonValueKind.Object)
{
unitData = ExtractPlayerUnitData(rawUnitData);
}
else
{
LoggingUtil.Warn($"No unit data for {steamId}");
}
var newData = new PlayerMatchData
{
Player = player,
PlayerId = steamId,
Match = match,
MatchId = match.MatchId,
Abandoned = data.GetBoolOrDefault("abandoned"),
Team = data.GetIntOrDefault("team"),
FractionName = data.GetValueOrDefault("fraction"),
EarnedTangos = data.GetIntOrDefault("earned_tangos"),
EarnedGold = data.GetIntOrDefault("earned_gold"),
UnitData = unitData
};
player.Matches.Add(newData);
match.PlayerData.Add(newData);
playerData.Add(newData);
}
// Retrieve exp for units
var unitNames = playerData.SelectMany(p => p.UnitData.Object.Keys).Distinct().ToList();
var units = await _db.GetOrCreateAsync(unitNames, u => u.Name, name => CreateUnitOrBuilder(name));
var experiences = units.ToDictionary(u => u.Name, u => u.Experience);
// Check whether this is a training match
match.IsTraining = DecideIsTraining(match, playerData);
// Update ratings and statistics
foreach (var pd in playerData)
{
pd.CalculateStats(experiences);
pd.RatingChange = pd.CalculateRatingChange(); // this requires having all player histories loaded
}
_db.PlayerMatchData.AddRange(playerData);
await _db.SaveChangesAsync();
lock (_dbLock)
{
transaction.Commit();
}
LoggingUtil.Log($"Succesfully saved; Wave {lastWave}; Duration {duration}; Players: {players.Count}; Duels: {createdDuels}; IsTraining: {match.IsTraining}");
return(match.MatchId);
});
private IEnumerator GetOwnerMatchData()
{
yield return(new WaitUntil(() => Owner != null));
_ownerMatchData = Owner.GetComponent <PlayerMatchData>();
}
public async Task <ActionResult> SaveMatchData(int?winner, string playerDataString, float duration,
int lastWave, string duelDataString)
{
if (!winner.HasValue || string.IsNullOrEmpty(playerDataString))
{
return(Json(new MissingArgumentFailure()));
}
//Creating Match
Match match = await CreateMatch(winner.Value, duration, lastWave);
//Adding Duels
if (!string.IsNullOrEmpty(duelDataString))
{
Dictionary <int, Dictionary <String, float> > duelData = null;
try
{
duelData = JsonConvert.DeserializeObject <Dictionary <int, Dictionary <String, float> > >(duelDataString);
}
catch (Exception)
{
try
{
var data = JsonConvert.DeserializeObject <List <Dictionary <String, float> > >(duelDataString);
for (int i = 0; i < data.Count; i++)
{
duelData[i + 1] = data[i];
}
}
catch (Exception) { }
}
if (duelData != null)
{
foreach (var pair in duelData)
{
var order = pair.Key;
var data = pair.Value;
Duel duel = await CreateDuel(match, order, (int)data["winner"], data["time"]);
}
}
}
//Adding player Data
var playerData =
JsonConvert.DeserializeObject <Dictionary <long, Dictionary <string, string> > >(playerDataString);
List <Player> players = new List <Player>();
List <PlayerMatchData> playerMatchDatas = new List <PlayerMatchData>();
foreach (var pair in playerData)
{
long steamId = pair.Key;
Dictionary <string, string> decodedData = pair.Value;
Player player = await GetOrCreatePlayer(steamId);
PlayerMatchData playerMatchData = await CreatePlayerMatchData(player,
match,
decodedData["fraction"],
int.Parse(decodedData["team"]),
bool.Parse(decodedData["abandoned"]),
int.Parse(decodedData["earned_tangos"]),
int.Parse(decodedData["earned_gold"]));
List <PlayerUnitRelation> playerUnitRelations =
await CreatePlayerUnitRelations(playerMatchData, decodedData);
players.Add(player);
playerMatchDatas.Add(playerMatchData);
}
await DecideIsTraining(match);
await ModifyRatings(playerMatchDatas, match);
await _steamApi.UpdatePlayerInformation(players.Select(p => p.SteamId));
return(Json(new { Success = true }));
}
private async Task <List <PlayerUnitRelation> > CreatePlayerUnitRelations(PlayerMatchData playerMatchData,
Dictionary <string, string> decodedData)
{
//local function to interpet the key
//key is constructed like this: <type>_<unitname>
(string unitName, string type) InterpretIdentifier(string identifier)
{
foreach (var t in UnitRelationFunctions.Keys)
{
if (identifier.StartsWith(t))
{
return(identifier.Replace(t, ""), t);
}
}
return(null, null);
}
Dictionary <string, PlayerUnitRelation> relations = new Dictionary <string, PlayerUnitRelation>();
foreach (var pair in decodedData)
{
var(unitName, type) = InterpretIdentifier(pair.Key);
if (unitName == null || type == null)
{
continue;
}
Unit unit = await GetOrCreateUnit(unitName);
int count = int.Parse(pair.Value);
PlayerUnitRelation relation = relations.ContainsKey(unitName)
? relations[unitName]
: new PlayerUnitRelation
{
PlayerMatch = playerMatchData,
Unit = unit
};
relations[unitName] = relation;
UnitRelationFunctions[type].Invoke(relation, count);
}
List <PlayerUnitRelation> result = relations.Values.ToList();
foreach (var unit in result.Select(r => r.Unit))
{
_db.Entry(unit).State = EntityState.Modified;
}
_db.Entry(playerMatchData).State = EntityState.Modified;
_db.PlayerUnitRelations.AddRange(result);
await _db.SaveChangesAsync();
//Calculating Match statistics
var p = await _db.PlayerMatchData
.IgnoreQueryFilters()
.Include(pd => pd.UnitDatas)
.ThenInclude(r => r.Unit)
.Include(pd => pd.Match)
.ThenInclude(pd => pd.Duels)
.SingleAsync(pd => pd.MatchId == playerMatchData.MatchId && pd.PlayerId == playerMatchData.PlayerId);
p.CalculateStats();
_db.Entry(p).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(result);
}
IEnumerator ShieldLengthCountDown(float shieldLengthTime, PlayerMatchData playerMatchData)
{
yield return(new WaitForSeconds(shieldLengthTime));
playerMatchData.CanTakeDamage = true;
}
