// -----------------------------------------------------------------------------------
public void Reset()
{
characterFile = null;
for (int i = 0; i < Config.Rounds; i++)
{
icons[i].SetUnlocked(unavailableSprite);
}
}
// --- MonoBehaviour ----------------------------------------------------------------------------
// -----------------------------------------------------------------------------------
// --- Methods ----------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------
public void SetCharacter(CharacterFile.File file)
{
characterFile = file;
characterImage.sprite = file == null ? randomCharacter.avatar : file.baseSheet.avatarA;
nameImage.sprite = file == null ? randomCharacter.name : file.baseSheet.name;
nameAnimation.Stop();
nameAnimation.Play();
}
// -----------------------------------------------------------------------------------
IEnumerator ShowCoroutine(CharacterFile.File characterFile, int round)
{
// deselect everything while showing the image
GameObject prevSelection = EventSystem.current.currentSelectedGameObject;
EventSystem.current.SetSelectedGameObject(null);
RawImage target = characterFile.IsPortrait(round) ? portrait : landscape;
// transition to black, load the images
yield return(StartCoroutine(Transition.instance.Show()));
CharacterFile.RoundImages images = characterFile.LoadRound(round);
target.texture = images.baseImage;
target.enabled = true;
artist.text = "ARTIST:" + characterFile.artist.ToUpper();
localBackground.SetActive(true);
yield return(StartCoroutine(Transition.instance.Hide()));
// wait
yield return(null);
while (!Input.GetButtonDown("Cut"))
{
yield return(null);
}
// show stats
SoundManager.instance.PlaySFX("ui_sweep_in");
stats.Show(round, characterFile.guid);
// wait
yield return(null);
while (!Input.GetButtonDown("Cut"))
{
yield return(null);
}
// transition out, hide the stats and images
yield return(StartCoroutine(Transition.instance.Show()));
stats.Hide();
localBackground.SetActive(false);
artist.text = "";
target.enabled = false;
yield return(StartCoroutine(Transition.instance.Hide()));
// disable the game object
gameObject.SetActive(false);
// restore selection
EventSystem.current.SetSelectedGameObject(prevSelection);
}
// --- MonoBehaviour ----------------------------------------------------------------------------
// -----------------------------------------------------------------------------------
// --- Methods ----------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------
public void Show(CharacterFile.File characterFile, int round)
{
stats = GetComponentInChildren <Stats>(true);
stats.Hide();
landscape.enabled = false;
portrait.enabled = false;
localBackground.SetActive(false);
artist.text = "";
gameObject.SetActive(true);
StartCoroutine(ShowCoroutine(characterFile, round));
}
// -----------------------------------------------------------------------------------
IEnumerator StartGame()
{
state = State.StartingGame;
// can't really select anything
if (characterGrid.isEmpty)
{
string msg = "NO CHARACTERS AVAILABLE";
yield return(StartCoroutine(PopupManager.instance.ShowMessagePopup(msg)));
yield break;
}
// select random character if needed
if (selected == null)
{
selected = characterGrid.SelectRandomCharacter();
}
avatar.SwitchImage();
Game.Controller.sourceFile = selected;
// select skill
yield return(StartCoroutine(PopupManager.instance.ShowSkillPopup()));
// skill select canceled?
if (PopupManager.instance.skill == Game.Skill.Type.INVALID)
{
avatar.SwitchImage();
StartCoroutine(SelectingCharacter());
yield break;
}
Debug.Log("Starting game");
// disable the graphics raycaster to avoid inputing anything while loading
GetComponent <GraphicRaycaster>().enabled = false;
// set and save selected skill
Data.Options.instance.skill = PopupManager.instance.skill;
Data.Options.instance.Save();
// fade out BGM and destroy sound manager (in game has its own manager)
SoundManager.instance.FadeoutBGM(1f);
yield return(new WaitForSeconds(1f));
// start game
yield return(StartCoroutine(Transition.instance.Show()));
SceneManager.LoadScene("Game");
}
// -----------------------------------------------------------------------------------
void SetCharacterFile(CharacterFile.File file)
{
if (file != null)
{
bool isNew = !Data.SaveFile.instance.GetCharacterStats(file.guid).played;
GameObject newImage = transform.Find("New").gameObject;
newImage.SetActive(isNew);
}
_characterFile = file;
Image icon = transform.Find("Icon").GetComponent <Image>();
icon.sprite = file.baseSheet.icon;
}
// -----------------------------------------------------------------------------------
/// <summary>
/// Add an icon to the character grid
/// </summary>
public CharacterIcon AddCharacter(CharacterFile.File file)
{
CharacterIcon newIcon = Instantiate(sampleIcon, pagesRoot, true);
newIcon.name = file.guid;
newIcon.characterFile = file;
newIcon.gameObject.SetActive(true);
newIcon.selected += OnCharacterSelected;
newIcon.highlighted += OnCharacterHighlighted;
availableCharacters.Add(newIcon);
return(newIcon);
}
// -----------------------------------------------------------------------------------
/// <summary>
/// Callback from the character icon, when a character gets selected.
/// </summary>
private void OnCharacterSelected(CharacterIcon icon)
{
if (icon == randomButton)
{
selected = null;
avatar.SetCharacter(null);
roundImages.Reset();
}
else
{
selected = icon.characterFile;
avatar.SetCharacter(selected);
roundImages.SetCharacter(selected);
}
}
// --- MonoBehaviour ----------------------------------------------------------------------------
// -----------------------------------------------------------------------------------
void Start()
{
#if UNITY_EDITOR
if (sourceFile == null)
{
sourceFile = new CharacterFile.File(DEBUG_file);
}
#endif
if (SoundManager.instance == null)
{
Instantiate(Resources.Load("Sound Manager"));
}
cameraController = Camera.main.GetComponent <CameraController>();
sourcePlayArea.gameObject.SetActive(false);
// character is now set as played
Data.SaveFile saveFile = Data.SaveFile.instance;
Data.CharacterStats stats = saveFile.GetCharacterStats(sourceFile.guid);
if (!stats.played)
{
stats.played = true;
saveFile.Save();
}
// randomize bosses (we have 3, but need 4)
roundBoss = new List <Enemy>(sourcePlayArea.GetBosses());
roundBoss.Shuffle();
roundBoss.Add(roundBoss[Random.Range(0, roundBoss.Count)]);
// basic initialization
round = 0;
livesLeft = Config.instance.startLives;
Skill.instance.Initialize();
Timer.instance.timedOut += OnTimerTimedOut;
BonusItemManager.instance.InitializeGame(sourceFile.availableRounds);
// Bonus manager event handling
BonusItemManager.instance.bonusAwarded += OnBonusAwarded;
// start the first round
StartCoroutine(InitializeRound(false));
}
// -----------------------------------------------------------------------------------
/// <summary>
/// Loads all character sheets and sets up icons
/// </summary>
/// <returns></returns>
IEnumerator LoadCharacterSheets()
{
Debug.Log("Loading character files");
string[] files = System.IO.Directory.GetFiles(CharacterFile.File.dataPath, "*.chr");
foreach (string file in files)
{
CharacterFile.File charFile = new CharacterFile.File(file);
CharacterIcon icon = characterGrid.AddCharacter(charFile);
icon.selected += OnCharacterSelected;
yield return(null);
}
// wait until the charcter grid finishes initializing
while (!characterGrid.isReady)
{
yield return(null);
}
characterGrid.Paginate();
characterGrid.SelectFirst();
}
// -----------------------------------------------------------------------------------
public void SetCharacter(CharacterFile.File characterFile)
{
bool saveNeeded = false;
stats = Data.SaveFile.instance.GetCharacterStats(characterFile.guid);
this.characterFile = characterFile;
for (int i = 0; i < Config.Rounds; i++)
{
if (stats.rounds[i].cleared)
{
// only play the animation the first time you unlock an image
if (stats.rounds[i].lockAnimationPlayed)
{
icons[i].SetUnlocked(characterFile.baseSheet.roundIcons[i]);
}
else
{
icons[i].AnimateUnlock(characterFile.baseSheet.roundIcons[i]);
stats.rounds[i].lockAnimationPlayed = true;
saveNeeded = true;
}
}
else if (i < characterFile.availableRounds)
{
icons[i].SetLocked();
}
else
{
icons[i].SetUnlocked(unavailableSprite);
}
}
if (saveNeeded)
{
Data.SaveFile.instance.Save();
}
}
