void ProcessReplayButtonEvent()
{
if (!isBestReplayAvailable)
{
return;
}
switch (this.bestReplayState)
{
case ReplayState.Stopped:
if (this.bestReplayData == null)
{
SetReplayState(ReplayState.Downloading);
ReplayData.DownloadReplayRecordAsync(bestReplayPath).ContinueWith(task => {
if (!task.IsFaulted && !task.IsCanceled && task.Result != null)
{
this.bestReplayData = task.Result;
}
});
}
else
{
SetReplayState(ReplayState.Playing);
}
break;
case ReplayState.Playing:
SetReplayState(ReplayState.Stopped);
break;
case ReplayState.Downloading:
default:
break;
}
}
/// <summary>
/// リプレイの再生
/// </summary>
/// <param name="fTime">リプレイ経過時間</param>
void ReplayPlaying(float fTime)
{
int DataIndex = 0;
for (int i = 0; i < ReplayDataList.Count; ++i)
{
if (ReplayDataList[i].fTime > fTime)
{
DataIndex = i - 1;
break;
}
}
if (DataIndex < 1)
{
return;
}
ReplayData BeforeData = ReplayDataList[DataIndex - 1];
ReplayData AfterData = ReplayDataList[DataIndex];
float DeltaTime = AfterData.fTime - fTime / (AfterData.fTime - BeforeData.fTime);
SetReplay(BeforeData, AfterData, DeltaTime);
}
public void Download()
{
new Task(() =>
{
ReplayData replayData = new ReplayData();
replayData.ServerVersion = this.replay.GetServerVersion();
if (this.OnServerVersionDownloaded != null)
{
this.OnServerVersionDownloaded(this, replayData.ServerVersion);
}
replayData.Metadata = this.replay.GetMetadata();
if (this.OnMetadataDownloaded != null)
{
this.OnMetadataDownloaded(this, replayData.Metadata);
}
for (int i = 1; i <= replayData.Metadata.LastChunkId; i++)
{
Chunk chunk = new Chunk();
chunk.Id = i;
chunk.Data = this.replay.GetChunkData(i);
replayData.Chunks.Add(chunk);
if (this.OnChunkDownloaded != null)
{
this.OnChunkDownloaded(this, chunk);
}
}
for (int i = 1; i <= replayData.Metadata.LastKeyFrameId; i++)
{
KeyFrame keyFrame = new KeyFrame();
keyFrame.Id = i;
keyFrame.Data = this.replay.GetKeyFrameData(i);
replayData.KeyFrames.Add(keyFrame);
if (this.OnKeyFrameDownloaded != null)
{
this.OnKeyFrameDownloaded(this, keyFrame);
}
}
replayData.LastChunkInfo = this.replay.GetLastChunkInfo();
replayData.EncryptionKey = this.encryptionKey;
if (this.OnDownloadFinished != null)
{
this.OnDownloadFinished(this, replayData);
}
}).Start();
}
public IEnumerator <YieldInstruction> Replay(ReplayData replay)
{
GameManager.Instance.BGM("", true);
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.FadeOut(false)));
DataManager.Instance.MsgLog.Clear();
if (replay.States.Count > 0)
{
GameState state = replay.ReadState();
if (state.Save.NextDest.IsValid())
{
DataManager.Instance.SetProgress(state.Save);
LuaEngine.Instance.LoadSavedData(DataManager.Instance.Save); //notify script engine
ZoneManager.LoadFromState(state.Zone);
DataManager.Instance.CurrentReplay = replay;
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.MoveToZone(DataManager.Instance.Save.NextDest)));
yield break;
}
}
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.SetDialogue(Text.FormatKey("DLG_NO_ADVENTURE"))));
GameManager.Instance.SceneOutcome = GameManager.Instance.ReturnToReplayMenu();
}
private static void AddCommandSealUseToDatabase(ReplayData replayData, frsDb db,
List <gameplayerdetail> dbPlayerDetailList, List <player> dbPlayerList)
{
foreach (player player in dbPlayerList)
{
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerName(player.PlayerName);
if (playerInfo == null)
{
throw new InvalidOperationException("Player Name could not be found from replay data (AddCommandSealUseToDatabase): " + player.PlayerName);
}
gameplayerdetail gpDetail = dbPlayerDetailList.First(x => x.FK_PlayerID == player.PlayerID);
var commandSealGroup = playerInfo.CommandSealList.GroupBy(x => x)
.Select(group => new
{
CommandSealAbilID = group.Key,
UseCount = group.Count()
});
foreach (var commandSeal in commandSealGroup)
{
commandsealuse commandSealUsed = new commandsealuse()
{
FK_GamePlayerDetailID = gpDetail.GamePlayerDetailID,
CommandSealAbilID = commandSeal.CommandSealAbilID,
UseCount = commandSeal.UseCount
};
db.commandsealuses.Add(commandSealUsed);
}
}
}
private void DoRecord()
{
ReplayData replayData = ReplayData.builder()
.setPosition(transform.position)
.setYVelocity(playerMovement.YVelocity)
.setTimeScale(playerMovement.TimeScale)
.setCurrentAngel(playerMovement.CurrentAngel)
.setAngularSpeed(playerMovement.AngularSpeed)
.setJumpHeight(playerMovement.CurrentJumpHeight)
.setJumpState(stateController.CurrentJumpState)
.setStartBoostYPos(playerMovement.StartBoostYPos)
.setApexYPos(playerMovement.ApexYPos)
.setCameraZoom(cameraController.CameraSize)
.setJetpackFuel(gameManger.JetPackFuel)
.setParachutes(gameManger.Parachutes)
.setPlanners(gameManger.Planners)
.build();
positionRecord.Enqueue(replayData);
if (positionRecord.Count > replaySize)
{
replayData = positionRecord.Dequeue();
ClearForceMarkerBehind(forceMarkers, replayData.currentAngel);
ClearForceMarkerBehind(forceMarkersToDelete, replayData.currentAngel);
}
}
private static void AddHeroStatLearnDetailToDatabase(ReplayData replayData, frsDb db,
List <gameplayerdetail> dbPlayerDetailList, List <player> dbPlayerList)
{
foreach (player player in dbPlayerList)
{
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerName(player.PlayerName);
if (playerInfo == null)
{
throw new InvalidOperationException("Player Name could not be found from replay data (AddHeroStatLearnDetailToDatabase): " + player.PlayerName);
}
var statList = playerInfo.StatList.GroupBy(x => x)
.Select(group => new
{
StatAbilID = group.Key,
StatLearnCount = group.Count()
});
gameplayerdetail gpDetail = dbPlayerDetailList.First(x => x.FK_PlayerID == player.PlayerID);
foreach (var stat in statList)
{
herostatinfo statInfo = db.herostatinfo.First(x => x.HeroStatAbilID == stat.StatAbilID);
herostatlearn statLearned = new herostatlearn()
{
FK_HeroStatInfoID = statInfo.HeroStatInfoID,
FK_GamePlayerDetailID = gpDetail.GamePlayerDetailID,
LearnCount = stat.StatLearnCount
};
db.herostatlearn.Add(statLearned);
}
}
}
private static void AddGodsHelpUseToDatabase(ReplayData replayData, frsDb db,
List <gameplayerdetail> dbPlayerDetailList, List <player> dbPlayerList)
{
foreach (player player in dbPlayerList)
{
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerName(player.PlayerName);
if (playerInfo == null)
{
throw new InvalidOperationException("Player Name could not be found from replay data (AddGodsHelpUseToDatabase): " + player.PlayerName);
}
gameplayerdetail gpDetail = dbPlayerDetailList.First(x => x.FK_PlayerID == player.PlayerID);
foreach (var godsHelpAbilId in playerInfo.GodsHelpList)
{
godshelpinfo godsHelpInfo = db.godshelpinfo.First(x => x.GodsHelpAbilID == godsHelpAbilId);
godshelpuse godsHelpUsed = new godshelpuse()
{
FK_GodsHelpInfoID = godsHelpInfo.GodsHelpInfoID,
FK_GamePlayerDetailID = gpDetail.GamePlayerDetailID
};
db.godshelpuse.Add(godsHelpUsed);
}
}
}
/// <summary>
/// Parses a list of FRSEvent, then fills replayData with parsed information
/// </summary>
/// <param name="frsEventCallList"></param>
/// <param name="replayData"></param>
public static void ParseEventAPI(IEnumerable <FRSEvent> frsEventCallList, ReplayData replayData)
{
foreach (FRSEvent frsEvent in frsEventCallList)
{
_eventHandlerDic[frsEvent.EventCategory](frsEvent, replayData);
}
}
private static void ParseServantSelection(FRSEvent frsEvent, ReplayData replayData)
{
string[] servantSelectionData = frsEvent.EventDetail.Split(new[] { EVENT_MSG_DELIMITER }, StringSplitOptions.None); //PlayerName//PlayerReplayId//HeroId//TeamNumber
if (servantSelectionData.Length != 4)
{
throw new InvalidDataException($"Expected 4 inputs for ServantSelection event in method ParseServantSelection. Input {frsEvent.EventDetail}");
}
string playerName = servantSelectionData[0];
int playerGameId = int.Parse(servantSelectionData[1]);
string servantId = servantSelectionData[2];
int teamNumber = int.Parse(servantSelectionData[3]);
if (teamNumber > 2 || teamNumber < 1)
{
throw new InvalidDataException($"Incorrect TeamNumber found in ParseServantSelection. Input {teamNumber}");
}
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerName(playerName);
if (playerInfo == null)
{
throw new InvalidDataException($"PlayerName could not be found in method ParseServantSelection. Input {playerName}");
}
playerInfo.ServantId = servantId;
playerInfo.PlayerGameId = playerGameId;
replayData.AddPlayerInfoByGameId(playerGameId, playerInfo);
//Mix teams switch teams around
//We reassign team number here in case if it's been changed
//Also not zero-index based, so we subtract one
playerInfo.Team = teamNumber - 1;
}
private void OnPlaybackModeOn()
{
activeTurnOffPlaybackMode = !CrossPlatformInputManager.GetButtonDown("Jump");
rigidBody.detectCollisions = false;
rigidBody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidBody.isKinematic = true;
rigidBody.velocity = Vector3.zero;
RemoveUnactualForceMarkers();
if (markReplayForceJumpPoint)
{
foreach (float key in trajectoryMarker.ForceJumpMarkers.Keys)
{
MarkerObject markerObject = trajectoryMarker.ForceJumpMarkers[key];
markerObject.SetColor(markerColor);
forceMarkers.Add(key, trajectoryMarker.ForceJumpMarkers[key]);
}
trajectoryMarker.ForceJumpMarkers.Clear();
}
else
{
trajectoryMarker.ClearAndDestroyForceMarkers();
}
ReplayData replayData = positionRecord.Peek();
while (Physics.BoxCast(replayData.position, boxCollider.bounds.extents, Vector3.zero, Quaternion.Euler(0, 90 - replayData.currentAngel, 0), 0))
{
replayData = positionRecord.Dequeue();
}
playbackData = new List <ReplayData>(positionRecord);
DrawPath();
currentFrame = playbackData.Count - 1;
DoPlayBack(currentFrame);
}
public void OnReplay()
{
var cgdData = GetData <CombatGainsDetailItemData>();
if (cgdData == null)
{
return;
}
if (!string.IsNullOrEmpty(cgdData.Url))
{
Application.OpenURL(cgdData.GetFullUrl());
return;
}
var ctr = CombatGainsController.Instance;
if (ctr.CurType < 1)
{
return;
}
var replayData = new ReplayData
{
ReplayId = name,
GameKey = ctr.CurGameKey,
Type = ctr.CurType,
DetailData = cgdData
};
CombatGainsController.Instance.JoinReplay(replayData);
}
public void Win(ReplayData replayData)
{
stop();
replayData.EndTimeInSeconds = Timer.ElapsedSeconds;
WinOverlay.Setup(Timer.ElapsedSeconds, replayData);
StartCoroutine(delayActivate(WinOverlay.gameObject));
}
public void UpdateInfo(int index, int pID, Tile t)
{
ReplayData r = new ReplayData(pID, t);
replayInfo.Add(index, r);
PersistInfo(r);
}
public void SaveReplay(int index, string name, STGData data)
{
if (Global.IsInReplayMode)
{
return;
}
ReplayInfo info = new ReplayInfo
{
replayIndex = index,
name = name,
dateTick = System.DateTime.Now.Ticks,
lastFrame = STGStageManager.GetInstance().GetFrameSinceStageStart(),
stageName = data.stageName,
characterIndex = data.characterIndex,
};
ReplayData repData = new ReplayData();
repData.info = info;
repData.keyList = OperationController.GetInstance().GetOperationKeyList();
repData.lastFrame = STGStageManager.GetInstance().GetFrameSinceStageStart();
repData.seed = data.seed;
// 写入info文件
WriteRepInfoFile(info);
WriteRepDataFile(repData);
}
public ReplayEventData(ReplayData from, ReplayData to)
{
this.from = from;
this.to = to;
TimeSpan span = to.time.Subtract(from.time);
float ms = span.Milliseconds;
this.duration = Mathf.Abs(ms * 0.001f); // Convert to seconds
}
private void ManageReplaysDeleteButton_Click(object sender, EventArgs e)
{
ReplayData replayData = (ReplayData)ManageReplaysList.SelectedItems[0].Tag;
ReplayManager.DeleteReplay(replayData.Filename);
this.LoadReplays();
}
public static void SaveReplay(string filename, ReplayData replayData)
{
string filePath = Path.Combine(Program.ReplaysDir, String.Format("{0}.replaygg", filename));
using (FileStream fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
using (GZipStream gzipStream = new GZipStream(fileStream, CompressionMode.Compress))
new BinaryFormatter().Serialize(gzipStream, replayData);
}
public void ReturnsReplayData()
{
// Arrange -> Act
var replayData = new ReplayData();
// Assert
Assert.IsAssignableFrom <ReplayData>(replayData);
}
private void Receiver_OnReceived(string action, string data)
{
switch (action)
{
case "BattleReady":
Dispatcher.Invoke(() =>
{
EnemyDeckList.Clear();
});
break;
case "Load":
Sender.Initialize(int.Parse(data));
Sender.Send($"Setting:{Settings.ToString()}");
break;
case "EnemyPlay":
case "EnemyAdd":
Dispatcher.Invoke(() =>
{
EnemyDeckList.Add(CardData.Parse(data, action == "EnemyPlay" ? 1 : -1));
});
break;
case "PlayerDeck":
var cardList = new List <CardData>();
var cards = data.Split('\n');
foreach (var card in cards)
{
cardList.Add(CardData.Parse(card));
}
Dispatcher.Invoke(() =>
{
PlayerDeckList.Clear();
PlayerDeckList.Add(cardList);
});
break;
case "PlayerDraw":
Dispatcher.Invoke(() =>
{
PlayerDeckList.Add(CardData.Parse(data, -1));
});
break;
case "ReplayDetail":
Dispatcher.Invoke(() =>
{
ReplayGrid.DataContext = ReplayData.Parse(data);
});
break;
}
Dispatcher.Invoke(() =>
{
LogText.Text = $"{action}:{data}\n{LogText.Text}";
});
}
/// <summary>
/// 現在のリプレイデータを作成
/// </summary>
/// <returns>作成したリプレイデータ</returns>
ReplayData GetData()
{
ReplayData NowData = new ReplayData();
NowData.fTime = Time.time - fRecordStartTime;
NowData.Position = transform.position;
NowData.Rotate = transform.rotation;
return(NowData);
}
public ReplayEventData(ReplayData from, ReplayData to)
{
this.from = from;
this.to = to;
TimeSpan span = to.time.Subtract(from.time);
float ms = span.Milliseconds;
this.duration = Mathf.Abs(ms * 0.001f); // Convert to seconds
}
private static void ParseLevelUp(FRSEvent frsEvent, ReplayData replayData)
{
string[] levelUpData = frsEvent.EventDetail.Split(new[] { EVENT_MSG_DELIMITER }, StringSplitOptions.None); //PlayerID//ItemId
int playerId = int.Parse(levelUpData[0]);
int newLevel = int.Parse(levelUpData[1]);
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerGameId(playerId);
playerInfo.ServantLevel = newLevel;
}
private game GetNewGame(ReplayData replayData, server dbServer, frsDb db)
{
int gameId = 0;
if (db.game.Any())
{
gameId = db.game.Max(g => g.GameID) + 1; //Generate Max GameID + 1
}
game fateGame = new game
{
GameID = gameId,
GameName = replayData.GameName,
Log = String.Join("\n", replayData.GameChatMessage.ToArray()),
MatchType = replayData.GameMode.ToString(),
MapVersion = ReplayData.MapVersion,
Duration = new TimeSpan(0, 0, 0, 0, (int)replayData.ReplayHeader.ReplayLength),
PlayedDate = replayData.GameDateTime,
ReplayUrl = replayData.ReplayUrl,
FK_ServerID = dbServer.ServerID,
TeamOneWinCount = replayData.TeamOneVictoryCount,
TeamTwoWinCount = replayData.TeamTwoVictoryCount
};
if (replayData.IsForfeitedGame)
{
fateGame.IsForfeitedGame = true;
if (replayData.ForfeitedTeam == ForfeitedTeam.T1)
{
fateGame.Result = GameResult.T2W.ToString();
}
else if (replayData.ForfeitedTeam == ForfeitedTeam.T2)
{
fateGame.Result = GameResult.T1W.ToString();
}
else
{
throw new InvalidDataException("Could not determine forfeiting team");
}
}
else
{
if (replayData.TeamOneVictoryCount > replayData.TeamTwoVictoryCount)
{
fateGame.Result = GameResult.T1W.ToString();
}
else if (replayData.TeamOneVictoryCount < replayData.TeamTwoVictoryCount)
{
fateGame.Result = GameResult.T2W.ToString();
}
else
{
fateGame.Result = GameResult.NONE.ToString();
}
}
return(fateGame);
}
private List <gameplayerdetail> GetGamePlayerDetailList(ReplayData replayData, IEnumerable <player> dbPlayers, game fateGame, server dbServer,
frsDb db)
{
List <gameplayerdetail> fateGamePlayerDetailList = new List <gameplayerdetail>();
foreach (player player in dbPlayers)
{
PlayerInfo playerInfo = replayData.GetPlayerInfoByPlayerName(player.PlayerName);
if (playerInfo == null)
{
throw new Exception(String.Format("Player Name not found during GamePlayerDetailList module. Input: {0}",
player.PlayerName));
}
gameplayerdetail fateGamePlayerDetail = new gameplayerdetail();
fateGamePlayerDetail.FK_GameID = fateGame.GameID;
fateGamePlayerDetail.FK_PlayerID = player.PlayerID;
fateGamePlayerDetail.FK_ServerID = dbServer.ServerID;
herotype playerHeroType = db.herotype.FirstOrDefault(x => x.HeroUnitTypeID == playerInfo.ServantId);
if (playerHeroType == null)
{
throw new Exception(String.Format("DB Error: Unknown hero type id: {0}", playerInfo.ServantId));
}
fateGamePlayerDetail.FK_HeroTypeID = playerHeroType.HeroTypeID;
fateGamePlayerDetail.Kills = playerInfo.Kills;
fateGamePlayerDetail.Deaths = playerInfo.Deaths;
fateGamePlayerDetail.Assists = playerInfo.Assists;
fateGamePlayerDetail.Team = (playerInfo.Team + 1).ToString();
fateGamePlayerDetail.DamageTaken = playerInfo.DamageTaken;
fateGamePlayerDetail.DamageDealt = playerInfo.DamageDealt;
fateGamePlayerDetail.HeroLevel = playerInfo.ServantLevel;
if (fateGame.Result == GameResult.NONE.ToString())
{
fateGamePlayerDetail.Result = GamePlayerResult.NONE.ToString();
}
else if (fateGame.Result == GameResult.T1W.ToString())
{
fateGamePlayerDetail.Result = playerInfo.Team == 0
? GamePlayerResult.WIN.ToString()
: GamePlayerResult.LOSS.ToString();
}
else if (fateGame.Result == GameResult.T2W.ToString())
{
fateGamePlayerDetail.Result = playerInfo.Team == 1
? GamePlayerResult.WIN.ToString()
: GamePlayerResult.LOSS.ToString();
}
else
{
throw new Exception(String.Format("Unexpected GameResult enumeration. Input: {0}",
fateGame.Result));
}
fateGamePlayerDetailList.Add(fateGamePlayerDetail);
}
return(fateGamePlayerDetailList);
}
private void ParseGameReplayDataFromBlock(byte[] dataBlockBytes, ReplayData replayData, int currIndex = 0)
{
uint accumulatedReplayTime = 0;
while (currIndex < dataBlockBytes.Length)
{
switch (dataBlockBytes[currIndex])
{
case 0x00: //End of replay
while (currIndex < dataBlockBytes.Length)
{
if (dataBlockBytes[currIndex] != 0x00)
{
throw new InvalidDataException(
String.Format("End of replay expected, but there's still data available. CurrIndex: {0}, Input: {1}",
currIndex, dataBlockBytes[currIndex]));
}
currIndex++;
}
break;
case 0x1A:
currIndex += 5; //Unknown. Skip
break;
case 0x1B:
currIndex += 5; //Unknown. Skip
break;
case 0x1C:
currIndex += 5; //Unknown. Skip
break;
case 0x1E: case 0x1F: //TimeSlot block
currIndex++;
ParseTimeSlotBlock(replayData, ref currIndex, ref accumulatedReplayTime, dataBlockBytes);
break;
case 0x17: case 0x54: //Player left
currIndex += 14;
break;
case 0x20: //Chat message
currIndex++;
var chatMessage = GetChatMessage(replayData, ref currIndex, dataBlockBytes);
replayData.AddChatMessage(chatMessage);
break;
case 0x22:
currIndex += 6; //Checksum or Random number/seed
break;
case 0x23:
currIndex += 11; //Unknown
break;
case 0x2F:
currIndex += 9; //Game end countdown
break;
default:
throw new Exception(String.Format("Unexpected Action at CurrIndex : {0}, Action Input : {1}" ,currIndex,dataBlockBytes[currIndex]));
}
}
}
private void OnLoadReplaySuccess(ReplayData repData)
{
STGData data = new STGData();
data.stageName = repData.info.stageName;
data.characterIndex = repData.info.characterIndex;
data.isReplay = true;
data.seed = repData.seed;
_fsm.SetNextStateId((int)eGameState.STG, data);
}
// Saves data to be played back later
private ReplayData Save_Values()
{
ReplayData new_replay = new ReplayData();
new_replay.player_pos = player_transform.position;
new_replay.player_rot = player_rotation_transform.rotation;
new_replay.timestamp = time;
return(new_replay);
}
private static IEnumerator <YieldInstruction> continueReplay(ReplayData replay, SOSMail rescueMail)
{
GameManager.Instance.BGM("", true);
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.FadeOut(false)));
DataManager.Instance.MsgLog.Clear();
//load that up instead if found
GameState state = replay.ReadState();
DataManager.Instance.SetProgress(state.Save);
LuaEngine.Instance.LoadSavedData(DataManager.Instance.Save); //notify script engine
ZoneManager.LoadFromState(state.Zone);
//NOTE: In order to preserve debug consistency, you SHOULD set the language to that of the quicksave.
//HOWEVER, it would be too inconvenient for players sharing their quicksaves, thus this feature is LEFT OUT.
DataManager.Instance.Loading = DataManager.LoadMode.Loading;
DataManager.Instance.CurrentReplay = replay;
if (rescueMail != null)
{
DataManager.Instance.Save.Rescue = new RescueState(rescueMail, false);
}
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentZone.OnInit()));
if (DataManager.Instance.Save.NextDest.IsValid())
{
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.MoveToZone(DataManager.Instance.Save.NextDest)));
}
else
{
//no valid next dest happens when the player has saved in a ground map in the middle of an adventure
DataManager.Instance.ResumePlay(DataManager.Instance.CurrentReplay.RecordDir, DataManager.Instance.CurrentReplay.QuicksavePos);
DataManager.Instance.CurrentReplay = null;
GameManager.Instance.SetFade(true, false);
DataManager.Instance.Loading = DataManager.LoadMode.None;
if (ZoneManager.Instance.CurrentMapID.Segment > -1)
{
GameManager.Instance.MoveToScene(Dungeon.DungeonScene.Instance);
GameManager.Instance.BGM(ZoneManager.Instance.CurrentMap.Music, true);
}
else
{
GameManager.Instance.MoveToScene(Ground.GroundScene.Instance);
GameManager.Instance.BGM(ZoneManager.Instance.CurrentGround.Music, true);
}
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.FadeIn()));
}
}
public ReplayServer(ReplayData replayData)
{
this.replayData = replayData;
this.httpListener = new HttpListener();
this.requestManager = new RequestManager(replayData);
this.listenTask = new Task(() => this.Listen());
this.httpListener.Prefixes.Add("http://localhost:8080/");
}
//Length must be 20 minutes or more
private static bool IsGameDurationValid(ReplayData fateReplayData)
{
TimeSpan gameDuration = new TimeSpan(0, 0, 0, 0, (int)fateReplayData.ReplayHeader.ReplayLength);
if (gameDuration.TotalMinutes < 25)
{
logger.Trace("Game duration is too short. Must be 25 minutes or more");
return(false);
}
return(true);
}
public override void Awake()
{
if( GameStatusInterfacer.GameMode != GameDefine.InputType.Replay )
{
enabled = false;
return;
}
replayData = SaveLoad.LoadReplayData( GameStatusInterfacer.ReplayId );
Random.seed = replayData.Seed;
upKeyFrameLoader.Read( replayData.UpKeyList );
downKeyFrameLoader.Read( replayData.DownKeyList );
leftKeyFrameLoader.Read( replayData.LeftKeyList );
rightKeyFrameLoader.Read( replayData.RightKeyList );
fireKeyFrameLoader.Read( replayData.FireKeyList );
specialKeyFrameLoader.Read( replayData.SpecialKeyList );
shiftKeyFrameLoader.Read( replayData.ShiftKeyList );
}
/// <summary>
/// Constructors a new player.
/// </summary>
public Player(Level level, Vector2 start, ReplayData replay)
{
this.replayData = new ReplayData();
int positionsToCreate = (replay == null ? 0 : replay.StreamCount);
this.ghostData = replay;
for (int i = 0; i <= positionsToCreate; i++)
{
this.sprites.Add(new AnimationPlayer());
this.playerPositions.Add(Vector2.Zero);
this.playerVelocities.Add(Vector2.Zero);
this.isOnGround.Add(true);
this.previousBottom.Add(0.0f);
this.jumpTime.Add(0.0f);
this.isJumping.Add(false);
this.wasJumping.Add(false);
this.movement.Add(0.0f);
this.flips.Add(true);
this.playerStates.Add(PlayerState.Alive);
}
this.level = level;
LoadContent();
Reset(null, start);
}
protected override string GetInformation(ReplayData replayData)
{
return GameDefine.StageTypeString( replayData.StageType );
}
// var textMesh = GetComponent<TextMesh>();
//
// var replayData = SaveLoad.LoadReplayData( id );
// if( replayData == null )
// {
// textMesh.text = nullString;
// }
// else
// {
// var timeStamp = new System.DateTime( replayData.TimeStamp );
// textMesh.text = StringAsset.Format(
// "ReplayFileName",
// id.ToString( "00" ),
// timeStamp.ToString( "yyyy/MM/dd HH:mm" ),
// StringAsset.Get( string.Format( "Player{0}_Name", replayData.PlayerId ) ),
// replayData.Difficulty.ToString(),
// "-- " + GameDefine.StageTypeString( replayData.StageType ) + " --"
// );
// }
protected override string GetInformation(ReplayData replayData)
{
return new System.DateTime( replayData.TimeStamp ).ToString( "yyyy/MM/dd HH:mm" );
}
protected override string GetInformation(ReplayData replayData)
{
return replayData.Difficulty.ToString();
}
void Awake()
{
if( GameStatusInterfacer.GameMode == GameDefine.InputType.Replay )
{
enabled = false;
return;
}
var now = System.DateTime.Now;
var seed = (now.Millisecond * now.Second * now.Minute) % 19911016;
Random.seed = seed;
replayData = new ReplayData(
seed,
GameStatusInterfacer.PlayerId,
GameStatusInterfacer.StageId,
GameStatusInterfacer.Difficulty,
GameStatusInterfacer.PlayStyle
);
}
protected override string GetInformation(ReplayData replayData)
{
return StringAsset.Get( string.Format( "Player{0}_Name", replayData.PlayerId ) );
}
protected abstract string GetInformation( ReplayData replayData );
