<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Toggles/SwitchToggle.cs<|end_filename|>
﻿using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class SwitchToggle : MonoBehaviour
    {
        [Header("IMAGES")]
        [SerializeField]
        private Image backgroundImage;

        [SerializeField]
        private Image offImage;

        [SerializeField]
        private Image onImage;

        private Toggle tglSwitch;
        private Color color;

        private void Start()
        {
            tglSwitch = GetComponent<Toggle>();
            color = backgroundImage.color;

            if (tglSwitch != null)
            {
                if (tglSwitch.isOn)
                {
                    backgroundImage.color = Color.green;
                }

                tglSwitch.onValueChanged.AddListener((value) =>
                {
                    if (value)
                    {
                        backgroundImage.color = Color.green;
                        offImage.gameObject.SetActive(false);
                        onImage.gameObject.SetActive(true);
                    }
                    else
                    {
                        backgroundImage.color = color;
                        onImage.gameObject.SetActive(false);
                        offImage.gameObject.SetActive(true);
                    }
                });
            }
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Utilities/Scroll/HorizontalScrollSnap.cs<|end_filename|>
using JetBrains.Annotations;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Utilities
{
    [RequireComponent(typeof(ScrollRect))]
    public class HorizontalScrollSnap : HorizontalScrollSnapBase, IEndDragHandler
    {
        private void Start()
        {
            IsVertical = false;
            ChildAnchorPoint = new Vector2(0, 0.5f);

            _currentPage = StartingScreen;

            PanelDimensions = gameObject.GetComponent<RectTransform>().rect;

            UpdateLayout();
        }

        private void Update()
        {
            if (!Lerp && ScrollRect.velocity == Vector2.zero)
            {
                if (!Settled && !PointerDown)
                {
                    if (!IsRectSettledOnaPage(ScreensContainer.localPosition))
                    {
                        ScrollToClosestElement();
                    }
                }

                return;
            }
            else if (Lerp)
            {
                ScreensContainer.localPosition = Vector3.Lerp(ScreensContainer.localPosition, LerpTarget, TransitionSpeed * Time.deltaTime);
                if (Vector3.Distance(ScreensContainer.localPosition, LerpTarget) < 0.1f)
                {
                    ScreensContainer.localPosition = LerpTarget;
                    Lerp = false;
                    EndScreenChange();
                }
            }

            CurrentPage = GetPageforPosition(ScreensContainer.localPosition);

            if (!PointerDown)
            {
                if (ScrollRect.velocity.x > 0.01 || ScrollRect.velocity.x < 0.01)
                {
                    if (IsRectMovingSlowerThanThreshold(0))
                    {
                        ScrollToClosestElement();
                    }
                }
            }
        }

        private bool IsRectMovingSlowerThanThreshold(float startingSpeed)
        {
            return (ScrollRect.velocity.x > startingSpeed && ScrollRect.velocity.x < SwipeVelocityThreshold) ||
                   (ScrollRect.velocity.x < startingSpeed && ScrollRect.velocity.x > -SwipeVelocityThreshold);
        }

        private void DistributePages()
        {
            Screens = ScreensContainer.childCount;
            ScrollRect.horizontalNormalizedPosition = 0;

            const int offset = 0;
            float currentXPosition = 0;
            var pageStepValue = ChildSize = (int) PanelDimensions.width * ((PageStep == 0) ? 3 : PageStep);

            for (var i = 0; i < ScreensContainer.transform.childCount; i++)
            {
                var child = ScreensContainer.transform.GetChild(i).gameObject.GetComponent<RectTransform>();
                currentXPosition = offset + (int) (i * pageStepValue);
                child.sizeDelta = new Vector2(PanelDimensions.width, PanelDimensions.height);
                child.anchoredPosition = new Vector2(currentXPosition, 0f);
                child.anchorMin = child.anchorMax = child.pivot = ChildAnchorPoint;
            }

            var dimension = currentXPosition + offset * -1;

            ScreensContainer.offsetMax = new Vector2(dimension, 0f);
        }

        [UsedImplicitly]
        public void AddChild(GameObject go)
        {
            AddChild(go, false);
        }

        [UsedImplicitly]
        public void AddChild(GameObject go, bool worldPositionStays)
        {
            ScrollRect.horizontalNormalizedPosition = 0;
            go.transform.SetParent(ScreensContainer, worldPositionStays);
            InitialiseChildObjectsFromScene();
            DistributePages();

            if (MaskArea)
            {
                UpdateVisible();
            }

            SetScrollContainerPosition();
        }

        [UsedImplicitly]
        public void RemoveChild(int index, out GameObject childRemoved)
        {
            RemoveChild(index, false, out childRemoved);
        }

        [UsedImplicitly]
        public void RemoveChild(int index, bool worldPositionStays, out GameObject childRemoved)
        {
            childRemoved = null;
            if (index < 0 || index > ScreensContainer.childCount)
            {
                return;
            }

            ScrollRect.horizontalNormalizedPosition = 0;

            var child = ScreensContainer.transform.GetChild(index);
            child.SetParent(null, worldPositionStays);
            childRemoved = child.gameObject;
            InitialiseChildObjectsFromScene();
            DistributePages();

            if (MaskArea)
            {
                UpdateVisible();
            }

            if (_currentPage > Screens - 1)
            {
                CurrentPage = Screens - 1;
            }

            SetScrollContainerPosition();
        }

        [UsedImplicitly]
        public void RemoveAllChildren(out GameObject[] childrenRemoved)
        {
            RemoveAllChildren(false, out childrenRemoved);
        }

        [UsedImplicitly]
        public void RemoveAllChildren(bool worldPositionStays, out GameObject[] childrenRemoved)
        {
            var screenCount = ScreensContainer.childCount;
            childrenRemoved = new GameObject[screenCount];

            for (int i = screenCount - 1; i >= 0; i--)
            {
                childrenRemoved[i] = ScreensContainer.GetChild(i).gameObject;
                childrenRemoved[i].transform.SetParent(null, worldPositionStays);
            }

            ScrollRect.horizontalNormalizedPosition = 0;
            CurrentPage = 0;
            InitialiseChildObjectsFromScene();
            DistributePages();

            if (MaskArea)
            {
                UpdateVisible();
            }
        }

        private void SetScrollContainerPosition()
        {
            ScrollStartPosition = ScreensContainer.localPosition.x;
            ScrollRect.horizontalNormalizedPosition = (float) (_currentPage) / (Screens - 1);
            OnCurrentScreenChange(_currentPage);
        }

        [UsedImplicitly]
        public void UpdateLayout()
        {
            Lerp = false;
            DistributePages();

            if (MaskArea)
            {
                UpdateVisible();
            }

            SetScrollContainerPosition();
            OnCurrentScreenChange(_currentPage);
        }

        private void OnRectTransformDimensionsChange()
        {
            if (ChildAnchorPoint != Vector2.zero)
            {
                UpdateLayout();
            }
        }

        private void OnEnable()
        {
            InitialiseChildObjectsFromScene();
            DistributePages();

            if (MaskArea)
            {
                UpdateVisible();
            }

            if (JumpOnEnable || !RestartOnEnable)
            {
                SetScrollContainerPosition();
            }

            if (RestartOnEnable)
            {
                GoToScreen(StartingScreen);
            }
        }

        public void OnEndDrag(PointerEventData eventData)
        {
            PointerDown = false;

            if (ScrollRect.horizontal)
            {
                var distance = Vector3.Distance(StartPosition, ScreensContainer.localPosition);
                if (UseFastSwipe && distance < PanelDimensions.width && distance >= FastSwipeThreshold)
                {
                    ScrollRect.velocity = Vector3.zero;
                    if (StartPosition.x - ScreensContainer.localPosition.x > 0)
                    {
                        NextScreen();
                    }
                    else
                    {
                        PreviousScreen();
                    }
                }
            }
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/SettingsPartView.cs<|end_filename|>
﻿using System;
using UnityEngine;

namespace GeronimoGames.Kit.Game
{
    public class SettingsPartView : MonoBehaviour
    {
        [Header("BUTTONS")]
        [SerializeField]
        private SettingButtonView[] settingsButton;

        public event Action<SettingsType> OnClick;

        private void Start()
        {
            foreach (var button in settingsButton)
            {
                button.OnClick += ButtonOnClick;
            }
        }

        public void Initialize(string paramName, SettingsType type)
        {
            foreach (var button in settingsButton)
            {
                if (button.Type == type)
                {
                    button.SetText(paramName);
                }
            }
        }

        private void ButtonOnClick(SettingsType type)
        {
            OnClick?.Invoke(type);
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Basic/BasicView.cs<|end_filename|>
﻿using GeronimoGames.Kit.Utilities;
using UnityEngine;

namespace GeronimoGames.Kit.Game
{
    public class BasicView : MonoBehaviour
    {
        [Header("ROOT")]
        [SerializeField]
        private GameObject root;

        private CanvasGroup canvasGroup;

        private void Awake()
        {
            canvasGroup = root.AddComponent<CanvasGroup>();
            canvasGroup.alpha = 0.0f;
        }

        protected virtual void Start()
        {
        }

        public void SetActive(bool value)
        {
            root.SetActive(value);

            StopAllCoroutines();

            StartCoroutine(value
                ? Fade.FadeIn(canvasGroup, 1.0f, 0.5f)
                : Fade.FadeOut(canvasGroup, 0.0f, 0.5f));
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/Core/Models/ParamModel.cs<|end_filename|>
﻿using System;

namespace GeronimoGames.Kit.Game
{
    [Serializable]
    public class ParamModel
    {
        public string paramName;
        public int paramId;
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/TermsView.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Game
{
    public class TermsView : BasicView
    {
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/HomeView.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Game
{
    public class HomeView : BasicViewNavigation
    {
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/ProfileView.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Game
{
    public class ProfileView : BasicViewNavigation
    {
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/WalkthroughView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class WalkthroughView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button getStartedButton;

        public event Action OnClick;

        protected override void Start()
        {
            base.Start();

            getStartedButton.onClick.AddListener(() => { OnClick?.Invoke(); });
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/Controllers/MainController.cs<|end_filename|>
﻿using UnityEngine;

namespace GeronimoGames.Kit.Game
{
    public class MainController : MonoBehaviour
    {
        [Header("VIEWS")]
        [SerializeField]
        private LogoView logoView;

        [SerializeField]
        private MenuView menuView;

        [SerializeField]
        private SignInView signInView;

        [SerializeField]
        private SignUpView signUpView;

        [SerializeField]
        private RecoveryView recoveryView;

        [SerializeField]
        private TermsView termsView;

        [SerializeField]
        private WalkthroughView walkThroughView;

        [SerializeField]
        private ProfileView profileView;

        [SerializeField]
        private AboutUsView aboutUsView;

        [SerializeField]
        private HomeView homeView;

        [SerializeField]
        private PortfolioView portfolioView;

        [SerializeField]
        private SettingsView settingsView;

        private void Start()
        {
            signUpView.OnSignUp += SignUpViewOnSignUp;
            signUpView.OnAlreadyAccount += SignUpViewOnAlreadyAccount;

            signInView.OnLogin += SignInViewOnLogin;
            signInView.OnCreate += SignInViewOnCreate;
            signInView.OnForgot += SignInViewOnForgot;

            recoveryView.OnSend += RecoveryViewOnSend;
            recoveryView.OnAlreadyAccount += RecoveryViewOnAlreadyAccount;

            walkThroughView.OnClick += WalkThroughViewOnClick;

            menuView.OnHome += MenuViewOnHome;
            menuView.OnProfile += MenuViewOnProfile;
            menuView.OnAboutUs += MenuViewOnAboutUs;
            menuView.OnPortfolio += MenuViewOnPortfolio;
            menuView.OnSettings += MenuViewOnSettings;
            menuView.OnLogout += MenuViewOnLogout;

            profileView.OnBack += ProfileViewOnBack;
            aboutUsView.OnBack += AboutUsViewOnBack;
            homeView.OnBack += HomeViewOnBack;
            portfolioView.OnBack += PortfolioViewOnBack;
            settingsView.OnBack += SettingsViewOnBack;

            Init();
        }

        private void OnDisable()
        {
            signUpView.OnSignUp -= SignUpViewOnSignUp;
            signUpView.OnAlreadyAccount -= SignUpViewOnAlreadyAccount;

            signInView.OnLogin -= SignInViewOnLogin;
            signInView.OnCreate -= SignInViewOnCreate;
            signInView.OnForgot -= SignInViewOnForgot;

            recoveryView.OnSend -= RecoveryViewOnSend;
            recoveryView.OnAlreadyAccount -= RecoveryViewOnAlreadyAccount;

            walkThroughView.OnClick -= WalkThroughViewOnClick;

            menuView.OnHome -= MenuViewOnHome;
            menuView.OnProfile -= MenuViewOnProfile;
            menuView.OnAboutUs -= MenuViewOnAboutUs;
            menuView.OnPortfolio -= MenuViewOnPortfolio;
            menuView.OnSettings -= MenuViewOnSettings;
            menuView.OnLogout -= MenuViewOnLogout;

            profileView.OnBack -= ProfileViewOnBack;
            aboutUsView.OnBack -= AboutUsViewOnBack;
            homeView.OnBack -= HomeViewOnBack;
            portfolioView.OnBack -= PortfolioViewOnBack;
            settingsView.OnBack -= SettingsViewOnBack;
        }

        private void Init()
        {
            walkThroughView.SetActive(true);
        }

        private void WalkThroughViewOnClick()
        {
            walkThroughView.SetActive(false);

            logoView.SetActive(true);
            termsView.SetActive(true);
            signUpView.SetActive(true);
        }

        private void SignUpViewOnSignUp()
        {
        }

        private void SignUpViewOnAlreadyAccount()
        {
            signUpView.SetActive(false);

            signInView.SetActive(true);
        }

        private void SignInViewOnLogin()
        {
            logoView.SetActive(false);
            termsView.SetActive(false);
            signInView.SetActive(false);

            menuView.SetActive(true);
        }

        private void SignInViewOnCreate()
        {
            signInView.SetActive(false);

            signUpView.SetActive(true);
        }

        private void SignInViewOnForgot()
        {
            signInView.SetActive(false);

            recoveryView.SetActive(true);
        }

        private void RecoveryViewOnSend()
        {
        }

        private void RecoveryViewOnAlreadyAccount()
        {
            recoveryView.SetActive(false);

            signInView.SetActive(true);
        }

        private void ProfileViewOnBack()
        {
            profileView.SetActive(false);

            menuView.SetActive(true);
        }

        private void MenuViewOnHome()
        {
            menuView.SetActive(false);

            homeView.SetActive(true);
        }

        private void MenuViewOnProfile()
        {
            menuView.SetActive(false);

            profileView.SetActive(true);
        }

        private void MenuViewOnAboutUs()
        {
            menuView.SetActive(false);

            aboutUsView.SetActive(true);
        }

        private void MenuViewOnPortfolio()
        {
            menuView.SetActive(false);

            portfolioView.SetActive(true);
        }

        private void MenuViewOnSettings()
        {
            menuView.SetActive(false);

            settingsView.DisableParams();
            settingsView.SetActive(true);
        }

        private void AboutUsViewOnBack()
        {
            aboutUsView.SetActive(false);

            menuView.SetActive(true);
        }

        private void HomeViewOnBack()
        {
            homeView.SetActive(false);

            menuView.SetActive(true);
        }

        private void PortfolioViewOnBack()
        {
            portfolioView.SetActive(false);

            menuView.SetActive(true);
        }

        private void SettingsViewOnBack()
        {
            settingsView.SetActive(false);

            menuView.SetActive(true);
        }

        private void MenuViewOnLogout()
        {
            menuView.SetActive(false);

            walkThroughView.SetActive(true);
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/SettingsView.cs<|end_filename|>
﻿using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class SettingsView : BasicViewNavigation
    {
        [Header("TOGGLES")]
        [SerializeField]
        private Toggle appToggle;

        [SerializeField]
        private Toggle cameraToggle;

        [SerializeField]
        private Toggle networkToggle;

        [SerializeField]
        private Toggle otherToggle;

        [Header("GAME OBJECTS")]
        [SerializeField]
        private GameObject appGo;

        [SerializeField]
        private GameObject cameraGo;

        [SerializeField]
        private GameObject networkGo;

        [SerializeField]
        private GameObject otherGo;

        [SerializeField]
        private GameObject containerGo;

        [Header("PART")]
        [SerializeField]
        private SettingsPartView settingsPartView;

        [Header("PREFABS")]
        [SerializeField]
        private GameObject paramButtonPrefab;

        private List<ParamButtonView> lstParamButton;

        protected override void Start()
        {
            base.Start();

            lstParamButton = new List<ParamButtonView>();

            appToggle.onValueChanged.AddListener((value) =>
            {
                if (!value)
                {
                    return;
                }

                DisableParams();

                appGo.SetActive(true);
                cameraGo.SetActive(false);
                networkGo.SetActive(false);
                otherGo.SetActive(false);
            });

            cameraToggle.onValueChanged.AddListener((value) =>
            {
                if (!value)
                {
                    return;
                }

                DisableParams();

                cameraGo.SetActive(true);
                appGo.SetActive(false);
                networkGo.SetActive(false);
                otherGo.SetActive(false);
            });

            networkToggle.onValueChanged.AddListener((value) =>
            {
                if (!value)
                {
                    return;
                }

                DisableParams();

                networkGo.SetActive(true);
                cameraGo.SetActive(false);
                appGo.SetActive(false);
                otherGo.SetActive(false);
            });

            otherToggle.onValueChanged.AddListener((value) =>
            {
                if (!value)
                {
                    return;
                }

                DisableParams();

                otherGo.SetActive(true);
                cameraGo.SetActive(false);
                networkGo.SetActive(false);
                appGo.SetActive(false);
            });

            Init();
        }

        private void Init()
        {
            settingsPartView.OnClick += SettingsPartViewOnClick;
        }

        public void DisableParams()
        {
            containerGo.SetActive(false);
            DestroyElements();
        }

        private void SettingsPartViewOnClick(SettingsType type)
        {
            DestroyElements();

            var data = LocalCore.GetDataFromJsonFromPath<ParamModel>(type.ToString(), "Settings").ToList();

            containerGo.SetActive(true);
            InitParams(data, type);
        }

        private void InitParams(IEnumerable<ParamModel> data, SettingsType type)
        {
            foreach (var model in data)
            {
                var param = Instantiate(paramButtonPrefab, containerGo.transform, false);
                param.transform.localScale = Vector3.one;
                param.transform.SetAsFirstSibling();

                var button = param.GetComponent<ParamButtonView>();
                button.Initialize(model, type);

                button.OnClick += ButtonOnClick;

                lstParamButton.Add(button);
            }
        }

        private void ButtonOnClick(string paramName, int paramId, SettingsType type)
        {
            containerGo.SetActive(false);
            settingsPartView.Initialize(paramName, type);
        }

        private void DestroyElements()
        {
            if (lstParamButton == null)
            {
                return;
            }

            foreach (var element in lstParamButton)
            {
                Destroy(element.gameObject);
            }

            lstParamButton.Clear();
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Buttons/Setting/ParamButtonView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class ParamButtonView : MonoBehaviour
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button paramButton;

        [Header("TEXTS")]
        [SerializeField]
        private Text paramText;

        [Header("SETTINGS")]
        [SerializeField]
        private SettingsType settingsType;

        private string paramName;
        private int paramId;

        public event Action<string, int, SettingsType> OnClick;

        private void Start()
        {
            paramButton.onClick.AddListener(() => { OnClick?.Invoke(paramName, paramId, settingsType); });
        }

        public void Initialize(ParamModel model, SettingsType settingsType)
        {
            this.settingsType = settingsType;

            paramName = model.paramName;
            paramId = model.paramId;

            paramText.text = paramName;
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Utilities/Other/Palette.cs<|end_filename|>
﻿using UnityEngine;

namespace GeronimoGames.Kit.Utilities
{
    public class Palette : Singleton<Palette>
    {
        [Header("RED")]
        public Color red1 = new Color32(255, 205, 210, 255);

        public Color red2 = new Color32(239, 154, 154, 255);
        public Color red3 = new Color32(229, 115, 115, 255);
        public Color red4 = new Color32(239, 83, 80, 255);
        public Color red5 = new Color32(244, 67, 54, 255);

        [Header("PURPLE")]
        public Color purple1 = new Color32(225, 190, 231, 255);

        public Color purple2 = new Color32(206, 147, 216, 255);
        public Color purple3 = new Color32(186, 104, 200, 255);
        public Color purple4 = new Color32(171, 71, 188, 255);
        public Color purple5 = new Color32(156, 39, 176, 255);

        [Header("BLUE")]
        public Color blue1 = new Color32(187, 222, 251, 255);

        public Color blue2 = new Color32(144, 202, 249, 255);
        public Color blue3 = new Color32(100, 181, 246, 255);
        public Color blue4 = new Color32(66, 165, 245, 255);
        public Color blue5 = new Color32(33, 150, 243, 255);

        [Header("CYAN")]
        public Color cyan1 = new Color32(178, 235, 242, 255);

        public Color cyan2 = new Color32(128, 222, 234, 255);
        public Color cyan3 = new Color32(77, 208, 225, 255);
        public Color cyan4 = new Color32(39, 198, 218, 255);
        public Color cyan5 = new Color32(0, 188, 212, 255);

        [Header("TEAL")]
        public Color teal1 = new Color32(178, 223, 219, 255);

        public Color teal2 = new Color32(128, 203, 196, 255);
        public Color teal3 = new Color32(77, 182, 172, 255);
        public Color teal4 = new Color32(38, 166, 154, 255);
        public Color teal5 = new Color32(0, 150, 136, 255);

        [Header("GREEN")]
        public Color green1 = new Color32(200, 230, 201, 255);

        public Color green2 = new Color32(165, 214, 167, 255);
        public Color green3 = new Color32(129, 199, 132, 255);
        public Color green4 = new Color32(102, 187, 106, 255);
        public Color green5 = new Color32(76, 175, 80, 255);

        [Header("YELLOW")]
        public Color yellow1 = new Color32(255, 249, 196, 255);

        public Color yellow2 = new Color32(255, 245, 157, 255);
        public Color yellow3 = new Color32(255, 241, 118, 255);
        public Color yellow4 = new Color32(255, 238, 88, 255);
        public Color yellow5 = new Color32(255, 235, 59, 255);

        [Header("ORANGE")]
        public Color orange1 = new Color32(255, 224, 178, 255);

        public Color orange2 = new Color32(255, 204, 128, 255);
        public Color orange3 = new Color32(255, 183, 77, 255);
        public Color orange4 = new Color32(255, 167, 38, 255);
        public Color orange5 = new Color32(255, 152, 0, 255);

        [Header("BROWN")]
        public Color brown1 = new Color32(215, 204, 200, 255);

        public Color brown2 = new Color32(188, 170, 164, 255);
        public Color brown3 = new Color32(161, 136, 127, 255);
        public Color brown4 = new Color32(141, 110, 99, 255);
        public Color brown5 = new Color32(124, 85, 72, 255);

        [Header("GREY")]
        public Color grey1 = new Color32(245, 245, 245, 255);

        public Color grey2 = new Color32(238, 238, 238, 255);
        public Color grey3 = new Color32(224, 224, 224, 255);
        public Color grey4 = new Color32(189, 189, 189, 255);
        public Color grey5 = new Color32(158, 158, 158, 255);

        [Header("BLUE GREY")]
        public Color blueGrey1 = new Color32(207, 216, 220, 255);

        public Color blueGrey2 = new Color32(176, 190, 197, 255);
        public Color blueGrey3 = new Color32(144, 164, 174, 255);
        public Color blueGrey4 = new Color32(120, 144, 156, 255);
        public Color blueGrey5 = new Color32(96, 125, 139, 255);
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/PortfolioView.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Game
{
    public class PortfolioView : BasicViewNavigation
    {
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Buttons/Basic/BasicMenuButton.cs<|end_filename|>
﻿using System;
using System.Collections;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public sealed class BasicMenuButton : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, IPointerClickHandler
    {
        [SerializeField]
        private Image lineImage;

        private float widthButton;
        private float heightButton;
        private float widthLine;
        private float heightLine;

        private const float TimeAnim = 0.1f;

        private float velocity;
        private bool enter;
        private bool exit;

        public event Action OnClick;

        private void Start()
        {
            widthButton = GetComponent<RectTransform>().rect.width;
            heightButton = GetComponent<RectTransform>().rect.height;
            widthLine = lineImage.GetComponent<RectTransform>().rect.width;
            heightLine = lineImage.GetComponent<RectTransform>().rect.height;
        }

        private void Update()
        {
            if (enter)
            {
                GoAnim();
            }

            if (exit)
            {
                BackAnim();
            }
        }

        private void OnEnable()
        {
            enter = false;
            exit = true;
        }

        public void OnPointerEnter(PointerEventData eventData)
        {
#if UNITY_EDITOR || UNITY_STANDALONE_WIN || UNITY_WEBGL
            enter = true;
            exit = false;
#endif
        }

        public void OnPointerExit(PointerEventData eventData)
        {
#if UNITY_EDITOR || UNITY_STANDALONE_WIN || UNITY_WEBGL
            enter = false;
            exit = true;
#endif
        }

        public void OnPointerClick(PointerEventData eventData)
        {
            enter = true;
            exit = false;

            StartCoroutine(OnClickAsync());
        }

        public void InitialState()
        {
            enter = false;
            exit = true;
        }

        private void GoAnim()
        {
            var targetLine = lineImage.GetComponent<RectTransform>().rect.width;
            var width = Mathf.SmoothDamp(targetLine, widthButton, ref velocity, TimeAnim);

            lineImage.rectTransform.sizeDelta = new Vector2(width, heightButton);
        }

        private void BackAnim()
        {
            var targetLine = lineImage.GetComponent<RectTransform>().rect.width;
            var width = Mathf.SmoothDamp(targetLine, widthLine, ref velocity, TimeAnim);

            lineImage.rectTransform.sizeDelta = new Vector2(width, heightLine);
        }

        private IEnumerator OnClickAsync()
        {
            yield return new WaitForSeconds(TimeAnim + 0.12f);
            OnClick?.Invoke();
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Utilities/Scroll/HorizontalScrollSnapBase.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Utilities
{
    public class HorizontalScrollSnapBase : MonoBehaviour, IBeginDragHandler, IDragHandler, IHorizontalScrollSnap
    {
        internal Rect PanelDimensions;
        internal RectTransform ScreensContainer;
        internal bool IsVertical;
        internal int Screens = 1;

        internal float ScrollStartPosition;
        internal float ChildSize;
        private float childPos;
        private float maskSize;
        internal Vector2 ChildAnchorPoint;
        internal ScrollRect ScrollRect;
        internal Vector3 LerpTarget;
        internal bool Lerp;
        internal bool PointerDown = false;
        internal bool Settled = true;
        internal Vector3 StartPosition = new Vector3();
        
        [Tooltip("The currently active page")]
        internal int _currentPage;
        internal int PreviousPage;
        internal int HalfNoVisibleItems;
        internal bool MoveStarted;
        private int _bottomItem;
        private int _topItem;

        [Serializable] public class SelectionChangeStartEvent : UnityEvent { }
        [Serializable] public class SelectionPageChangedEvent : UnityEvent<int> { }
        [Serializable] public class SelectionChangeEndEvent : UnityEvent<int> { }

        [Tooltip("The screen / page to start the control on\n*Note, this is a 0 indexed array")]
        [SerializeField] public int StartingScreen = 0;

        [Tooltip("The distance between two pages based on page height, by default pages are next to each other")]
        [SerializeField]
        [Range(0, 8)]
        public float PageStep = 1;

        [Tooltip("The gameobject that contains toggles which suggest pagination. (optional)")]
        public GameObject Pagination;

        [Tooltip("Button to go to the previous page. (optional)")]
        public GameObject PrevButton;

        [Tooltip("Button to go to the next page. (optional)")]
        public GameObject NextButton;

        [Tooltip("Transition speed between pages. (optional)")]
        public float TransitionSpeed = 7.5f;

        [Tooltip("Fast Swipe makes swiping page next / previous (optional)")]
        public bool UseFastSwipe = false;

        [Tooltip("Offset for how far a swipe has to travel to initiate a page change (optional)")]
        public int FastSwipeThreshold = 100;

        [Tooltip("Speed at which the ScrollRect will keep scrolling before slowing down and stopping (optional)")]
        public int SwipeVelocityThreshold = 100;

        [Tooltip("The visible bounds area, controls which items are visible/enabled. *Note Should use a RectMask. (optional)")]
        public RectTransform MaskArea;

        [Tooltip("Pixel size to buffer arround Mask Area. (optional)")]
        public float MaskBuffer = 1;

        public int CurrentPage
        {
            get
            {
                return _currentPage;
            }

            internal set
            {
                if ((value != _currentPage && value >= 0 && value < ScreensContainer.childCount) || (value == 0 && ScreensContainer.childCount == 0))
                {
                    PreviousPage = _currentPage;
                    _currentPage = value;
                    if (MaskArea) UpdateVisible();
                    if (!Lerp) ScreenChange();
                    OnCurrentScreenChange(_currentPage);
                }
            }
        }

        [Tooltip("By default the container will lerp to the start when enabled in the scene, this option overrides this and forces it to simply jump without lerping")]
        public bool JumpOnEnable = false;

        [Tooltip("By default the container will return to the original starting page when enabled, this option overrides this behaviour and stays on the current selection")]
        public bool RestartOnEnable = false;

        [Tooltip("(Experimental)\nBy default, child array objects will use the parent transform\nHowever you can disable this for some interesting effects")]
        public bool UseParentTransform = true;

        [Tooltip("Scroll Snap children. (optional)\nEither place objects in the scene as children OR\nPrefabs in this array, NOT BOTH")]
        public GameObject[] ChildObjects;

        [SerializeField]
        [Tooltip("Event fires when a user starts to change the selection")]
        private SelectionChangeStartEvent _onSelectionChangeStartEvent = new SelectionChangeStartEvent();
        public SelectionChangeStartEvent OnSelectionChangeStartEvent { get { return _onSelectionChangeStartEvent; } set { _onSelectionChangeStartEvent = value; } }

        [SerializeField]
        [Tooltip("Event fires as the page changes, while dragging or jumping")]
        private SelectionPageChangedEvent _onSelectionPageChangedEvent = new SelectionPageChangedEvent();
        public SelectionPageChangedEvent OnSelectionPageChangedEvent { get { return _onSelectionPageChangedEvent; } set { _onSelectionPageChangedEvent = value; } }

        [SerializeField]
        [Tooltip("Event fires when the page settles after a user has dragged")]
        private SelectionChangeEndEvent _onSelectionChangeEndEvent = new SelectionChangeEndEvent();
        public SelectionChangeEndEvent OnSelectionChangeEndEvent { get { return _onSelectionChangeEndEvent; } set { _onSelectionChangeEndEvent = value; } }

        private void Awake()
        {
            if (ScrollRect == null)
            {
                ScrollRect = gameObject.GetComponent<ScrollRect>();
            }

            PanelDimensions = gameObject.GetComponent<RectTransform>().rect;

            if (StartingScreen < 0)
            {
                StartingScreen = 0;
            }

            ScreensContainer = ScrollRect.content;

            InitialiseChildObjects();

            if (NextButton)
            {
                NextButton.GetComponent<Button>().onClick.AddListener(NextScreen);
            }

            if (PrevButton)
            {
                PrevButton.GetComponent<Button>().onClick.AddListener(PreviousScreen);
            }
        }

        internal void InitialiseChildObjects()
        {
            if (ChildObjects != null && ChildObjects.Length > 0)
            {
                if (ScreensContainer.transform.childCount > 0)
                {
                    Debug.LogError("ScrollRect Content has children, this is not supported when using managed Child Objects\n Either remove the ScrollRect Content children or clear the ChildObjects array");
                    return;
                }

                InitialiseChildObjectsFromArray();
            }
            else
            {
                InitialiseChildObjectsFromScene();
            }
        }

        internal void InitialiseChildObjectsFromScene()
        {
            var childCount = ScreensContainer.childCount;
            ChildObjects = new GameObject[childCount];
            for (var i = 0; i < childCount; i++)
            {
                ChildObjects[i] = ScreensContainer.transform.GetChild(i).gameObject;
                if (MaskArea && ChildObjects[i].activeSelf)
                {
                    ChildObjects[i].SetActive(false);
                }
            }
        }

        internal void InitialiseChildObjectsFromArray()
        {
            var childCount = ChildObjects.Length;
            for (var i = 0; i < childCount; i++)
            {
                var child = GameObject.Instantiate(ChildObjects[i]);
                if (UseParentTransform)
                {
                    var childRect = child.GetComponent<RectTransform>();
                    childRect.rotation = ScreensContainer.rotation;
                    childRect.localScale = ScreensContainer.localScale;
                    childRect.position = ScreensContainer.position;
                }

                child.transform.SetParent(ScreensContainer.transform);
                ChildObjects[i] = child;
                if (MaskArea && ChildObjects[i].activeSelf)
                {
                    ChildObjects[i].SetActive(false);
                }
            }
        }

        internal void UpdateVisible()
        {
            if (!MaskArea || ChildObjects == null || ChildObjects.Length < 1 || ScreensContainer.childCount < 1)
            {
                return;
            }

            maskSize = IsVertical ? MaskArea.rect.height : MaskArea.rect.width;
            HalfNoVisibleItems = (int)Math.Round(maskSize / (ChildSize * MaskBuffer), MidpointRounding.AwayFromZero) / 2;
            _bottomItem = _topItem = 0;

            for (var i = HalfNoVisibleItems + 1; i > 0; i--)
            {
                _bottomItem = _currentPage - i < 0 ? 0 : i;
                if (_bottomItem > 0) break;
            }

            for (var i = HalfNoVisibleItems + 1; i > 0; i--)
            {
                _topItem = ScreensContainer.childCount - _currentPage - i < 0 ? 0 : i;
                if (_topItem > 0) break;
            }

            for (var i = CurrentPage - _bottomItem; i < CurrentPage + _topItem; i++)
            {
                try
                {
                    ChildObjects[i].SetActive(true);
                }
                catch
                {
                    Debug.Log("Failed to setactive child [" + i + "]");
                }
            }

            if (_currentPage > HalfNoVisibleItems) ChildObjects[CurrentPage - _bottomItem].SetActive(false);
            if (ScreensContainer.childCount - _currentPage > _topItem) ChildObjects[CurrentPage + _topItem].SetActive(false);
        }

        public void NextScreen()
        {
            if (_currentPage < Screens - 1)
            {
                if (!Lerp) StartScreenChange();

                Lerp = true;
                CurrentPage = _currentPage + 1;
                GetPositionforPage(_currentPage, ref LerpTarget);
                ScreenChange();
            }
        }

        public void PreviousScreen()
        {
            if (_currentPage > 0)
            {
                if (!Lerp) StartScreenChange();

                Lerp = true;
                CurrentPage = _currentPage - 1;
                GetPositionforPage(_currentPage, ref LerpTarget);
                ScreenChange();
            }
        }

        public void GoToScreen(int screenIndex)
        {
            if (screenIndex <= Screens - 1 && screenIndex >= 0)
            {
                if (!Lerp) StartScreenChange();

                Lerp = true;
                CurrentPage = screenIndex;
                GetPositionforPage(_currentPage, ref LerpTarget);
                ScreenChange();
            }
        }

        internal int GetPageforPosition(Vector3 pos)
        {
            return IsVertical ?
                (int)Math.Round((ScrollStartPosition - pos.y) / ChildSize) :
                (int)Math.Round((ScrollStartPosition - pos.x) / ChildSize);
        }

        internal bool IsRectSettledOnaPage(Vector3 pos)
        {
            return IsVertical ?
                -((pos.y - ScrollStartPosition) / ChildSize) == -(int)Math.Round((pos.y - ScrollStartPosition) / ChildSize) :
                -((pos.x - ScrollStartPosition) / ChildSize) == -(int)Math.Round((pos.x - ScrollStartPosition) / ChildSize);
        }

        internal void GetPositionforPage(int page, ref Vector3 target)
        {
            childPos = -ChildSize * page;
            if (IsVertical)
            {
                target.y = childPos + ScrollStartPosition;
            }
            else
            {
                target.x = childPos + ScrollStartPosition;
            }
        }

        internal void ScrollToClosestElement()
        {
            Lerp = true;
            CurrentPage = GetPageforPosition(ScreensContainer.localPosition);
            GetPositionforPage(_currentPage, ref LerpTarget);
            OnCurrentScreenChange(_currentPage);
        }

        internal void OnCurrentScreenChange(int currentScreen)
        {
            ChangeBulletsInfo(currentScreen);
            ToggleNavigationButtons(currentScreen);
        }

        private void ChangeBulletsInfo(int targetScreen)
        {
            if (Pagination)
            {
                for (var i = 0; i < Pagination.transform.childCount; i++)
                {
                    Pagination.transform.GetChild(i).GetComponent<Toggle>().isOn = (targetScreen == i) ? true : false;
                }
            }
        }

        private void ToggleNavigationButtons(int targetScreen)
        {
            if (PrevButton)
            {
                PrevButton.GetComponent<Button>().interactable = targetScreen > 0;
            }

            if (NextButton)
            {
                NextButton.GetComponent<Button>().interactable = targetScreen < ScreensContainer.transform.childCount - 1;
            }
        }

        private void OnValidate()
        {
            if (ScrollRect == null)
            {
                ScrollRect = GetComponent<ScrollRect>();
            }
            if (!ScrollRect.horizontal && !ScrollRect.vertical)
            {
                Debug.LogError("ScrollRect has to have a direction, please select either Horizontal OR Vertical with the appropriate control.");
            }
            if (ScrollRect.horizontal && ScrollRect.vertical)
            {
                Debug.LogError("ScrollRect has to be unidirectional, only use either Horizontal or Vertical on the ScrollRect, NOT both.");
            }

            var children = gameObject.GetComponent<ScrollRect>().content.childCount;
            if (children != 0 || ChildObjects != null)
            {
                var childCount = ChildObjects == null || ChildObjects.Length == 0 ? children : ChildObjects.Length;
                if (StartingScreen > childCount - 1)
                {
                    StartingScreen = childCount - 1;
                }

                if (StartingScreen < 0)
                {
                    StartingScreen = 0;
                }
            }

            if (MaskBuffer <= 0)
            {
                MaskBuffer = 1;
            }

            if (PageStep < 0)
            {
                PageStep = 0;
            }

            if (PageStep > 8)
            {
                PageStep = 9;
            }
        }

        public void StartScreenChange()
        {
            if (!MoveStarted)
            {
                MoveStarted = true;
                OnSelectionChangeStartEvent.Invoke();
            }
        }

        internal void ScreenChange()
        {
            OnSelectionPageChangedEvent.Invoke(_currentPage);
        }

        internal void EndScreenChange()
        {
            OnSelectionChangeEndEvent.Invoke(_currentPage);
            Settled = true;
            MoveStarted = false;
        }

        public Transform CurrentPageObject()
        {
            return ScreensContainer.GetChild(CurrentPage);
        }

        public void CurrentPageObject(out Transform returnObject)
        {
            returnObject = ScreensContainer.GetChild(CurrentPage);
        }

        public void OnBeginDrag(PointerEventData eventData)
        {
            PointerDown = true;
            Settled = false;
            StartScreenChange();
            StartPosition = ScreensContainer.localPosition;
        }

        public void OnDrag(PointerEventData eventData)
        {
            Lerp = false;
        }

        int IHorizontalScrollSnap.CurrentPage()
        {
            return CurrentPage = GetPageforPosition(ScreensContainer.localPosition);
        }

        public void SetLerp(bool value)
        {
            Lerp = value;
        }

        public void ChangePage(int page)
        {
            GoToScreen(page);
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/RecoveryView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class RecoveryView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button sendButton;

        [SerializeField]
        private Button alreadyAccountButton;

        public event Action OnSend;
        public event Action OnAlreadyAccount;

        protected override void Start()
        {
            base.Start();

            sendButton.onClick.AddListener(() => { OnSend?.Invoke(); });
            alreadyAccountButton.onClick.AddListener(() => { OnAlreadyAccount?.Invoke(); });
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/Managers/ScenesManager.cs<|end_filename|>
﻿using System.Collections;
using GeronimoGames.Kit.Utilities;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace GeronimoGames.Kit.Game
{
    public class ScenesManager : Singleton<ScenesManager>
    {
        public void LoadScene(string nameScene)
        {
            StartCoroutine(LoadSceneAsync(nameScene));
        }

        public void UnloadScene(string nameScene)
        {
            StartCoroutine(UnloadSceneAsync(nameScene));
        }

        private static IEnumerator LoadSceneAsync(string nameScene)
        {
            yield return new WaitForSeconds(0.5f);
            var async = SceneManager.LoadSceneAsync(nameScene, LoadSceneMode.Single);

            while (!async.isDone)
            {
                yield return null;
            }

            var scn = SceneManager.GetSceneByName(nameScene);
            SceneManager.SetActiveScene(scn);
        }

        private static IEnumerator UnloadSceneAsync(string nameScene)
        {
            var async = SceneManager.UnloadSceneAsync(nameScene);

            yield return new WaitForSeconds(0.5f);

            while (true)
            {
                if (async is {isDone: true})
                {
                    var asyncUnload = Resources.UnloadUnusedAssets();
                    yield return asyncUnload;
                    
                    yield break;
                }

                yield return null;
            }
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/Core/LocalCore.cs<|end_filename|>
﻿using System.IO;
using GeronimoGames.Kit.Utilities;
using UnityEngine;

namespace GeronimoGames.Kit.Game
{
    public static class LocalCore
    {
        public static T[] GetDataFromJson<T>(string fileName)
        {
            var path = Application.streamingAssetsPath + "/" + fileName + ".json";
            var file = File.ReadAllText(path);
            var data = JsonHelper.FromJson<T>(file);
            return data;
        }

        public static T[] GetDataFromJsonFromPath<T>(string fileName, string pathFolder)
        {
            string realPath = null;

#if UNITY_EDITOR || UNITY_IOS
            realPath = Application.streamingAssetsPath + "/" + pathFolder + "/" + fileName + ".json";
#elif UNITY_ANDROID
            realPath = string.Format("{0}/{1}", Application.persistentDataPath, fileName + ".json");
            string originalPath = "jar:file://" + Application.dataPath + "!/assets/" + pathFolder + "/" + fileName + ".json";

            WWW reader = new WWW(originalPath);
            while ( ! reader.isDone) {}

            File.WriteAllBytes(realPath, reader.bytes);
#endif

            var file = File.ReadAllText(realPath);
            var data = JsonHelper.FromJson<T>(file);
            return data;
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/SignInView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class SignInView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button loginButton;

        [SerializeField]
        private Button createButton;

        [SerializeField]
        private Button forgotButton;

        public event Action OnLogin;
        public event Action OnCreate;
        public event Action OnForgot;

        protected override void Start()
        {
            base.Start();

            loginButton.onClick.AddListener(() => { OnLogin?.Invoke(); });
            createButton.onClick.AddListener(() => { OnCreate?.Invoke(); });
            forgotButton.onClick.AddListener(() => { OnForgot?.Invoke(); });
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/MenuView.cs<|end_filename|>
﻿using System;
using UnityEngine;

namespace GeronimoGames.Kit.Game
{
    public class MenuView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private BasicMenuButton homeButton;

        [SerializeField]
        private BasicMenuButton profileButton;

        [SerializeField]
        private BasicMenuButton aboutUsButton;

        [SerializeField]
        private BasicMenuButton portfolioButton;

        [SerializeField]
        private BasicMenuButton settingsButton;

        [SerializeField]
        private BasicMenuButton logoutButton;

        public event Action OnHome;
        public event Action OnProfile;
        public event Action OnAboutUs;
        public event Action OnPortfolio;
        public event Action OnSettings;
        public event Action OnLogout;

        protected override void Start()
        {
            base.Start();

            homeButton.OnClick += HomeButtonOnClick;
            profileButton.OnClick += ProfileButtonOnClick;
            aboutUsButton.OnClick += AboutUsButtonOnClick;
            portfolioButton.OnClick += PortfolioButtonOnClick;
            settingsButton.OnClick += SettingsButtonOnClick;
            logoutButton.OnClick += LogoutButtonOnClick;
        }

        private void HomeButtonOnClick()
        {
            OnHome?.Invoke();
        }

        private void ProfileButtonOnClick()
        {
            OnProfile?.Invoke();
        }

        private void AboutUsButtonOnClick()
        {
            OnAboutUs?.Invoke();
        }

        private void PortfolioButtonOnClick()
        {
            OnPortfolio?.Invoke();
        }

        private void SettingsButtonOnClick()
        {
            OnSettings?.Invoke();
        }

        private void LogoutButtonOnClick()
        {
            OnLogout?.Invoke();
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Canvas/BlinkCanvas.cs<|end_filename|>
﻿using UnityEngine;

namespace GeronimoGames.Kit.Game.Canvas
{
    public class BlinkCanvas : MonoBehaviour
    {
        [Header("CANVAS")]
        [SerializeField]
        private CanvasGroup canvasGroup;

        private float alphaMin = 0.25f;
        private float alphaMax = 1.0f;
        private float timer;

        private const float Speed = 1.0f;

        private void Update()
        {
            canvasGroup.alpha = Mathf.Lerp(alphaMin, alphaMax, timer);

            timer += Speed * Time.deltaTime;

            if (!(timer > 1.0f))
            {
                return;
            }

            (alphaMax, alphaMin) = (alphaMin, alphaMax);
            timer = 0.0f;
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/SplashView.cs<|end_filename|>
﻿using System;
using System.Collections;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class SplashView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button tapButton;

        [Header("TEXTS")]
        [SerializeField]
        private Text tapText;

        [Header("IMAGES")]
        [SerializeField]
        private Image iconImage;

        [SerializeField]
        private Image[] linesImage;

        private int countLine;

        protected override void Start()
        {
            base.Start();

            tapButton.onClick.AddListener(() =>
            {
                tapText.gameObject.SetActive(false);
                iconImage.gameObject.SetActive(false);
                StartCoroutine(AnimStartAsync());
            });

            SetActive(true);
        }

        private IEnumerator AnimStartAsync()
        {
            foreach (var line in linesImage)
            {
                yield return new WaitForSeconds(0.05f);
                StartCoroutine(AnimAsync(line));
            }
        }

        private IEnumerator AnimAsync(Image line)
        {
            while (Math.Abs(line.fillAmount - 1) > 0.0001)
            {
                yield return new WaitForSeconds(0.01f * Time.deltaTime);
                line.fillAmount += 0.075f;
            }

            yield return new WaitForSeconds(0.50f);
            line.fillOrigin = 1;

            while (Math.Abs(line.fillAmount) > 0.0001)
            {
                yield return new WaitForSeconds(0.01f * Time.deltaTime);
                line.fillAmount -= 0.075f;
            }

            countLine++;

            if (countLine == linesImage.Length)
            {
                LoadScene();
            }
        }

        private static void LoadScene()
        {
            ScenesManager.Instance.LoadScene("Main");
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Basic/BasicViewNavigation.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class BasicViewNavigation : BasicView
    {
        [Header("NAVIGATION")]
        [SerializeField]
        private Button backButton;

        public event Action OnBack;

        protected override void Start()
        {
            base.Start();

            backButton.onClick.AddListener(() => { OnBack?.Invoke(); });
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Buttons/Setting/SettingButtonView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public enum SettingsType
    {
        FontSize = 0,
        FontCustom = 1,
        Language = 2,
        Theme = 3,
    }

    public class SettingButtonView : MonoBehaviour
    {
        [Header("TEXTS")]
        [SerializeField]
        private Text settingText;

        [Header("SETTINGS")]
        [SerializeField]
        private SettingsType settingsType;

        private Button settingButton;

        public event Action<SettingsType> OnClick;

        public SettingsType Type
        {
            get => settingsType;
            set => settingsType = value;
        }

        private void Start()
        {
            settingButton = GetComponent<Button>();

            if (settingButton != null)
            {
                settingButton.onClick.AddListener(() => { OnClick?.Invoke(Type); });
            }
        }

        public void SetText(string paramName)
        {
            if (settingText != null)
            {
                settingText.text = paramName;
            }
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Utilities/Scroll/IHorizontalScrollSnap.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Utilities
{
    internal interface IHorizontalScrollSnap
    {
        void ChangePage(int page);
        void SetLerp(bool value);
        int CurrentPage();
        void StartScreenChange();
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/SignUpView.cs<|end_filename|>
﻿using System;
using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class SignUpView : BasicView
    {
        [Header("BUTTONS")]
        [SerializeField]
        private Button signUpButton;

        [SerializeField]
        private Button alreadyAccountButton;

        public event Action OnAlreadyAccount;
        public event Action OnSignUp;

        protected override void Start()
        {
            base.Start();

            alreadyAccountButton.onClick.AddListener(() => { OnAlreadyAccount?.Invoke(); });
            signUpButton.onClick.AddListener(() => { OnSignUp?.Invoke(); });
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/Buttons/FollowButton.cs<|end_filename|>
﻿using UnityEngine;
using UnityEngine.UI;

namespace GeronimoGames.Kit.Game
{
    public class FollowButton : MonoBehaviour
    {
        [Header("SETTINGS")]
        [SerializeField]
        private string url;

        private void Start()
        {
            var button = gameObject.GetComponent<Button>();

            if (button != null)
            {
                button.onClick.AddListener(() => { Application.OpenURL(url); });
            }
        }
    }
}

<|start_filename|>Assets/Project/Scripts/GeronimoGames/Kit/Game/View/AboutUsView.cs<|end_filename|>
﻿namespace GeronimoGames.Kit.Game
{
    public class AboutUsView : BasicViewNavigation
    {
    }
}