using UnityEngine;
|
using UnityEngine.UI;
|
using System.Collections;
|
using EnhancedUI.EnhancedScroller;
|
using EnhancedUI;
|
|
namespace EnhancedScrollerDemos.SnappingDemo
|
{
|
/// <summary>
|
/// This demo shows how you can use snapping to lock a slot cell to a particular
|
/// spot in the scroller when the scroller's velocity dips below a certain
|
/// threshhold. The demo script controls three separate slot controller scripts,
|
/// though we could have just as easily done each of their logic in this one script.
|
/// </summary>
|
public class SnappingDemo : MonoBehaviour
|
{
|
/// <summary>
|
/// The states the game can be in
|
/// </summary>
|
private enum GameStateEnum
|
{
|
Initializing,
|
Playing,
|
GameOver
|
}
|
|
/// <summary>
|
/// Cached array of the slot controllers
|
/// </summary>
|
private SlotController[] _slotControllers;
|
|
/// <summary>
|
/// The data index value of each scroll controller
|
/// </summary>
|
private int[] _snappedDataIndices;
|
|
/// <summary>
|
/// The current credits available for play
|
/// </summary>
|
private int _credits;
|
|
/// <summary>
|
/// The number of scrollers that have snapped and stopped
|
/// during this lever pull. Once the count reaches three,
|
/// the score will be tallied.
|
/// </summary>
|
private int _snapCount;
|
|
/// <summary>
|
/// The current state of the game
|
/// </summary>
|
private GameStateEnum _gameState;
|
|
/// <summary>
|
/// The minimum and maximum values that each scroller
|
/// can have when the lever is pulled. This script
|
/// will pick a random value between the minimum and
|
/// maximum and also randomly pick the direction of movement.
|
/// </summary>
|
public float minVelocity;
|
public float maxVelocity;
|
|
/// <summary>
|
/// These are the indices of the various slots,
|
/// used in tallying the score
|
/// </summary>
|
public int cherryIndex;
|
public int sevenIndex;
|
public int tripleBarIndex;
|
public int bigWinIndex;
|
public int blankIndex;
|
|
/// <summary>
|
/// These are the sprites for the slot data. We
|
/// could have placed these in the SlotController script,
|
/// but then we'd need to duplicate the list three times.
|
/// </summary>
|
public Sprite[] slotSprites;
|
|
/// <summary>
|
/// This is the button used to start the slots moving
|
/// </summary>
|
public Button pullLeverButton;
|
|
/// <summary>
|
/// This shows how many credits are left
|
/// </summary>
|
public Text creditsText;
|
|
/// <summary>
|
/// The number of credits to start with
|
/// </summary>
|
public int startingCredits;
|
|
/// <summary>
|
/// Panels and gameobjects used in the game states
|
/// </summary>
|
public GameObject playingPanel;
|
public GameObject gameOverPanel;
|
public PlayWin playWin;
|
|
/// <summary>
|
/// Setting the credits will alter some UI
|
/// </summary>
|
private int Credits
|
{
|
get
|
{
|
return _credits;
|
}
|
set
|
{
|
// don't let the credits dip below zero
|
_credits = (value < 0 ? 0 : value);
|
|
// show the credits
|
creditsText.text = string.Format("{0:n0}", _credits);
|
|
// deactivate the lever if the credits are zero
|
pullLeverButton.gameObject.SetActive(_credits > 0);
|
}
|
}
|
|
/// <summary>
|
/// Setting the game state will alter the game's UI
|
/// </summary>
|
private GameStateEnum GameState
|
{
|
get
|
{
|
return _gameState;
|
}
|
set
|
{
|
_gameState = value;
|
|
switch (_gameState)
|
{
|
case GameStateEnum.Playing:
|
|
// turn on the snapping for each scroller in the slot controllers
|
foreach (var slotController in _slotControllers)
|
{
|
slotController.scroller.snapping = true;
|
}
|
|
// reset the credits and activate the playing panel,
|
// deactivating the game over panel
|
|
Credits = startingCredits;
|
|
playingPanel.SetActive(true);
|
gameOverPanel.SetActive(false);
|
|
break;
|
|
case GameStateEnum.GameOver:
|
|
// activate the game over panel and deactivate
|
// the playing panel
|
|
playingPanel.SetActive(false);
|
gameOverPanel.SetActive(true);
|
|
break;
|
}
|
}
|
}
|
|
void Awake()
|
{
|
// set our game to initializing
|
GameState = GameStateEnum.Initializing;
|
|
// cache the slot controllers from this game object
|
_slotControllers = gameObject.GetComponentsInChildren<SlotController>();
|
|
// create array for the selected data indices arrays
|
_snappedDataIndices = new int[_slotControllers.Length];
|
|
// set each slot controller's scroll snapping handler
|
// (we could have done this in the slot controller script,
|
// but handling it here gives us information about the
|
// game's state and overall values for each slot controller)
|
foreach (var slotController in _slotControllers)
|
{
|
slotController.scroller.scrollerSnapped = ScrollerSnapped;
|
}
|
}
|
|
void Start()
|
{
|
// reload each scroll controller with sprites for the data
|
foreach (var slotController in _slotControllers)
|
{
|
slotController.Reload(slotSprites);
|
}
|
}
|
|
void LateUpdate()
|
{
|
// We set the playing state here so that the game
|
// doesn't show a winner when it starts up (because
|
// there will always be three of a kind at startup).
|
if (GameState == GameStateEnum.Initializing)
|
GameState = GameStateEnum.Playing;
|
}
|
|
/// <summary>
|
/// This function is linked in the editor to the Pull Lever Button's click event
|
/// </summary>
|
public void PullLeverButton_OnClick()
|
{
|
// reset the snap count back to zero. When the count reaches three,
|
// the score will be tallied
|
_snapCount = 0;
|
|
// take away a credit to play
|
Credits--;
|
|
// disable the lever button
|
pullLeverButton.interactable = false;
|
|
// loop through each slot controller and add a random velocity and direction to the scrollers
|
foreach (var slotController in _slotControllers)
|
{
|
slotController.AddVelocity((UnityEngine.Random.Range(0, 1f) > 0.5f ? 1f : -1f) * UnityEngine.Random.Range(minVelocity, maxVelocity));
|
}
|
}
|
|
/// <summary>
|
/// This function is linked in the editor to the Reset Button's Click event
|
/// </summary>
|
public void ResetButton_OnClick()
|
{
|
// reset the game back to playing from a game over state
|
GameState = GameStateEnum.Playing;
|
}
|
|
/// <summary>
|
/// This is the handler of each snapping in the scroller. The
|
/// cell index will only be different from the data index if looping is on.
|
/// </summary>
|
/// <param name="scroller">The EnhancedScroller that fired the event</param>
|
/// <param name="cellIndex">The index of the cell that snapped on</param>
|
/// <param name="dataIndex">The data index of the cell that snapped on</param>
|
private void ScrollerSnapped(EnhancedScroller scroller, int cellIndex, int dataIndex)
|
{
|
// if we are not playing, ignore this event
|
if (GameState != GameStateEnum.Playing) return;
|
|
// increment the snap count. We will need three total snaps to tally the score
|
_snapCount++;
|
|
// set the slot of the snapped scroller for use in tallying the score
|
_snappedDataIndices[_snapCount - 1] = dataIndex;
|
|
if (_snapCount == _slotControllers.Length)
|
{
|
// if we've reached the final snap count, then tally the score
|
TallyScore();
|
|
// reenable the lever
|
pullLeverButton.interactable = true;
|
}
|
|
if (Credits == 0)
|
{
|
// if we are out of credits after tallying the score, go to a game over state
|
GameState = GameStateEnum.GameOver;
|
}
|
}
|
|
/// <summary>
|
/// This function calculates the slot score and updates the credits if necessary
|
/// </summary>
|
private void TallyScore()
|
{
|
// reset the snap count
|
_snapCount = 0;
|
|
var score = 0;
|
|
// get shortcuts to the snapped slots
|
var s1 = _snappedDataIndices[0];
|
var s2 = _snappedDataIndices[1];
|
var s3 = _snappedDataIndices[2];
|
|
if (s1 == blankIndex || s2 == blankIndex || s3 == blankIndex)
|
{
|
// at least one of the slot is blank, so no score
|
score = 0;
|
}
|
else
|
{
|
if (s1 == s2 && s1 == s3)
|
{
|
// all three slots are equal
|
|
if (s1 == sevenIndex)
|
{
|
// jackpot!
|
score = 1000;
|
}
|
else if (s1 == bigWinIndex)
|
{
|
// three big win
|
score = 150;
|
}
|
else if (s1 == tripleBarIndex)
|
{
|
// three triple bar
|
score = 70;
|
}
|
else if (s1 == cherryIndex)
|
{
|
// three cherries
|
score = 40;
|
}
|
else
|
{
|
// three of something else
|
score = 20;
|
}
|
}
|
else if (s1 == cherryIndex || s2 == cherryIndex || s3 == cherryIndex)
|
{
|
// at least one cherry showed up
|
score = 3;
|
}
|
}
|
|
if (score > 0)
|
{
|
// we had a score, so we add it to the credits and show the play win panel
|
Credits += score;
|
playWin.Play(score);
|
}
|
}
|
}
|
}
|
