Almost done

Assets/Scenes/SampleSceneBkp.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 298fe1a2e6f8c144390dbaac85e13be0
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/BettingBoardManager.cs

@@ -0,0 +1,7 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class BettingBoardManager : MonoBehaviour
+{
+}

Assets/Scripts/BettingBoardManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5750d50a785169c4cae5c793a7759769
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/BettingSpace.cs

@@ -11,6 +11,10 @@ public class BettingSpace : MonoBehaviour
     Image image;
     Color defaultColor;
     RectTransform rect;
+    public Vector3 curPosition;
+    public float distance;
+
+    public int Number;
     void Start()
     {
         rect = GetComponent<RectTransform>();
@@ -33,22 +37,40 @@ public class BettingSpace : MonoBehaviour
         eventTrigger.triggers.Add(OnEnter);
         eventTrigger.triggers.Add(OnExit);
         eventTrigger.triggers.Add(OnClick);
-    }
 
+        curPosition = transform.position;
+
+        RouletteManager.RegisterBettingSpace(this);
+    }
+    Color changedColor {get { return new Color(defaultColor.r,defaultColor.g,defaultColor.b,defaultColor.a*0.5f);}}
     void onEnter(BaseEventData e){
-        image.color = new Color(defaultColor.r,defaultColor.g,defaultColor.b,defaultColor.a*0.5f);
+        if(RouletteManager.spinning){return;}
+
+        RouletteManager.HighlightBettingSpace(new List<int>(){Number});
     }
 
     void onExit(BaseEventData e){
-        image.color = defaultColor;
+        if(RouletteManager.spinning){return;}
+
+        RouletteManager.ClearHighlightedBettingSpaces();
     }
 
     void onClick(BaseEventData e){
+        if(RouletteManager.spinning){return;}
+
+        if(RouletteManager.MoneyAvailable < RouletteManager.SelectedChip){return;}
+
+
         GameObject newChip = Instantiate(RouletteManager.SelectedChipItem.gameObject, transform);
         newChip.GetComponent<RectTransform>().localPosition = Vector3.zero;
         newChip.GetComponent<RectTransform>().sizeDelta = new Vector2(50,50);
 
-        RouletteManager.AddBet(RouletteManager.SelectedChip);
+        RouletteManager.AddBet(RouletteManager.SelectedChip, CombinerType.Single, new List<int>(){Number}, newChip);
+    }
+
+    public void SetHighlighted(bool value){
+        // image.color = value ? changedColor : defaultColor;
+        GetComponent<Outline>().effectColor = new Color(1,1,1, (value) ? 0.5f:0);
     }
     
 }

Assets/Scripts/BettingSpaceCombiner.cs

