Persona UI, Its A Lot Of Work

Persona UI, Its A Lot Of Work

So it’s been about a month and I felt it was about time I updated you’ll on the progress so far. I’m still working on the UI setups at the moment as they are required for the rest of the project to really function. Have been hoping between this project and another on and off all month. So I’ve only actually worked on this for about 10 or so days this month but the progress is worth showing.

Menu Management

With the amount of UI there is to do I needed to make a menu system that would let me switch between different menus with ease. Before I had a manager class that did this on context, but that was getting really messy really quickly. Instead of continuing with the messy setup I decided to refactoring it into something more useable.

The new setup is entirely static and is called in the displays logic for the active menu. The active menu then controls what buttons open what displays and runs the logic to open the new one and close the current if needed. Using an interface to keep it simple. So far this solution is proving to work quite well. Though I imagine I will, have to come back to it at some point and make further adjustments. An example of the new menu controller API in use to close one display & open another:

// API - uses type to open/close menus, with each being registered on the scene opening. 
// MenuController.OpenMenuCloseThis<TOpenMenuType, TCloseMenuType>();
// Below would switch from the skill select UI on the active persona to the detailed persona view display. 
MenuController.OpenMenuCloseThis<ViewPersonaDisplayController, SelectPersonaSkillDisplay>();

Persona Inspect

This is by far the most complex display in the entire project. But so far it’s not going too badly. I’ve managed to get then reveal mostly working and sorted a setup to show the active persona’s data. But there is still a long way to go. One of the challenges of this UI is the fact that it changes each time it’s opened or modified. With boxes randomly changing sizes etc. I have a feeling I’m going to need to work more on the UI polygon script to make it more reliable for all the use cases that are gonna crop up in the future.

P5R

My Version So Far

Some other bits include a popup description display that appears when inspecting the persona skills. I have setup a mockup for this display on the UI which works, but it needs to actually populate with data and appear still which it currently doesn’t. The other main progress is the stat level bars, these are a tad annoying as the actual “fill” is not set the actual value due to the background needing to take up more space than the fill. Currently I have the background taking the actual space while the fill uses a reduced size. But I still want to see if I can get it to update without needing such a workaround. There still a lot to-do on this display but I’m hoping to get it functionally working by the next update.

Data

In my last post I went over some of the data stuff I was working on with Google sheets, this is still an ongoing task with instant kill, healing and some passive skills still to work out and implementation for. Its tricky as a lot of these skills are very specific and working out a generic structure to store the data is proving tricky. But I am hoping to have the data done by the next update or two as it will be needed before I get fully into the gameplay and move implementation. I did fix a few issues here where data wasn’t updating object in the project, but I did some refactoring here and there to make the implementation on the dev side a bit easier. Most notable was the battle stats, so “Str, Ma, En, Ag, Lu”. The main change was to change the data from a struct to a class and to store all the data in a custom SerializableDictionary instead of individual values for ease of access. With getter/setter methods to access specific values by stat type. The code now looking like this:

/// <summary>
/// A container class to hold a persona's battle stats.
/// </summary>
[Serializable]
public class BattleStats
{
    /* ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
    |   Fields
    ───────────────────────────────────────────────────────────────────────────────────────────────────────────── */
    
    [SerializeField] private SerializableDictionary<PersonaBattleStat, int> stats;
    
    /* ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
    |   Constructors
    ───────────────────────────────────────────────────────────────────────────────────────────────────────────── */

    /// <summary>
    /// Makes a blank battle stats class.
    /// </summary>
    public BattleStats() { }


    /// <summary>
    /// Makes a new battle stats data with the dictionary entered.
    /// </summary>
    /// <param name="data">The data to set.</param>
    public BattleStats(SerializableDictionary<PersonaBattleStat, int> data)
    {
        stats = data;
    }
        
    /* ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
    |   Methods
    ───────────────────────────────────────────────────────────────────────────────────────────────────────────── */

    /// <summary>
    /// Gets the stat of the type entered.
    /// </summary>
    /// <param name="statType">The stat to get.</param>
    /// <returns>The stat value.</returns>
    public int GetStat(PersonaBattleStat statType)
    {
        if (stats.ContainsKey(statType))
        {
            return stats[statType];
        }
        
        return -1;
    }


    /// <summary>
    /// Sets the stat to the entered value.
    /// </summary>
    /// <param name="statType">The stat to edit.</param>
    /// <param name="value">The value to set to.</param>
    public void SetStat(PersonaBattleStat statType, int value)
    {
        if (!stats.ContainsKey(statType)) return;
        stats[statType] = value;
    }
}

Misc

In the last post I also covered affinities and their display. I mentioned i wasn’t going to do the two versions. Well I’ve changed my mind on that and now plan to implement the extended boxes in the future. The display just looks really off without the background behind the text. So expect an update on that soon. Otherwise progress is good and I’m pretty happy with how the project is going so far. Even played a little P5R to get some reference material and had to stop myself playing xD

That’s about it for this update, see you all in the next one.

So Much Data

So Much Data

Data Handling

After the first day I was spending time working on the data structure for all the data needed for persona’s which is a lot. The skills stuff I did on day 1 is great, but when thinking about it further I knew I’d need a way to generate a lot of skills and items without needing to do it all manually. As that would just take far too long and I would hate it all by the time I had created each skill by hand. This meant I needed to looking to ways of automating the data creation with some tool. For this I looked to see if there was any way to make a google sheet readable in Unity. Thankfully there was a nice short tutorial on downloading data to a csv format in Unity. I managed to make a system based on that, that would download a google sheet tab to a .csv file that I could then read and convert into the sciprtable objects as needed.

The code is nothing special here and is rather rigid as I made it purely to make scriptable objects and not for general game data use. Though down the line I may looking to make a system like that. But the good thing is that it works and makes handling skills & later the custom personas considerably easier.


Affinites Display UI

Other than that I did a bit more UI work and setup a display for the persona skill affinites. These being the skills they are weak or strong to etc. The display in persona 5 is fairly dynamic with two states for this, one for no text but unkown affinities and another for when there is an affinity. But, due to a lack of good screenshots to mock it up with and the hassle of mathcing it for each icon I’ve decided that for my version to just use the one version and just update the text.

The good news is the unknown state that I’m matching from persona 5 look spretty accurate and cool. See the left for how it looks currently. Note that there is a white background behind it in the final UI setup. I haven’t worked on any of the logic for hooking this up yet, but the data it will use will make it easy to just update the affinity text if it is revealed.


Organisation & Cleanup

The final progress for the day was a bit more clean up with some commenting & script organisation. I improved the polygon ui mover script to auto start/stop and to only run when active and started a better structure where mechanics are grouped together instead of all the ui in one parent folder and all of the data in another as it makes it harder to find some bits of the codebase as it grows in size.


Whats Next?

Mostly more data xD, yea I’ve yet to get the healing skills in as of writing as well as about half of the passive ones. This is due to the varying data that I’ll need to store. There is a chance that I may have to hard code some skills in with no data just due to how specific they are, but I’ll keep trying to make a good structure before going down that way. I also plan to get some early setup for the turn management for a 1 v 1 to start with and then a x v 1 as I plan to have a full party of 4 for the player to use, matching the source game. It’ll probably be a few weeks before the next update as I do have to work on another project at the same time as this and that one has a more rigid deadline to hit.