// Use this for initialization
void Start()
{
handHelper = gameObject.transform.GetChild(0).gameObject.GetComponent <HandHelper>();
col = GetComponent <Collider2D>();
gameController = GameObject.FindGameObjectWithTag("GameController");
controller_scr = gameController.GetComponent <Controller>();
}
public void ShowHandHelper(Vector3 worldPosition, KinectInterop.HandState leftHandState,
KinectInterop.HandState rightHandState, float canvasRadius = 98.5f)
{
GameObject handHelperObject = Utils.Spawn(HandHelperPrefab, HandHelperRoot);
HandHelper handHelper = handHelperObject.GetComponent <HandHelper>();
handHelper.Init(worldPosition, leftHandState, rightHandState, canvasRadius);
}
private void ThrowIfDuplicate(IEnumerable <Player> players, IEnumerable <Card> doardCards)
{
List <Card> cards = new List <Card>(doardCards);
players.ToList().ForEach(p => cards.AddRange(p.Cards));
HandHelper.ThrowIfDuplicate(cards);
}
public void StraightFlush_EvaluateWinnersCount()
{
var players = new List <PokerPlayer>()
{
new PokerPlayer()
{
Name = "Marvz", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Eight, Suit.Clubs),
new Card(Rank.Nine, Suit.Clubs),
new Card(Rank.Queen, Suit.Clubs),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Ten, Suit.Clubs)
}
}
},
new PokerPlayer()
{
Name = "Keng", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Nine, Suit.Hearts),
new Card(Rank.King, Suit.Hearts),
new Card(Rank.Queen, Suit.Hearts),
new Card(Rank.Jack, Suit.Hearts),
new Card(Rank.Ten, Suit.Hearts)
}
}
},
new PokerPlayer()
{
Name = "Des", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Nine, Suit.Diamonds),
new Card(Rank.King, Suit.Diamonds),
new Card(Rank.Queen, Suit.Diamonds),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Ten, Suit.Diamonds)
}
}
}
};
foreach (var player in players)
{
player.Hand.EvaluateHandType();
}
var winners = HandHelper.EvaluateWinners(players, HandCategory.StraightFlush);
Assert.AreEqual(2, winners.Count);
}
public void HighCard_EvaluateWinnersCount()
{
var players = new List <PokerPlayer>()
{
new PokerPlayer()
{
Name = "Marvz", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Two, Suit.Clubs),
new Card(Rank.King, Suit.Spades),
new Card(Rank.Five, Suit.Diamonds),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Ace, Suit.Hearts)
}
}
},
new PokerPlayer()
{
Name = "Keng", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Three, Suit.Hearts),
new Card(Rank.King, Suit.Clubs),
new Card(Rank.Five, Suit.Spades),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Ace, Suit.Clubs)
}
}
},
new PokerPlayer()
{
Name = "Des", Hand = new Hand()
{
Cards = new Cards {
new Card(Rank.Three, Suit.Diamonds),
new Card(Rank.King, Suit.Hearts),
new Card(Rank.Five, Suit.Clubs),
new Card(Rank.Jack, Suit.Spades),
new Card(Rank.Ace, Suit.Diamonds)
}
}
}
};
foreach (var player in players)
{
player.Hand.EvaluateHandType();
}
var winners = HandHelper.EvaluateWinners(players, HandCategory.HighCard);
Assert.AreEqual(2, winners.Count);
}
public void OnePair_ShouldReturnFalse()
{
var cards = new Cards
{
new Card(Rank.Two, Suit.Clubs),
new Card(Rank.King, Suit.Spades),
new Card(Rank.Five, Suit.Diamonds),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Ace, Suit.Hearts)
};
Assert.IsFalse(HandHelper.IsItOnePair(cards));
}
public void OnePair_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Six, Suit.Clubs),
new Card(Rank.Nine, Suit.Spades),
new Card(Rank.King, Suit.Diamonds),
new Card(Rank.Nine, Suit.Clubs),
new Card(Rank.Ace, Suit.Hearts)
};
Assert.IsTrue(HandHelper.IsItOnePair(cards));
}
public void ThreeOfAKind_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Eight, Suit.Clubs),
new Card(Rank.King, Suit.Spades),
new Card(Rank.Eight, Suit.Diamonds),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Eight, Suit.Hearts)
};
Assert.IsTrue(HandHelper.IsItThreeOfAKind(cards));
}
public void Straight_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Nine, Suit.Clubs),
new Card(Rank.Seven, Suit.Spades),
new Card(Rank.Ten, Suit.Diamonds),
new Card(Rank.Eight, Suit.Clubs),
new Card(Rank.Six, Suit.Hearts)
};
Assert.IsTrue(HandHelper.IsItStraight(cards));
}
public void FullHouse_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Two, Suit.Clubs),
new Card(Rank.Four, Suit.Spades),
new Card(Rank.Two, Suit.Diamonds),
new Card(Rank.Four, Suit.Hearts),
new Card(Rank.Four, Suit.Clubs)
};
Assert.IsTrue(HandHelper.IsItFullHouse(cards));
}
public void FourOfAKind_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Seven, Suit.Clubs),
new Card(Rank.Four, Suit.Spades),
new Card(Rank.Four, Suit.Diamonds),
new Card(Rank.Four, Suit.Clubs),
new Card(Rank.Four, Suit.Hearts)
};
Assert.IsTrue(HandHelper.IsItFourOfAKind(cards));
}
public void RoyalFlush_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Ace, Suit.Clubs),
new Card(Rank.King, Suit.Clubs),
new Card(Rank.Queen, Suit.Clubs),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Ten, Suit.Clubs)
};
Assert.IsTrue(HandHelper.IsItRoyalFlush(cards));
}
public void StraightFlush_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Seven, Suit.Spades),
new Card(Rank.Four, Suit.Spades),
new Card(Rank.Five, Suit.Spades),
new Card(Rank.Six, Suit.Spades),
new Card(Rank.Three, Suit.Spades)
};
Assert.IsTrue(HandHelper.IsItStraightFlush(cards));
}
public void Flush_ShouldReturnTrue()
{
var cards = new Cards
{
new Card(Rank.Seven, Suit.Clubs),
new Card(Rank.King, Suit.Clubs),
new Card(Rank.Eight, Suit.Clubs),
new Card(Rank.Two, Suit.Clubs),
new Card(Rank.Ten, Suit.Clubs)
};
Assert.IsTrue(HandHelper.IsItFlush(cards));
}
// Update is called once per frame
void Update()
{
mainHand = controller.Frame().Hands[0];
objInLastFrame = objInCurrFrame;
objInCurrFrame = null;
//testing purposes
if (Input.GetKeyDown(KeyCode.I))
{
objInCurrFrame = CreateObject(MagicType.IceWall);
}
if (Input.GetKeyDown(KeyCode.F))
{
objInCurrFrame = CreateObject(MagicType.Fireball);
}
if (Input.GetKeyDown(KeyCode.T))
{
Application.LoadLevel(MagicConstant.TUTORIAL_LEVEL);
}
if (Input.GetKeyDown(KeyCode.G))
{
Application.LoadLevel(MagicConstant.GAME_LEVEL);
}
if (Input.GetKey(KeyCode.J) || Input.GetKey(KeyCode.Q))
{
player.transform.Rotate(new Vector3(0, -TURN_DIST, 0));
//pivot left
}
if (Input.GetKey(KeyCode.K) || Input.GetKey(KeyCode.E))
{
//pivot right
player.transform.Rotate(new Vector3(0, TURN_DIST, 0));
}
//Debug.Log (HandHelper.isFaceForward(mainHand, controller.Frame()) + " " + mainHand.Direction + ":" + mainHand.PalmNormal);
//cooling down, don't do anything else
if (cd.coolingDown(nc))
{
neutralize();
//hand stuff
}
else if (HandHelper.isValidHand(mainHand))
{
if (HandHelper.isClosedFist(mainHand))
{
//nc.resetBottomServo();
canCharge = true;
}
else if (HandHelper.isFaceUp(mainHand, controller.Frame()) && canCharge)
{
Debug.Log(chargeCounter);
if (chargeCounter <= LONG_THRESHOLD)
{
if (chargeCounter > SHORT_THRESHOLD && chargeCounter <= MEDIUM_THRESHOLD)
{
objInCurrFrame = CreateObject(MagicType.FireCharge, Size.Medium);
}
else if (chargeCounter > MEDIUM_THRESHOLD)
{
objInCurrFrame = CreateObject(MagicType.FireCharge, Size.Large);
}
else
{
objInCurrFrame = CreateObject(MagicType.FireCharge, Size.Small);
}
//Debug.Log ("Charging: " + chargeCounter);
nc.heatPeltier(lastSize);
chargeCounter++;
//overloaded, go into cooldown
}
else
{
Debug.Log("Charged too long, in cooldown mode");
neutralize();
cd.startCooldown();
}
//shoot charged object
}
else if (HandHelper.isFaceForward(mainHand, controller.Frame()) && chargeCounter > MIN_THRESHOLD)
{
objInCurrFrame = CreateObject(MagicType.Fireball);
neutralize();
//charge ice wall
}
else if (HandHelper.isFaceForward(mainHand, controller.Frame()))
{
Vector3 palmPos = mainHand.PalmPosition.ToUnityScaled();
Collider[] hitColliders = Physics.OverlapSphere(transform.TransformPoint(palmPos), CLOSEST_ICEWALL_DIST);
bool collided = false;
for (int i = 0; i < hitColliders.Length; i++)
{
if (hitColliders[i].tag == MagicConstant.ICEWALL_TAG)
{
hitColliders[i].SendMessage(MagicConstant.ICEWALL_CHARGE_SPELLNAME);
collided = true;
}
}
//create an ice wall if there isn't a nearby one and a circle gesture was performed
if (!collided && GameObject.FindWithTag(MagicConstant.FIREBALL_TAG) == null)
{
iceCounter++;
if (iceCounter > ICE_THRESHOLD)
{
objInCurrFrame = CreateObject(MagicType.IceWall);
canIce = false;
iceCounter = 0;
}
}
}
else
{
idling();
}
}
else
{
idling();
}
}
public override bool ReadyForNextInstr(float deltaTime, Frame frame, Hand hand)
{
Texture texture;
//do this only at start of new instruction
if (deltaTime < 0.5f)
{
switch (gestureType)
{
case "fist":
texture = Resources.Load("Images/fist-close") as Texture;
renderer.material.mainTexture = texture;
break;
case "fire":
texture = Resources.Load("Images/fist-open") as Texture;
renderer.material.mainTexture = texture;
break;
case "fireball":
texture = Resources.Load("Images/open-shoot") as Texture;
renderer.material.mainTexture = texture;
break;
case "forward":
texture = Resources.Load("Images/hand-open") as Texture;
renderer.material.mainTexture = texture;
break;
case "ice":
texture = Resources.Load("Images/spin-hand") as Texture;
renderer.material.mainTexture = texture;
break;
default:
Debug.Log("unrecognized gesture");
break;
}
}
if (deltaTime >= thresholdTime)
{
switch (gestureType)
{
case "fist":
return(HandHelper.isClosedFist(hand));
case "fire":
return(GameObject.FindGameObjectsWithTag(MagicConstant.FIRECHARGE_TAG).Length > 0);
case "fireball":
//shoot two before continuing
return(GameObject.FindGameObjectsWithTag(MagicConstant.FIREBALL_TAG).Length > 1);
case "forward":
return(HandHelper.isFaceForward(hand, frame));
case "ice":
return(GameObject.FindGameObjectsWithTag(MagicConstant.ICEWALL_TAG).Length > 0);
default:
Debug.Log("unrecognized gesture");
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Evaluate winner based on hand category
/// </summary>
private void EvaluateWinners()
{
this._winningHandCategory = HandHelper.GetWinningHandCategory(this._players);
this._winners = HandHelper.EvaluateWinners(this._players, this._winningHandCategory);
}