@@ -0,0 +1,163 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+public class BettingSpaceCombiner : MonoBehaviour
+{
+    public CombinerType combinerType;
+    public List<int> combinedNumbers;
+
+    EventTrigger eventTrigger;
+
+    void Start(){
+        eventTrigger = GetComponent<EventTrigger>();
+        EventTrigger.Entry OnEnter = new EventTrigger.Entry();
+        OnEnter.eventID = EventTriggerType.PointerEnter;
+        OnEnter.callback.AddListener(onEnter);
+
+        EventTrigger.Entry OnExit = new EventTrigger.Entry();
+        OnExit.eventID = EventTriggerType.PointerExit;
+        OnExit.callback.AddListener(onExit);
+
+        EventTrigger.Entry OnClick = new EventTrigger.Entry();
+        OnClick.eventID = EventTriggerType.PointerClick;
+        OnClick.callback.AddListener(onClick);
+
+        eventTrigger.triggers.Add(OnEnter);
+        eventTrigger.triggers.Add(OnExit);
+        eventTrigger.triggers.Add(OnClick);
+    }
+
+    void onEnter(BaseEventData e){
+        if(RouletteManager.spinning){return;}
+
+        RouletteManager.HighlightBettingSpace(combinedNumbers);
+        // Debug.Log("Comb : " + combinedNumbers.ToString());
+    }
+
+    void onExit(BaseEventData e){
+        if(RouletteManager.spinning){return;}
+
+        RouletteManager.ClearHighlightedBettingSpaces();
+    }
+
+    void onClick(BaseEventData e){
+        if(RouletteManager.spinning){return;}
+
+        if(RouletteManager.MoneyAvailable < RouletteManager.SelectedChip){return;}
+
+        GameObject newChip = Instantiate(RouletteManager.SelectedChipItem.gameObject,transform.parent.parent);
+        newChip.GetComponent<RectTransform>().position = GetComponent<RectTransform>().position;
+        newChip.GetComponent<RectTransform>().sizeDelta = new Vector2(50,50);
+
+        RouletteManager.AddBet(RouletteManager.SelectedChip, combinerType, combinedNumbers, newChip);
+    }
+
+    void OnValidate(){
+        string[] args = name.Split("_");
+        if(args[0] == "Split"){
+            combinerType = CombinerType.Split;
+        }else if(args[0]== "Street"){
+            combinerType = CombinerType.Street;
+        }else if(args[0] == "Corner"){
+            combinerType = CombinerType.Corner;
+        }else if(args[0] == "Five"){
+            combinerType = CombinerType.Five;
+        }else if(args[0] == "Line"){
+            combinerType = CombinerType.Corner;
+        }else if(args[0] == "Dozen"){
+            combinerType = CombinerType.Dozen;
+            combinedNumbers = new List<int>();
+            int offset = 1;
+            if(args[1] == "2"){
+                offset+=12;
+            }else if(args[1] == "3"){
+                offset += 24;
+            }
+            for(int i=0; i < 12; i++){
+                combinedNumbers.Add(i+ offset);
+            }
+            return;
+        }else if(args[0] == "Row"){
+            combinerType = CombinerType.Row;
+            combinedNumbers = new List<int>();
+            int mult = 0;
+            if(args[1] == "2"){
+                mult=1;
+            }else if(args[1] == "3"){
+                mult=2;
+            }
+            for(int i=0; i < 36; i+=3){
+                combinedNumbers.Add((i+1) + mult);
+            }
+            return;
+        }else if(args[0] == "18"){
+            combinerType = CombinerType.Eighteen;
+            combinedNumbers = new List<int>();
+            int offset = 1;
+            if(args[1] == "2"){
+                offset += 18;
+            }
+            for(int i=0; i < 18; i++){
+                combinedNumbers.Add((i+1) + offset);
+            }
+            return;
+        }else if(args[0] == "Odd"){
+            combinerType = CombinerType.Odd;
+            combinedNumbers = new List<int>();
+            for(int i=0; i < 36; i++){
+                if(i%2!=0){combinedNumbers.Add((i+1));}
+            }
+            return;
+        }else if(args[0] == "Even"){
+            combinerType = CombinerType.Even;
+            combinedNumbers = new List<int>();
+            for(int i=0; i < 36; i++){
+                if(i%2==0){combinedNumbers.Add((i+1));}
+            }
+            return;
+        }else if(args[0] == "Red"){
+            combinerType = CombinerType.Red;
+            combinedNumbers = new List<int>();
+            for(int i=0; i < 36; i++){
+                if(RouletteManager.Reds.Contains((i+1))){combinedNumbers.Add((i+1));}
+            }
+            return;
+        }else if(args[0] == "Black"){
+            combinerType = CombinerType.Black;
+            combinedNumbers = new List<int>();
+            for(int i=0; i < 36; i++){
+                if(!RouletteManager.Reds.Contains((i+1))){combinedNumbers.Add((i+1));}
+            }
+            return;
+        }{
+            return;
+        }
+
+        combinedNumbers = new List<int>();
+        for(int i=1; i < args.Length; i++){
+            combinedNumbers.Add(int.Parse(args[i]));
+        }
+
+        // GetComponent<Image>().color = new Color(1,1,1,0);
+    }
+}
+
+
+public enum CombinerType{
+    Split,
+    Street,
+    Corner,
+    Line,
+    Five,
+    Dozen,
+    Row,
+    Eighteen,
+    Red,
+    Black,
+    Odd,
+    Even,
+    Single
+}

Assets/Scripts/BettingSpaceCombiner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a0e35a98e6a1cf42b9df59602952122
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Chip.cs

