// Use this for initialization
void Start()
{
string quizId = GameDataStore.Get().selectedQuiz;
if (quizId == "")
{
quizId = "1";
}
resultView.OnResultNextButtonPressed += OnResultNextButtonPressed;
resultView.OnResultRetryButtonPressed += OnResultRetryButtonPressed;
quizzesManager = FindObjectOfType(typeof(QuizzesManager)) as QuizzesManager;
GetComponent <InputDetector>().OnTouchReleaseAnywhere += OnTouchReleaseAnywhere;
viewSlider = GetComponentInChildren <ViewSlider>();
questionViewLayouts = new List <QuestionViewLayout>(FindObjectsOfType <QuestionViewLayout>());
keyboardManager = FindObjectOfType <KeyboardManager>();
quiz = quizzesManager.GetQuiz(quizId);
if (quiz != null)
{
StartQuiz();
}
InitializePlayAds();
}
// Use this for initialization
void Start()
{
backEnd = FindObjectOfType <BackendCommunicator>();
backEnd.OnWeekQuizDownloadComplete += OnWeekQuizDownloadComplete;
backEnd.OnWeekQuizDownloadFail += OnWeekQuizDownloadFail;
ratePopup = GetComponentInChildren <RatePopup>();
AnimationHelper.SetToBeginning(logoAnimation);
AnimationHelper.SetToBeginning(playButtonAnimation);
AnimationHelper.SetToBeginning(bottomButtonsAnimation);
GameDataStore.Get().playTimes++;
GameDataStore.Get().Save();
bool bol = true;
Debug.Log("bool = " + bol.ToString());
if (isFirstTime)
{
backEnd.GetWeeklyQuizzes();
isFirstTime = false;
}
else
{
PlayStartAnimations();
}
}
private List <Quiz> ParseQuizzes(string quizzesData)
{
List <Quiz> quizzesFromStore = new List <Quiz>();
string[] quizDataObjs = quizzesData.Split(OBJ_SEPAR);
try
{
foreach (string quizData in quizDataObjs)
{
if (quizData != "")
{
string[] dataFields = quizData.Split(PARAM_SEPAR);
string xml = dataFields[0];
int points = int.Parse(dataFields[1]);
Quiz quiz = xmlManager.LoadXml(xml)[0];
quiz.points = points;
quizzesFromStore.Add(quiz);
}
}
}
catch (System.Exception e)
{
Debug.Log("Error: clear quizzesData " + e);
GameDataStore.Get().quizzesData = "";
GameDataStore.Get().Save();
}
return(quizzesFromStore);
}
private void Start()
{
var dataStore = new GameDataStore();
if (encrypted)
{
_jsonSaver = new EncryptedJsonSaver <GameDataStore>("encrypted_save");
dataStore.MasterVolume = 0.5f;
}
else
{
_jsonSaver = new JsonSaver <GameDataStore>("normal_save");
dataStore.MasterVolume = 0.8f;
}
_button.onClick.AddListener(() => _jsonSaver.Save(dataStore));
_decodeButton.onClick.AddListener(() =>
{
try
{
if (_jsonSaver.Load(out GameDataStore data))
{
Debug.Log(data.MasterVolume);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
});
}
internal DesignerDataViewModel()
{
GameGroups = new ObservableCollection <GameGroup>();
var gameInfos = new List <GameInformation>();
var rand = new Random(DateTime.Now.Millisecond);
GameDataStore emptyGameDataStore = new GameDataStore();
gameInfos.Add(new GameInformation(emptyGameDataStore, "Jesus vs Kim", GameType.OfflineTwoPlayer, DateTime.Now - new TimeSpan(rand.Next(100000)), 4, true));
gameInfos.Add(new GameInformation(emptyGameDataStore, "BenCohen", GameType.OfflineTwoPlayer, DateTime.Now - new TimeSpan(rand.Next(100000)), 7, true));
gameInfos.Add(new GameInformation(emptyGameDataStore, "Jesse", GameType.OfflineTwoPlayer, DateTime.Now - new TimeSpan(rand.Next(100000)), 12, true));
gameInfos.Add(new GameInformation(emptyGameDataStore, "Peter", GameType.OfflineTwoPlayer, DateTime.Now - new TimeSpan(rand.Next(100000)), 1, true));
var activeGameGroup = new GameGroup(null, "Active Games", null, null, null);
foreach (var gameInfo in gameInfos)
{
activeGameGroup.Items.Add(new Game(gameInfo));
}
var completedGameGroup = new GameGroup(null, "Completed Games", null, null, null);
foreach (var gameInfo in gameInfos)
{
completedGameGroup.Items.Add(new Game(gameInfo));
}
GameGroups.Add(activeGameGroup);
GameGroups.Add(completedGameGroup);
}
/// <summary>
/// Link actions that reference other GameObjects.
/// All other GameObjects in dependent stores must already be Instantiated.
/// </summary>
/// <param name="data">UI GameData</param>
protected override void LinkData(UIData data)
{
var toolbar = MainMenu.GetComponent <Toolbar>();
// Link button children and actions
foreach (var buttonGroupData in data.ButtonGroups)
{
var buttonGroup = _buttonGroups[buttonGroupData.Name];
for (int i = 0; i < buttonGroupData.Buttons.Count; ++i)
{
var buttonData = buttonGroupData.Buttons[i];
var button = buttonGroup.Buttons[i];
// Link OnSelect Action -----------------------
if (buttonData.OnSelect is OpenSubMenuAction)
{
var openSubMenuAction = buttonData.OnSelect as OpenSubMenuAction;
var openSubMenuButtons = GameDataStore.Get <ButtonGroup>(GameDataType.ButtonGroup, openSubMenuAction.ButtonGroupName);
if (openSubMenuButtons == null)
{
GameLogger.FatalError("OpenSubMenuAction could not link to non-existant button group '{0}'", openSubMenuAction.ButtonGroupName);
}
button.OnSelect = () => toolbar.OpenSubMenu(openSubMenuButtons);
}
else if (buttonData.OnSelect is OpenWindowAction)
{
var openWindowAction = buttonData.OnSelect as OpenWindowAction;
if (!WindowManager.TryGetWindow(openWindowAction.WindowName, out Window _))
{
GameLogger.FatalError("OpenWindowAction could not link to non-existant window '{0}'", openWindowAction.WindowName);
}
button.OnSelect = () => WindowManager.OpenWindow(openWindowAction.WindowName, null);
}
else if (buttonData.OnSelect is OpenWindowWithDataAction)
{
var openWindowAction = buttonData.OnSelect as OpenWindowWithDataAction;
if (!WindowManager.TryGetWindow(openWindowAction.WindowName, out Window _))
{
GameLogger.FatalError("OpenWindowWithDataAction could not link to non-existant window '{0}'", openWindowAction.WindowName);
}
button.OnSelect = () => WindowManager.OpenWindow(openWindowAction.WindowName, openWindowAction.DataType, openWindowAction.DataName);
}
// Link OnDeselect Action -----------------------
if (buttonData.OnDeselect is CloseSubMenuAction)
{
button.OnDeselect = () => toolbar.CloseSubMenu();
}
else if (buttonData.OnDeselect is CloseWindowAction)
{
button.OnDeselect = () => WindowManager.CloseWindow();
}
}
}
}
public MainGame()
{
GameData = new GameDataStore();
networkHandler = new NetworkHandler(this);
GraphicsDeviceManager graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
ScreenManager = new ScreenManager(this, graphics);
}
public static GameDataStore Get()
{
if (instance == null)
{
instance = new GameDataStore();
instance.Load();
}
return(instance);
}
public void TryShow()
{
bool rated = GameDataStore.Get().rated;
int playTimes = GameDataStore.Get().playTimes;
if (!rated && playTimes > showRateAfter)
{
AnimateIn();
}
}
private void OnQuizSelected(QuizListItem item)
{
string quizId = item.GetQuizId();
GameDataStore.Get().selectedQuiz = quizId;
Debug.Log("OnQuizSelected() quizId: " + quizId);
Loader.LoadQuiz();
}
public async Task FetchGames()
{
LoadingGames = true;
var games = (await GameDataStore.GetAllAsync()).Select(x => new GameViewItem(x)).ToList();
foreach (var game in games)
{
await game.InitPlayerNamesString();
}
Games = games;
LoadingGames = false;
}
void HandleOnRatePressed()
{
GameDataStore.Get().rated = true;
GameDataStore.Get().Save();
HidePopup();
#if UNITY_ANDROID
Application.OpenURL(androidUrl);
#elif UNITY_IPHONE
Application.OpenURL(iosUrl);
#endif
}
// Use this for initialization
void Awake()
{
levelRequire = LevelsExperiencePointsArray.pointsArray;
gameData = GameDataStore.Get();
if (levelText != null)
{
levelText.text = gameData.level.ToString();
}
SetProgressBarScale(GetPercentage(gameData.exp, gameData.level));
}
private void Awake()
{
m_Store = Camera.main.GetComponent <GameDataStore>();
m_GameTracker = Camera.main.GetComponent <GameTracker>();
foreach (var toy in m_Store.BaseToys)
{
InstantiateToyButton(toy, BaseToyButtonContent);
}
foreach (var attachment in m_Store.ToyAttachments)
{
InstantiateAttachmentButton(attachment, AttachmentButtonContent);
}
}
void Start()
{
if (Achievements == null)
{
gameData = GameDataStore.Get();
string[] tempAchievementList = gameData.achievementList.Split("|".ToCharArray());
for (int i = 0; i < tempAchievementList.Length; i++)
{
Achievements[i] = JsonToAchievement(tempAchievementList[i]);
}
Debug.Log("load");
}
Debug.Log(Achievements[0]);
ValidateAchievements();
UpdateRewardPointTotals();
}
public async Task <bool> AddGameAsync()
{
if (!CanCreateGame())
{
return(false);
}
else
{
var game = new Game()
{
Name = Name,
Players = selectedPlayers.Select(x => x.RemoteId).ToArray()
};
return(await GameDataStore.AddAsync(game));
}
}
public void SaveQuizzes()
{
if (initialized)
{
string quizzesDataStr = QuizzesToString();
GameDataStore.Get().quizzesData = quizzesDataStr;
GameDataStore.Get().Save();
Debug.Log("SaveQuizzes() quizzesData= " + quizzesDataStr);
}
else
{
Debug.LogWarning("ERROR: No QuizzesManager found in scene!");
}
}
private async void Initialize(GameDataStore gameDataStore)
{
_gameDataStore = gameDataStore;
await ApplicationServices.ShareSourceService.Current.SetDataForShareSource(gameDataStore);
var gameInfo = await gameDataStore.GameDataService.GetGameInformationAsync(gameDataStore.GameID);
Side side = Side.White;
GameName = gameInfo.FriendlyName;
var gameState = await gameDataStore.GameDataService.GetGameStateAsync(gameDataStore.GameID);
List<TurnRecord> turnHistory = new List<TurnRecord>();
if (gameState != null)
{
gameState = gameState.TrimStart(Environment.NewLine.ToCharArray());
var reader = new StringReader(gameState);
string turnStr = null;
while ((turnStr = reader.ReadLine()) != null)
{
var turn = SerializationHelper.DeserializeTurnRecord(turnStr, side);
turnHistory.Add(turn);
side = side == Side.White ? Side.Black : Side.White;
}
}
_gameModel = new GameState(gameInfo);
_gameView = new GameView.GameView(GameBoard, this);
_whiteController = new LocalPlayerController(Side.White, _gameDataStore.GameDataService);
_blackController = new LocalPlayerController(Side.Black, _gameDataStore.GameDataService);
InitializeFromTurnHistory(turnHistory);
_whiteController.AttachTo(GameBoard, _gameModel);
_blackController.AttachTo(GameBoard, _gameModel);
_gameView.InitializeWithGameState(_gameModel);
if (gameInfo.IsActive)
{
var nextMoveController = gameInfo.NextToMove == Side.White ? _whiteController : _blackController;
nextMoveController.SetVisiblePositionsForPlayer();
}
else
{
IsEnabled = false;
}
}
private void LoadStoredQuizzes()
{
if (!initialized)
{
initialized = true;
xmlManager = new XMLManager();
storedQuizzesDataStr = GameDataStore.Get().quizzesData;
storedQuizzes = new List <Quiz>();
if (storedQuizzesDataStr != "")
{
// get all quizzes from stored quiz data string
storedQuizzes = ParseQuizzes(storedQuizzesDataStr);
}
}
}
private void Awake()
{
Store = GetComponent <GameDataStore>();
OrderTracker = GameObject.Find("OrderTracker").GetComponent <OrderTracker>();
LevelLoader = GameObject.Find("LevelChanger").GetComponent <LevelChanger>();
}
void HandleOnLaterPressed()
{
GameDataStore.Get().playTimes = 0;
AnimateOut();
}
public static void InitConfig(int enConfig, short keyType, List <GameData> dataList)
{
gameDataList[enConfig] = new GameDataStore((EnConfig)enConfig, keyType, dataList);
}
private void QuitQuiz()
{
GameDataStore.Get().Save();
Loader.LoadQuizList();
}
/// <summary>
/// Opens a window on screen using GameDataStore data.
/// </summary>
/// <param name="name">Name of the window to open.</param>
/// <param name="type">The type of game data to pass to the window.</param>
/// <param name="dataName">Name of the data to pass to the window.</param>
public void OpenWindow(string name, GameDataType type, string dataName)
{
object data = GameDataStore.Get(type, dataName);
OpenWindow(name, data);
}
