void Awake()
{
numFrames = ES3.Load <int>("Frame Amount");
fps = ES3.Load <int>("FPS");
Recording = GameObject.Find("Main Camera").GetComponent <Recording>();
progress.value = 0;
progress.minValue = 0; progress.maxValue = numFrames;
frameProgress.value = 0;
frameProgress.minValue = 0; frameProgress.maxValue = numFrames;
Recording.enabled = false;
instruction.text = "Tap anywhere to start recording";
foreach (var obj in Resources.FindObjectsOfTypeAll <Transform>() as Transform[])
{
if (obj.gameObject.CompareTag("MoveOn"))
{
obj.gameObject.SetActive(false);
}
if (obj.gameObject.CompareTag("Stop"))
{
obj.gameObject.SetActive(false);
}
}
}
void LoadNextID()
{
if (ES3.KeyExists("NextID"))
{
nextID = ES3.Load <int>("NextID");
}
}
public override void Enter()
{
// Get FSMVariables objects required based on whether the user wants to save local variables, global variables or both.
var variableLists = new List <FsmVariables>();
if (loadFsmVariables.Value)
{
variableLists.Add(Fsm.Variables);
}
if (loadGlobalVariables.Value)
{
variableLists.Add(FsmVariables.GlobalVariables);
}
var dict = ES3.Load <Dictionary <string, object> >(key.Value, GetSettings());
foreach (var variableList in variableLists)
{
foreach (var fsmVariable in variableList.GetAllNamedVariables())
{
if (dict.ContainsKey(fsmVariable.Name))
{
fsmVariable.RawValue = dict[fsmVariable.Name];
}
}
}
}
public bool Load()
{
object playerDataObj;
try
{
playerDataObj = ES3.Load("myPlayerData");
}
catch
{
Debug.Log("Load catch failed");
return(false);
}
if (playerDataObj == null)
{
Debug.Log("Load failed");
return(false);
}
else
{
Debug.Log("Load success");
playerData = playerDataObj as PlayerData;
return(true);
}
}
private void Start()
{
playerController = GetComponent <CharacterController>();
playerController.enabled = false;
tDetection = GetComponent <TriggerDetection>();
keys = GetComponent <playerKeyHolder>();
playerRb = GetComponent <Rigidbody>();
controller = GetComponent <CharacterController>();
isMoving = false;
isSafe = false;
isDead = false;
isStarting = true;
Physics.gravity *= 2;
StartCoroutine(WaitForMusic());
if (ES3.KeyExists("posicao") && ES3.KeyExists("energia"))
{
lastCheckpointPos = ES3.Load <Vector3>("posicao");
lastCheckpointRot = ES3.Load <Quaternion>("rotacao");
Manager.current.turnOff = ES3.Load <bool>("energia");
transform.position = lastCheckpointPos;
transform.rotation = lastCheckpointRot;
}
else
{
lastCheckpointPos = transform.position;
lastCheckpointRot = transform.rotation;
}
playerController.enabled = true;
}
public void LoadData(bool shouldSave)
{
foreach (LevelSelectButton levelSelect in allGrassyLevels)
{
LevelSelectInfo lSelect = levelSelect.levelToTravelTo;
string loadString = "LevelData_" + lSelect.buildSceneNumber.ToString();
if (ES3.KeyExists(loadString))
{
LevelSaveData loadedData = ES3.Load <LevelSaveData>(loadString);
lSelect.levelCompletionData = new LevelCompletionData();
lSelect.levelCompletionData.completed = loadedData.completed;
lSelect.levelCompletionData.earnedStars = loadedData.stars;
lSelect.levelCompletionData.cratesUsed = loadedData.cratesDropped;
}
else
{
lSelect.levelCompletionData = new LevelCompletionData();
lSelect.levelCompletionData.completed = false;
lSelect.levelCompletionData.earnedStars = 0;
lSelect.levelCompletionData.cratesUsed = 0;
if (shouldSave)
{
SaveProgress(false, 0, 0, true, lSelect);
}
}
levelSelect.UpdateStars(grassyPalette);
}
UpdateUnlocks();
}
public override void Awake()
{
base.Awake();
settings = new ES3Settings(ES3.EncryptionType.AES);
if (ES3.KeyExists("IsContinue", "Stage.es3"))
{
if (ES3.Load <bool>("IsContinue", "Stage.es3"))
{
this.StageLoadData();
}
else
{
this.NotSaveChpaterEnter();
}
}
else
{
this.NotSaveChpaterEnter();
}
player = FindObjectOfType <CMovement>();
portal = this.transform.Find("Portal").GetComponent <CPortal>();
portal.SetChapterScene(this);
this.MoveStage();
}
public void Load(string saveFile)
{
_autoSaveFile = saveFile;
var gameManager = FindObjectOfType <GameManager>();
var gmDto = (GameManager.GameManagerDto)ES3.Load("game manager", saveFile);
var travelManager = FindObjectOfType <TravelManager>();
var tmDto = ES3.Load("travel manager", saveFile);
travelManager.RestoreState(tmDto);
var encounterManager = FindObjectOfType <EncounterManager>();
var emDto = ES3.Load("encounter manager", saveFile);
encounterManager.RestoreState(emDto);
if (string.Equals(gmDto.CurrentSceneName, GameManager.CombatSceneName, StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(SceneManager.GetActiveScene().name, GameManager.CombatSceneName,
StringComparison.OrdinalIgnoreCase))
{
LoadCombatManager();
}
else
{
SceneManager.sceneLoaded += LoadCombatManager;
}
}
gameManager.RestoreState(gmDto);
}
public void SyncBattleInfo(string playerId)
{
string filePath = string.Format("{0}/NormalBattle", playerId);
SyncCoin(ES3.Load <int>("Coin", filePath));
SyncCurSpawn(ES3.Load <int>("CurSpawn", filePath));
SyncHighestSpawn(ES3.Load <int>("HighestSpawn", filePath));
int count = 0;
for (int i = 0; i < 5; ++i)
{
if (ES3.KeyExists(string.Format("HeroID{0}", i), filePath))
{
++count;
}
}
for (int i = 0; i < count; ++i)
{
SyncBattleHero(playerId, i);
}
ByteBuffer data = new ByteBuffer();
data.writeByte(102);
data.writeByte(BattleService.BATTLE_START);
ServiceManager.PostMessageShortEx(data);
SyncCurWave(ES3.Load <int>("CurWave", filePath));
}
public void Load()
{
//Here we are taking the objects which have the scripts we want to reference and finding the scripts to reference from those objects
StatTracker statTrackerScript = statTrackerObject.GetComponent <StatTracker>();
TextChange textChangeScript = textChangeObject.GetComponent <TextChange>();
statTrackerScript.strength = ES3.Load <int>("strength");
statTrackerScript.corruption = ES3.Load <int>("corruption");
statTrackerScript.arcana = ES3.Load <int>("arcana");
//Not sure i did this right. in the load function the documentation says to do the key then the "default. Not sure I understood what a default is correctly
statTrackerScript.importantHappeningsList = ES3.Load("importantHappeningsList", new List <string>());
statTrackerScript.choiceTraits = ES3.Load("choiceTraits", new List <string>());
//We load the page we were on
textChangeScript.currentPage = ES3.Load <Page>("currentPage");
//This takes the information about the current page's text which should be displayed and puts it into the text object which is the main text of the story
textChangeScript.mainText.text = textChangeScript.currentPage.description;
//here we turn buttons to active or inactive
textChangeScript.ButtonActivationChanges(textChangeScript.currentPage.buttonOneVisible, textChangeScript.currentPage.buttonTwoVisible, textChangeScript.currentPage.buttonThreeVisible, textChangeScript.currentPage.buttonFourVisible);
//Here we update the text for buttons
textChangeScript.ButtonTextChanges(textChangeScript.currentPage.buttonOneText, textChangeScript.currentPage.buttonTwoText, textChangeScript.currentPage.buttonThreeText, textChangeScript.currentPage.buttonFourText);
Debug.Log("The Load Function was called");
}
public void loadSettings(string filename)
{
if (ES3.FileExists(this.fileName))
{
Setting = ES3.Load <SettingObject>("settings", this.fileName);
}
}
public void VerifyMainSaveFile()
{
OnSaveFileAccessed();
if (ES3.FileExists("main.es3"))
{
Debug.Log("Main save data exists.");
}
else
{
Debug.Log("Main save data does not exist.");
}
if (ES3.KeyExists("mostRecentStartup", "main.es3"))
{
Debug.Log("Welcome back! Last play session was " + ES3.Load <System.DateTime>("mostRecentStartup", "main.es3"));
}
ES3.Save <System.DateTime>("mostRecentStartup", System.DateTime.Now, "main.es3");
if (ES3.DirectoryExists(saveFilesDirectory))
{
foreach (var filename in ES3.GetFiles(saveFilesDirectory))
{
Debug.Log("Found save file: " + filename);
}
}
else
{
Debug.Log("No save files exist.");
}
}
public override void Awake()
{
base.Awake();
animator = this.GetComponent <Animator>();
this.fCurrentHealth = this.fStartHealth;
movement = this.GetComponent <CMovement>();
shooter = this.GetComponent <CShooter>();
this.flashTime = 0.25f;
if (ES3.KeyExists("CurrentHealth", "Player.es3"))
{
fCurrentHealth = ES3.Load <float>("CurrentHealth", "Player.es3");
fMaxHealth = ES3.Load <float>("MaxHealth", "Player.es3");
shield = ES3.Load <int>("Shield", "Player.es3");
}
else
{
ES3.Save <int>("Shield", shield, "Player.es3");
ES3.Save <float>("CurrentHealth", fCurrentHealth, "Player.es3");
ES3.Save <float>("MaxHealth", fMaxHealth, "Player.es3");
}
heartUI = GameObject.Find("Heart_UI").GetComponent <CHeartUI>();
heartUI.SetHeart((int)fCurrentHealth, (int)fMaxHealth, shield);
onDeath += EndGame;
}
private float GetMagneticHeading()
{
#if PLATFORM_ANDROID
if (!SystemInfo.supportsGyroscope || !ApplyCompassTiltCompensationOnAndroid || androidNativeCompass == null)
{
if (ES3.Load <bool>("Test"))
{
return(Camera.main.transform.rotation.eulerAngles.y);
}
else
{
return(Input.compass.magneticHeading);
}
//return Input.compass.magneticHeading;
}
return(androidNativeCompass.GetMagneticHeading());
// if (Screen.orientation == ScreenOrientation.Landscape)
// {
// return heading;// + 45;
// }
// else
// {
// return heading;
// }
#else
return(Input.compass.magneticHeading);
#endif
}
// ゲームモードごとにbestscoreを読み込み
// ない場合は0を返す
private int LoadBestScore(ModeType modeType)
{
switch (modeType)
{
case ModeType.Normal:
return(ES3.Load <int>(SaveDataKeys.NormalBestScore, SaveDataPaths.BestScoreDataPath, 0));
break;
case ModeType.Hard:
return(ES3.Load <int>(SaveDataKeys.HardBestScore, SaveDataPaths.BestScoreDataPath, 0));
break;
case ModeType.Aggressive:
return(ES3.Load <int>(SaveDataKeys.AggressiveBestScore, SaveDataPaths.BestScoreDataPath, 0));
break;
case ModeType.Expert:
return(ES3.Load <int>(SaveDataKeys.ExpertBestScore, SaveDataPaths.BestScoreDataPath, 0));
break;
}
return(-1);
}
public void NormalBattleSaveCurSpawn(string playerId, int curSpawn)
{
string filePath = string.Format("{0}/NormalBattle", playerId);
ES3.Save <int>("CurSpawn", curSpawn, filePath);
SyncCurSpawn(curSpawn);
NormalBattleSaveCurWave(playerId, 0);
filePath = string.Format("{0}/NormalBattle", playerId);
if (curSpawn > ES3.Load <int>("HighestSpawn", filePath))
{
ES3.Save <int>("HighestSpawn", curSpawn, filePath);
ConfigTable tbl = ConfigData.GetValue("NormalTask_Client");
if (tbl.m_Data.ContainsKey(curSpawn.ToString()))
{
ConfigRow row = tbl.GetRow(curSpawn.ToString());
switch (row.GetValue("Type"))
{
case "1":
{
int heroId = int.Parse(row.GetValue("Value"));
AddHero(playerId, heroId);
SyncHero(playerId, heroId);
break;
}
}
SyncBattleTask(curSpawn);
}
}
}
public void LoadSavedData()
{
if (!ES3.FileExists())
{
return;
}
if (ES3.KeyExists("Level"))
{
GameVo.CurrentLevelID = ES3.Load <int>("Level");
}
if (ES3.KeyExists("Vibration"))
{
GameVo.Vibration = ES3.Load <bool>("Vibration");
}
if (ES3.KeyExists("SFX"))
{
GameVo.SFX = ES3.Load <bool>("SFX");
}
if (ES3.KeyExists("Coin"))
{
GameVo.Coin = ES3.Load <int>("Coin");
}
}
public string AddPlayer(string account)
{
int iPlayerId = ES3.KeyExists("IncrementPlayerID") ? ES3.Load <int>("IncrementPlayerID") + 1 : 1;
ES3.Save <int>("IncrementPlayerID", iPlayerId);
string sPlayerId = iPlayerId.ToString();
ES3.Save <string>(account, sPlayerId, "Account");
string filePath = string.Format("{0}/PlayerInfo", sPlayerId);
ES3.Save <string>("PlayerName", sPlayerId, filePath);
ES3.Save <int>("GuideStep", 0, filePath);
AddHero(sPlayerId, 1006);
AddHero(sPlayerId, 1020);
filePath = string.Format("{0}/NormalBattle", sPlayerId);
ES3.Save <int>("Coin", 0, filePath);
ES3.Save <int>("CurSpawn", 0, filePath);
ES3.Save <int>("CurWave", 0, filePath);
ES3.Save <int>("HighestSpawn", 0, filePath);
return(sPlayerId);
}
void LoadHasYetGot()
{
if (ES3.KeyExists("hasYetGot_DailyReward"))
{
hasYetGot = ES3.Load <bool>("hasYetGot_DailyReward");
}
}
private async UniTaskVoid Start()
{
var token = this.GetCancellationTokenOnDestroy();
SetActiveButtons(false);
await MoveTitle(token);
SetActiveButtons(true);
await CallActiveAnimation(true, token);
var pushedButtonObservables =
modeButtons.Select(x =>
x.OnClickAsObservable
.Select(_ => x.ModeType)
);
// 押されたbuttonによってゲームモードを変える
pushedButtonObservables.Merge()
.Do(x => ES3.Save <ModeType>(SaveDataKeys.ModeType, x, SaveDataPaths.PuzzleDataPath))
.Select(x => new GameInfo(x))
.Subscribe(x => MoveScene(x, token).ToObservable())
.AddTo(this);
// 前回のデーターを読み込んで途中から開始
if (continueButton.gameObject.activeSelf)
{
continueButton.OnClickAsObservable
.Select(_ => new ContinueGameInfo(
ES3.Load <ModeType>(SaveDataKeys.ModeType, SaveDataPaths.PuzzleDataPath),
ES3.Load <int>(SaveDataKeys.PreviousScore, SaveDataPaths.PuzzleDataPath),
ES3.Load <List <TileInfo> >(SaveDataKeys.TileDataList, SaveDataPaths.PuzzleDataPath)))
.Subscribe(x => MoveScene(x, token).ToObservable())
.AddTo(this);
}
}
public void Load()
{
EventController.GameReloaded();
// Load the DB
questDatabase.quests = ES3.Load <Dictionary <string, int[]> >("QuestDatabase", "QuestDatabase.json");
List <string> questNamesToAdd = new List <string>();
// Get a list of quest slugs that were loaded
foreach (var quest in questDatabase.quests)
{
questNamesToAdd.Add(quest.Key);
}
// Assign in-progress quests, mark completed quests as completed
foreach (string questName in questNamesToAdd)
{
if (questDatabase.Completed(questName))
{
completedQuests.Add(questName);
}
else
{
AssignQuest(questName, true);
}
}
}
void LoadResetTime()
{
if (ES3.KeyExists("ResetTime"))
{
resetTime = ES3.Load <DateTime>("ResetTime");
}
}
private void Start()
{
statusEffects = ES3.Load <bool>("EffectStatus");
music.mute = ES3.Load <bool>("MusicStatus");
if (ES3.Load <bool>("EffectStatus") == true)
{
effectsText.text = ("EFECTOS: NO");
}
else
{
effectsText.text = ("EFECTOS: SI");
}
if (ES3.Load <bool>("MusicStatus") == true)
{
musicText.text = ("MÚSICA: NO");
}
else
{
musicText.text = ("MÚSICA: SI");
}
pauseUI.gameObject.SetActive(false);
for (i = 0; i < effects.Length; i++)
{
effects[i].GetComponent <AudioSource>();
effects[i].mute = ES3.Load <bool>("EffectStatus");
}
}
private void Start()
{
RealStateDuration = stateDurationMinutes * 60;
if (ES3.KeyExists("currentStateIndex") == true)
{
StateIndex = ES3.Load <int>("currentStateIndex");
if (StateIndex != 10)
{
methodName = "State" + StateIndex;
}
else
{
methodName = "State1";
}
}
else
{
methodName = WorldStartState;
}
Type thisType = this.GetType();
MethodInfo theMethod = thisType.GetMethod(methodName);
theMethod.Invoke(this, null);
}
// Start is called before the first frame update
void Start()
{
// string testStr = "我为歌狂 wo wei ge kuang 123!!!";
// Debug.Log("@@@ 原文："+testStr);
// string testEncrypt = CryptoPrefs.Encrypt(testStr);
// Debug.Log("@@@ 加密："+testEncrypt);
// string testDecrypt = CryptoPrefs.Decrypt(testEncrypt);
// Debug.Log("@@@ 解密："+testDecrypt);
var settings = new ES3Settings(ES3.EncryptionType.AES, "myPassword");
string path = "测试加密存档222";
string key = "key";
string testStr = "我为歌狂 wo wei ge kuang 123!!!";
// ES3.Save<testValueClass>(key, new testValueClass(), path, settings);
testValueClass testValue = ES3.Load <testValueClass>(key, path, settings);
// EZSave.Instance.InitRecord(path);
// EZSave.Instance.SaveRecord<testValueClass>(key, new testValueClass(), path);
// testValueClass testValue = EZSave.Instance.LoadRecord<testValueClass>(key, path);
Debug.Log("### testValue.str: " + testValue.str + " testValue.int：" + testValue.testInt);
// Debug.Log("@@@ 原文："+testStr);
// string testEncrypt = CryptoPrefs.Encrypt(testStr);
// Debug.Log("@@@ 加密："+testEncrypt);
// string testDecrypt = CryptoPrefs.Decrypt(testEncrypt);
// Debug.Log("@@@ 解密："+testDecrypt);
}
/// <summary>
/// 메뉴 로컬라이징
/// </summary>
private void SetTitleMenuChangeLanguageAction()
{
switch ((LanguageKeys)ES3.Load <int>("Language"))
{
case LanguageKeys.English:
_noText = "No Data";
for (int i = 0; i < _titleTexts.Count; i++)
{
_titleTexts[i].text = _languageArrE[i];
}
_titleTexts[1].fontSize = 26;
break;
case LanguageKeys.Korean:
_noText = "미표기";
for (int i = 0; i < _titleTexts.Count; i++)
{
_titleTexts[i].text = _languageArrK[i];
}
_titleTexts[1].fontSize = 23;
break;
default:
break;
}
}
private void LoadPlayer()
{
ES3.Load("Position", so.playerPosition);
ES3.Load("Health", so.health);
ES3.Load("Mana", so.mana);
ES3.Load("Lumen", so.lumen);
}
private string GetNaviID(string id)
{
string result = _noText;
int n = int.Parse(id);
if (n >= 11 && n <= 14)
{
n = 11;
}
if (n == 15)
{
n = 12;
}
switch ((LanguageKeys)ES3.Load <int>("Language"))
{
case LanguageKeys.English:
result = _navigationMessageE[n];
break;
case LanguageKeys.Korean:
result = _navigationMessageK[n];
break;
default:
break;
}
return(result);
}
void Start()
{
if (ES3.KeyExists("Current Outfit"))
{
currentOutfit = ES3.Load <GameObject>("Current Outfit");
}
}
// Update is called once per frame
void Update()
{
if (isMainCameraNull)
{
return;
}
float currentHeading = 0f;
float currentMagneticHeading = 0f;
float currentAccuracy = 0f;
if (ES3.Load <bool>("Test"))
{
currentHeading = Camera.main.transform.rotation.eulerAngles.y;
currentMagneticHeading = Camera.main.transform.rotation.eulerAngles.y;
currentAccuracy = 1;
}
else
{
currentHeading = Input.compass.trueHeading; // locationProvider.CurrentHeading.heading;
currentMagneticHeading = Input.compass.magneticHeading; // locationProvider.CurrentHeading.magneticHeading;
currentAccuracy = Input.compass.headingAccuracy; // locationProvider.Provider.CurrentHeading.accuracy;
}
text.text = "TRUE NORTH: " + currentHeading;
text1.text = "MAGNETIC NORTH: " + currentMagneticHeading;
text2.text = "ACCURACY: " + currentAccuracy;
rectTransform.rotation = Quaternion.Euler(0, 0, (float)currentMagneticHeading);
rectTransform1.rotation = Quaternion.Euler(0, 0, (float)currentHeading);
}