@@ -16,12 +16,13 @@ public class Chip : MonoBehaviour
             RouletteManager.OnMoneyAvailablChanged.AddListener(OnMoneyChanged);
             GetComponent<Button>().onClick.AddListener(OnClicked);
         }else{
+            GetComponent<Image>().raycastTarget = false;
         }
     }
 
 
     void OnMoneyChanged(float newMoney){
-        gameObject.SetActive(newMoney >= value);
+        GetComponent<Button>().interactable = newMoney >= value;
     }
 
     void OnClicked(){

Assets/Scripts/ChipBoard.cs

@@ -4,11 +4,15 @@ using EasyButtons;
 using UnityEngine;
 using TMPro;
 using UnityEngine.UI;
+using UnityEngine.EventSystems;
 
 public class ChipBoard : MonoBehaviour
 {
+    public static ChipBoard instance;
     public Transform numberGridParent;
     public Color redColor,blackColor;
+    public EventTrigger eventTrigger;
+    public float DistanceThreshold = 10;
 
     [Button]
     void Config(){
@@ -16,16 +20,33 @@ public class ChipBoard : MonoBehaviour
             GameObject newItem= Instantiate(numberGridParent.GetChild(0).gameObject, numberGridParent);
             newItem.GetComponent<Image>().color = RouletteManager.Reds.Contains(i+1) ? redColor : blackColor;
             newItem.GetComponentInChildren<TMP_Text>().text = (i+1).ToString();
+            newItem.GetComponent<BettingSpace>().Number = i+1;
         }
     }
-    void Start()
+    void Awake()
     {
-        
+        instance = this;
+        EventTrigger.Entry OnEnter = new EventTrigger.Entry();
+        OnEnter.eventID = EventTriggerType.PointerEnter;
+        OnEnter.callback.AddListener(onEnter);
+
+        EventTrigger.Entry OnExit = new EventTrigger.Entry();
+        OnExit.eventID = EventTriggerType.PointerExit;
+        OnExit.callback.AddListener(onExit);
+
+        eventTrigger.triggers.Add(OnEnter);
+        eventTrigger.triggers.Add(OnExit);
     }
 
-    // Update is called once per frame
-    void Update()
-    {
-        
+    bool mouseIn = false;
+    void onEnter(BaseEventData e){
+        mouseIn= true;
     }
+
+    void onExit(BaseEventData e){
+        mouseIn=false;
+    }
+
+  
+    
 }

Assets/Scripts/RouletteManager.cs

@@ -8,7 +8,7 @@ public class RouletteManager : MonoBehaviour
 {
     public static RouletteManager instance { get; private set;}
     private static float moneyAvailable = 1000;
-    public static float MoneyAvailable {get{ return moneyAvailable;} set{OnMoneyAvailablChanged.Invoke(value); moneyAvailable = value;}}
+    public static float MoneyAvailable {get{ return moneyAvailable;} set{OnMoneyAvailablChanged.Invoke(value); moneyAvailable = value; instance.vcurrencyTxt.text = value.ToString();}}
     public static UnityEvent<float> OnMoneyAvailablChanged = new UnityEvent<float>();
 
     public static Dictionary<float, Chip> chipsBoard {get; private set;}
@@ -20,26 +20,91 @@ public class RouletteManager : MonoBehaviour
         chipsBoard.Add(chip.value, chip);
         selectedChipChanged.AddListener(chip.OnSelectedChanged);
         chip.OnSelectedChanged(SelectedChip);
+        
         return true;
     }
     public static UnityEvent<float> selectedChipChanged = new UnityEvent<float>();
-    private static float m_selectedChip = 0.2f;
+    private static float m_selectedChip = 1f;
     public static float SelectedChip { get{ return m_selectedChip; } set{
         m_selectedChip = value;
         selectedChipChanged.Invoke(value);
     }}
 
     public static Chip SelectedChipItem{get{return chipsBoard[SelectedChip];}}
-    public static int[] RouletteNumbers = {00,27,10,25,29,12,8,19,31,18,6,21,33,16,4,23,35,14,2,0,28,9,26,30,11,7,20,32,17,5,22,34,15,3,24,36,13,1};
+    public static int[] RouletteNumbers = {-1,27,10,25,29,12,8,19,31,18,6,21,33,16,4,23,35,14,2,0,28,9,26,30,11,7,20,32,17,5,22,34,15,3,24,36,13,1};
     public static List<int> Reds = new List<int>(){1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36};
-    
-    public static float bets;
-    public TMP_Text betsvalue;
 
-    public static void AddBet(float value){
-        bets += value;
+    public static Dictionary<int, BettingSpace> bettingSpaces = new Dictionary<int, BettingSpace>();
+    public static List<int> HighlightedBettingSpaces = new List<int>();
+    private static List<Bet> bets = new List<Bet>();
+    public static List<Bet> PlacedBets {get{return bets;}}
+
+    public static bool spinning;
+    public TMP_Text betsvalue;
+    public TMP_Text vcurrencyTxt;
+
+
+    public static void RegisterBettingSpace(BettingSpace space){
+        if(bettingSpaces.ContainsKey(space.Number)){return;}
+        bettingSpaces.Add(space.Number, space);
+    }
+
+    public static void HighlightBettingSpace(List<int> numbers){
+        HighlightedBettingSpaces = numbers;
+        UpdateHightlightedSpaces();
+    }
+   
+    public static void ClearHighlightedBettingSpaces(){ HighlightedBettingSpaces = new List<int>(); UpdateHightlightedSpaces();}
+
+    static void UpdateHightlightedSpaces(){
+        foreach(KeyValuePair<int,BettingSpace> bettingSpace in bettingSpaces){
+            if(HighlightedBettingSpaces.Contains(bettingSpace.Key)){
+                bettingSpace.Value.SetHighlighted(true);
+            }else{
+                bettingSpace.Value.SetHighlighted(false);
+
+            }
+        }
+    }
+
+
+    public static void RefreshUI(){
+        instance.Refresh();
+    }
+
+    public void Refresh(){
+        
+        betsvalue.text = "$"+ GetBetsValue();
+
+    }
+
+    public static float GetBetsValue(){
+        float betsVal = 0;
+        foreach(Bet bet in bets){
+            betsVal += bet.BetAmount;
+        }
+
+        return betsVal;
+    }
+
+    public static void AddBet(float value, CombinerType type, List<int> _numbers, GameObject newChip){
+        // bets += value;
+        if(value > MoneyAvailable){Debug.LogError("Not enough money for this"); return;}
+        Bet newBet = new Bet(){BetAmount = value, PayoutRatio = GetRatioFromType(type), Numbers = _numbers, chipObj= newChip};
+        bets.Add(newBet);
         MoneyAvailable-=value;
         instance.BetsChanged();
+
+        RefreshUI();
+    }
+
+    public static void ClearBets(){
+        foreach(Bet bet in bets){
+            Destroy(bet.chipObj);
+        }
+        bets = new List<Bet>();
+
+        RefreshUI();
     }
 
     void Awake(){
@@ -51,11 +116,89 @@ public class RouletteManager : MonoBehaviour
     }
 
     void OnSpinStopped(int landedValue){
-        MoneyAvailable -= 100;
+        foreach(Bet bet in bets){
+            if(bet.Numbers.Contains(landedValue)){
+
+                MoneyAvailable += bet.BetAmount * bet.PayoutRatio;
+                MoneyAvailable += bet.BetAmount;
+            }
+        }
+
+        ClearBets();
     }
 
     void BetsChanged(){
-        betsvalue.text = "$"+bets.ToString();
+    }
+
+
+
+
+
+
+    public static float GetRatioFromType(CombinerType type){
+        switch(type){
+            case CombinerType.Single:
+                return 35;
+                break;
+
+            case CombinerType.Split:
+                return 17;
+                break;
+
+            case CombinerType.Street:
+                return 11;
+                break;
+
+            case CombinerType.Corner:
+                return 8;
+                break;
+
+            case CombinerType.Five:
+                return 6;
+                break;
+
+            case CombinerType.Line:
+                return 5;
+                break;
+
+            case CombinerType.Dozen:
+                return 2;
+                break;
+
+            case CombinerType.Row:
+                return 2;
+                break;
+
+            case CombinerType.Eighteen:
+                return 1;
+                break;
+
+            case CombinerType.Red:
+                return 1;
+                break;
+
+            case CombinerType.Black:
+                return 1;
+                break;
+
+            case CombinerType.Even:
+                return 1;
+                break;
+
+            case CombinerType.Odd:
+                return 1;
+                break;
+        }
+        return 1;
+
     }
 
 }
+
+[System.Serializable]
+public class Bet{
+    public float BetAmount;
+    public float PayoutRatio = 1;
+    public List<int> Numbers;
+    public GameObject chipObj;
+}

Assets/Scripts/Spinner.cs

@@ -6,7 +6,11 @@ using TMPro;
 
 public class Spinner : MonoBehaviour
 {
+    public static Spinner instance;
 
+    void Awake(){
+        instance =this;
+    }
     public static int LandedNumber{get; private set;}
     public static UnityEvent<int> OnSpinStopped = new UnityEvent<int>();
     public Transform wheel;
@@ -51,6 +55,8 @@ public class Spinner : MonoBehaviour
         }
     }
     public void Spin(){
+        if(RouletteManager.GetBetsValue() <= 0){return;}
+        RouletteManager.spinning = true;
         StartCoroutine(spin());
     }
 
@@ -67,10 +73,12 @@ public class Spinner : MonoBehaviour
 
 
     private void m_onSpinStopped(){
+        RouletteManager.spinning = false;
         
         LandedNumber = GetLandedNumber();
         Debug.Log($"Landed on {LandedNumber}");
         numText.text = LandedNumber.ToString();
+        if(LandedNumber == -1){numText.text = "00";}
         
 
 

ProjectSettings/TagManager.asset

@@ -11,7 +11,7 @@ TagManager:
   - 
   - Water
   - UI
-  - 
+  - HiddenUI
   - 
   - 
   -