public IEnumerator WHEN_FillBatterySessionStorageFunctionCalled_THEN_BatterySessionStorageIsFilled()
{
BatterySessionManagement batterySessionManagement = new BatterySessionManagement();
batterySessionManagement.FillBatterySessionStorage();
BatterySessionStorage actualBatterySessionStorage = batterySessionManagement.batterySessionStorage;
PlayerStorage actualPlayer = actualBatterySessionStorage.Player;
yield return(null);
Assert.IsNotNull(actualBatterySessionStorage.BatterySessionId);
Assert.IsNotNull(actualPlayer);
Assert.AreEqual(typeof(Guid), actualPlayer.UserId.GetType());
Assert.AreEqual(typeof(int), actualPlayer.Age.GetType());
Assert.AreEqual(typeof(bool), actualPlayer.KeyBoard.GetType());
Assert.AreEqual(typeof(bool), actualPlayer.Mouse.GetType());
Assert.IsNull(actualBatterySessionStorage.SubScoreSeq);
Assert.IsNull(actualBatterySessionStorage.OverallScoreSeq);
Assert.IsNull(actualBatterySessionStorage.MiniGameOrder);
Assert.IsNotNull(actualBatterySessionStorage.BalloonsData);
Assert.IsNotNull(actualBatterySessionStorage.CatchTheThiefData);
Assert.IsNotNull(actualBatterySessionStorage.SquaresData);
Assert.IsNotNull(actualBatterySessionStorage.ImageHitData);
Assert.IsNotNull(actualBatterySessionStorage.CatchTheBallData);
Assert.IsNotNull(actualBatterySessionStorage.SaveOneBallData);
Assert.IsNotNull(actualBatterySessionStorage.JudgeTheBallData);
Assert.IsNotNull(actualBatterySessionStorage.UIInteractionData);
}
public void Inject(IPlayerClient client, UnityProject project)
{
m_Client = client;
m_Project = project;
m_Storage = new PlayerStorage(UnityEngine.Reflect.ProjectServer.ProjectDataPath, true, false);
}
// Streaming Events
public void OpenProject(Project project)
{
if (m_AuthClient == null)
{
Debug.LogError("Unable to open project without a Authentication Client.");
return;
}
if (m_SelectedProject != null)
{
Debug.LogError("Only one project can be opened at a time.");
return;
}
m_SelectedProject = project;
m_Client = new ReflectClient(this, m_AuthClient.user, m_AuthClient.storage, m_SelectedProject);
m_Client.manifestUpdated += OnManifestUpdated;
m_IsManifestDirty = false;
m_ReflectPipeline.InitializeAndRefreshPipeline(m_Client);
// TODO : SaveProjectData(project) saves "project.data" for the offline project.
// Maybe we need to move/remove this code depends on the design.
// "project.data" file is using to get "Offline Project List" and "Enable Delete Button" in the project option dialog now
var storage = new PlayerStorage(ProjectServer.ProjectDataPath, true, false);
storage.SaveProjectData(project);
}
public ActionResult Market()
{
PlayerStorage playerStorage = new PlayerStorage();
var model = new MainPageViewModel();
model.Players = playerStorage.GetAllPlayers();
return View(model);
}
public ActionResult Index()
{
PlayerStorage playerStorage = new PlayerStorage();
var model = new MainPageViewModel();
//model.Players = playerStorage.GetPlayersByAgeinterval(20, 25);
TeamDataStorage teamDataStorage = new TeamDataStorage();
Player player = new Player
{
Name = "Рафаэль Варан",
Age = 21,
Atack = 35,
Defence = 80,
Position = "защитник",
Price = 20000
};
//playerStorage.AddPlayer(player);
TeamData teamData = new TeamData
{
Budget = 100000,
Rate = 10,
PlayersNumber = 11,
MatchesPlayed = 20,
MatchesWin = 10,
MatchesDraw = 7,
MatchesLose = 3
};
teamDataStorage.AddTeamData(teamData);
//model.teamData = teamDataStorage.GetTeamData(0);
return View(model);
}
public void Tick()
{
var players = PlayerStorage.GetPlayers();
var finish = FieldStorage.GetFinishes();
foreach (var player in players)
{
if (player.IsSpotted)
{
_gameLoopView.ShowLoseGame();
GameIsOver = true;
}
}
if (finish.NodeIsTouched)
{
_gameLoopView.ShowWinGame();
GameIsOver = true;
}
if (GameIsOver)
{
if (Input.GetKeyDown(KeyCode.Space))
{
Restart();
}
}
}
public void Tick()
{
var guards = GuardStorage.GetGuards();
var players = PlayerStorage.GetPlayers();
foreach (var player in players)
{
foreach (var guard in guards)
{
if (CanSeeTarget(guard, player))
{
player.PlayerVisibleTimer += Time.deltaTime;
}
else
{
player.PlayerVisibleTimer -= Time.deltaTime;
}
player.PlayerVisibleTimer = Mathf.Clamp(player.PlayerVisibleTimer, 0, player.TimeToSpotPlayer);
float _visability = player.PlayerVisibleTimer / player.TimeToSpotPlayer;
guard.Color = Color.Lerp(Color.green, Color.red, _visability);
GuardStorage.UpdateItem(guard);
}
PlayerStorage.UpdateItem(player);
}
}
public static bool HasLocalData(Project project)
{
//TODO Need to find other way to get playerStorage or move this method to other
var storage = new PlayerStorage(UnityEngine.Reflect.ProjectServer.ProjectDataPath, true, false);
return(storage.HasLocalData(project));
}
IEnumerator LoginUser(string email, string password)
{
WWWForm form = new WWWForm();
form.AddField("email", email);
form.AddField("password", password);
webRequest = UnityWebRequest.Post($"{webService}/user/login", form);
yield return(webRequest.SendWebRequest());
if (webRequest.isNetworkError)
{
Debug.Log("Error en la peticion");
}
else
{
if (webRequest.responseCode == 200)
{
var json = JSON.Parse(webRequest.downloadHandler.text);
PlayerStorage.SaveId(json["user"]["email"], json["user"]["_id"]);
SceneManager.LoadScene("Main");
}
else
{
Debug.Log("User o password incorrecto");
}
}
}
public ActionResult Market()
{
PlayerStorage playerStorage = new PlayerStorage();
var model = new MainPageViewModel();
model.Players = playerStorage.GetAllPlayers();
return(View(model));
}
public ProjectDownloader(ProjectDownloaderSettings settings, IUpdateDelegate updateDelegate, UnityUser user, PlayerStorage playerStorage)
{
m_Settings = settings;
m_PlayerStorage = playerStorage;
m_UpdateDelegate = updateDelegate;
m_User = user;
SetUpdateDelegate(updateDelegate);
}
public IEnumerator WHEN_NameSet_THEN_NameGetFunctionWorks()
{
testPlayerStorage = new PlayerStorage();
testPlayerStorage.Name = "Jack";
string expectedName = "Jack";
yield return(null);
Assert.AreEqual(expectedName, testPlayerStorage.Name);
}
public ReflectClient(IUpdateDelegate updateDelegate, UnityUser user, PlayerStorage storage, UnityProject project)
{
m_Project = project;
m_User = user;
m_Storage = storage;
InitializeProjectClientListener();
updateDelegate.update += OnUpdate;
}
public IEnumerator WHEN_KeyboardSet_THEN_KeyboardGetFunctionWorks()
{
testPlayerStorage = new PlayerStorage();
bool expectedKeyboard = false;
testPlayerStorage.KeyBoard = false;
yield return(null);
Assert.AreEqual(expectedKeyboard, testPlayerStorage.KeyBoard);
}
public IEnumerator WHEN_MouseSet_THEN_MouseGetFunctionWorks()
{
testPlayerStorage = new PlayerStorage();
bool expectedMouse = true;
testPlayerStorage.Mouse = true;
yield return(null);
Assert.AreEqual(expectedMouse, testPlayerStorage.Mouse);
}
public PlayerStorage Save()
{
var store = new PlayerStorage
{
Name = Name,
Token = Token,
Entity = Entity.Save()
};
return(store);
}
public IEnumerator WHEN_UserIdSet_THEN_UserIdGetFunctionWorks()
{
testPlayerStorage = new PlayerStorage();
Guid expectedGuid = Guid.NewGuid();
testPlayerStorage.UserId = expectedGuid;
yield return(null);
Assert.AreEqual(expectedGuid, testPlayerStorage.UserId);
}
public IEnumerator WHEN_AgeSet_THEN_AgeGetFunctionWorks()
{
testPlayerStorage = new PlayerStorage();
int expectedAge = 18;
testPlayerStorage.Age = 18;
yield return(null);
Assert.AreEqual(expectedAge, testPlayerStorage.Age);
}
public PlayerController(IPlayerConfig config, IPlayerView view)
{
_modelGuid = PlayerStorage.CreateModel(config);
var model = PlayerStorage.GetItem(_modelGuid);
var position = FieldStorage.GetPlayerSpawn();
model.GridPosition = position;
model.Position = GridUtil.ConvertPointToPosition(position);
model.GridTargetPosition = position;
model.TargetPosition = GridUtil.ConvertPointToPosition(position);
_playerView = view;
}
public void SetUser(UnityUser user)
{
if (user == null || string.IsNullOrEmpty(user.UserId))
{
Debug.LogError("Invalid User");
}
// Storage
var storage = new PlayerStorage(ProjectServer.ProjectDataPath, true, false);
// Client
m_AuthClient = new AuthClient(user, storage);
ReflectPipelineFactory.SetUser(user, this, m_AuthClient, storage);
}
public IEnumerator WHEN_FillPlayerFunctionCalled_THEN_PlayerIsFilled()
{
BatterySessionManagement batterySessionManagement = new BatterySessionManagement();
// Call tested function
batterySessionManagement.FillPlayer();
PlayerStorage actualPlayer = batterySessionManagement.player;
yield return(null);
Assert.IsNotNull(actualPlayer);
Assert.AreEqual(typeof(Guid), actualPlayer.UserId.GetType());
Assert.AreEqual(typeof(int), actualPlayer.Age.GetType());
Assert.AreEqual(typeof(bool), actualPlayer.KeyBoard.GetType());
Assert.AreEqual(typeof(bool), actualPlayer.Mouse.GetType());
}
public IEnumerator WHEN_PlayerSet_THEN_PlayerObtained()
{
batterySessionStorage = new BatterySessionStorage();
PlayerStorage player = new PlayerStorage
{
Name = "Alan Turing",
Age = 108,
KeyBoard = true,
Mouse = false,
UserId = new Guid()
};
batterySessionStorage.Player = player;
yield return(null);
Assert.AreEqual(player, batterySessionStorage.Player);
}
public async Task JoinLobby(LobbyConnection c, Lobby l)
{
log.Debug("connection " + c + " joining lobby " + l);
using (var alock = await Data.Synchronizer.SetStateAsync(ModuleState.Writing))
{
if (c.Lobby != null)
{
throw new ArgumentException("Connection has already joined a lobby!");
}
if (l.LobbyState == LobbyState.Finished)
{
throw new LobbyStateException("Can not join finished game!");
}
Data.AddLobbyConnection(l, c);
try
{
var players = PlayerStorage.GetPlayerOfConnection(c.Connection);
await AddPlayerToLobby(players, l);
await Messenger.SendMessage(c.Connection, Messages.LobbyJoined(l));
await Messenger.SendMessage(c.Connection, Messages.GameModeChanged(l));
await Messenger.SendMessage(c.Connection, Messages.ReadyStates(l));
//await Messenger.SendMessage(c.Connection, Messages.LobbySettings(l));
await UpdateConnection(c);
}
catch (Exception ex)
{
log.Warn("connection " + c + " failed to join lobby " + l + ", reverting changes");
l.Connections.Remove(c.Connection.Id);
c.Lobby = null;
throw ex;
}
}
}
public IEnumerator WHEN_QuestionnaireSubmitted_THEN_PlayerInformationCorrectlyRecorded()
{
SimulateKeyboardInputFieldEntry(nameInputField, "Alan Turing");
SimulateKeyboardInputFieldEntry(ageInputField, "99");
keyboardToggleNo.isOn = true;
mouseToggleYes.isOn = true;
submitButton.onClick.Invoke();
yield return(null);
PlayerStorage actualPlayerStorage = QuestionnairePage.GetPlayer();
PlayerStorage expectedPlayerStorage = new PlayerStorage
{
Name = "Alan Turing",
Age = 99,
KeyBoard = false,
Mouse = true,
UserId = actualPlayerStorage.UserId
};
Assert.AreEqual(expectedPlayerStorage, actualPlayerStorage);
}
public async Task LeaveLobby(LobbyConnection connection, bool silent)
{
log.Debug("removing connection " + connection + " from lobby " + connection.Lobby);
using (var alock = await Data.Synchronizer.SetStateAsync(ModuleState.Writing))
{
var lobby = connection.Lobby;
if (lobby == null)
{
throw new LobbyStateException("Connection is not member in any lobby!");
}
log.Debug("connection " + connection.Connection.Id + " leaving lobby " + lobby.Id);
if (PlayerStorage.IsSynchronized(connection.Connection))
{
var players = PlayerStorage.GetPlayerOfConnection(connection.Connection).Where(p => lobby.Players.Contains(p)).ToArray();
await RemovePlayerFromLobby(players, lobby, silent);
}
lobby.Connections.Remove(connection.Connection.Id);
if (!silent && connection.Connection.State != ConnectionState.Disconnected)
{
await Messenger.SendMessage(connection.Connection, Messages.LobbyLeft());
}
connection.Lobby = null;
connection.PendingUpdates = 0;
if (lobby.Host == connection)
{
await MigrateHost(lobby);
}
}
}
public ActionResult Index()
{
PlayerStorage playerStorage = new PlayerStorage();
var model = new MainPageViewModel();
//model.Players = playerStorage.GetPlayersByAgeinterval(20, 25);
TeamDataStorage teamDataStorage = new TeamDataStorage();
Player player = new Player
{
Name = "Рафаэль Варан",
Age = 21,
Atack = 35,
Defence = 80,
Position = "защитник",
Price = 20000
};
//playerStorage.AddPlayer(player);
TeamData teamData = new TeamData
{
Budget = 100000,
Rate = 10,
PlayersNumber = 11,
MatchesPlayed = 20,
MatchesWin = 10,
MatchesDraw = 7,
MatchesLose = 3
};
teamDataStorage.AddTeamData(teamData);
//model.teamData = teamDataStorage.GetTeamData(0);
return(View(model));
}
// This method is called from the LoginManager component inside the sample Scene.
// This is the same LoginManager used in the Reflect Viewers.
// While in the Editor, the user is the current Unity account logged into the Unity Editor.
// Once logged in, we can list available projects by using a ProjectLister with an AuthClient.
public void OnUserLoggedIn(UnityUser user)
{
m_State = State.ListingProjects;
// A storage is required to specify where data are saved and cached
m_Storage = new PlayerStorage(Path.Combine(Application.dataPath, ".ReflectSamplesTemp"), false, false);
// Create a Authentication client from the current Unity user
m_AuthClient = new AuthClient(user, m_Storage);
var projectListerSettings = new ProjectListerSettings
{
OnProjectsRefreshCompleted = new ProjectListerSettings.ProjectsEvents(),
OnProjectsRefreshStarted = new UnityEvent()
};
projectListerSettings.OnProjectsRefreshCompleted.AddListener((projects) =>
{
// This is the callback for when all projects are done listing.
// For this sample, we populate a list that will be displayed as UI in the OnGUI method.
m_State = State.ProjectListed;
m_AvailableProjects = projects;
});
// Create a ProjectLister to enumerate all available projects in the cloud for this user
m_ProjectsLister = new ProjectsLister(projectListerSettings)
{
client = m_AuthClient
};
// Since ProjectLister runs in another thread, make sure to set the UpdateDelegate to be able to collect received data into the main thread.
m_ProjectsLister.SetUpdateDelegate(this);
// Start the ProjectLister thread. OnProjectsRefreshCompleted callback will be called when all projects are done listing.
m_ProjectsLister.Run();
}
public static PlayerSession Load(PlayerStorage store)
{
var session = new PlayerSession(store.Name, store.Token, (Player)store.Entity.ConstructEntity());
return(session);
}
async Task DownloadProject(IPlayerClient client, Project project, string folder)
{
lock (m_ProgressLock)
{
m_Progress = 0.0f;
}
var storage = new PlayerStorage(folder, false, true);
try
{
var manifestEntries = (await client.GetManifestsAsync()).ToArray();
onProgressChanged?.Invoke(0.0f);
var total = manifestEntries.Length;
var projectPercent = 1.0f / total;
var localManifests = new Dictionary <string, SyncManifest>();
IEnumerable <SourceProject> localSourceProjects = null;
try
{
localSourceProjects = storage.LoadProjectManifests(project).ToArray();
}
catch (ReflectVersionException)
{
if (manifestEntries.Length == 0)
{
throw new Exception($"Cannot open project {project.name} because it has been exported with a different version of Unity Reflect.");
}
}
if (localSourceProjects != null)
{
foreach (var sourceProject in localSourceProjects)
{
localManifests.Add(sourceProject.sourceId, sourceProject.manifest);
}
}
storage.SaveProjectData(project);
for (int i = 0; i < total; ++i)
{
var manifestEntry = manifestEntries[i];
localManifests.TryGetValue(manifestEntry.SourceId, out var oldManifest);
await DownloadManifestDiff(client, oldManifest, manifestEntry.Manifest, project, manifestEntry.SourceId, storage);
}
}
finally
{
client?.Dispose();
}
lock (m_ProgressLock)
{
m_Progress = 1.0f;
}
}
async Task DownloadManifestDiff(IPlayerClient client, SyncManifest oldManifest, SyncManifest newManifest,
UnityProject project, string sourceId, PlayerStorage storage)
{
List <ManifestEntry> entries;
if (oldManifest == null)
{
var content = newManifest.Content;
entries = content.Values.ToList();
}
else
{
ParseManifest(oldManifest.Content, newManifest.Content, out var modified, out var deleted);
entries = modified.ToList();
// TODO Handle deleted models
}
var destinationFolder = storage.GetSourceProjectFolder(project, sourceId);
var downloadFolder = Path.Combine(destinationFolder, k_TemporaryFolder);
var progress = new ProjectManagerInternal.DownloadProgress();
progress.SetTotal(entries.Count);
var tasks = entries.Select(entry => ProjectManagerInternal.DownloadAndStore(client, sourceId, entry, newManifest, downloadFolder, progress)).ToList();
// Don't forget the manifest itself
tasks.Add(ProjectManagerInternal.RunFileIOOperation(() =>
{
newManifest.EditorSave(downloadFolder);
return(Task.CompletedTask);
}));
// Wait for all download to finish
var task = Task.WhenAll(tasks);
while (!task.IsCompleted)
{
lock (m_ProgressLock)
{
m_Progress = progress.percent;
}
await Task.Delay(200);
}
// TODO Handle errors in the DownloadProgress
// Backward compatibility with local viewer cache that have SyncPrefab as a file.
var prefabPath = SyncInstance.GetPrefabPath(downloadFolder);
if (prefabPath == null)
{
var prefabName = sourceId + SyncPrefab.Extension;
var syncPrefab = SyncInstance.GenerateSyncPrefabFromManifest(prefabName, downloadFolder, newManifest);
var fullPath = Path.Combine(downloadFolder, prefabName);
PlayerFile.Save(syncPrefab, fullPath);
}
// Delete SyncInstances since they cannot be imported
var instancesFolder = Path.Combine(downloadFolder, "instances");
if (Directory.Exists(instancesFolder))
{
Directory.Delete(instancesFolder, true);
}
// Move all content from temporary download folder to the final destination
MoveDirectory(downloadFolder, destinationFolder);
}
public PlayerLogic()
{
playerStorage = new PlayerStorage();
}
public PlayerLogic()
{
playerStorage = new PlayerStorage();
}
public AuthClient(UnityUser user, PlayerStorage storage)
{
this.user = user;
this.storage = storage;
}
