public bool DoubleDown(HandInfo info)
{
var action = Table.GetAction(info);
return(action == ActionTable.ActionTypes.DoubleDownOrHit ||
action == ActionTable.ActionTypes.DoubleDownOrStand);
}
public bool Split(HandInfo info)
{
var action = Table.GetAction(info);
return(action == ActionTable.ActionTypes.SplitOrHit ||
action == ActionTable.ActionTypes.SplitOrStand);
}
public virtual bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (soft)
{
if (value == 16 || value == 17 || value == 18)
{
return(dealer < Ranks.Seven);
}
return(false);
}
if ((value == 10 || value == 11) && value > info.DealerHand.Value)
{
return(true);
}
if (dealer < Ranks.Seven && value == 9)
{
return(true);
}
return(false);
}
public override void HandOver(HandInfo info)
{
//Adjust the count based on what was seen this hand.
foreach (var c in info.DealerHand.Cards)
{
if (c.Rank < Ranks.Seven)
{
count++;
}
else if (c.Rank > Ranks.Nine)
{
count--;
}
}
foreach (var h in info.PlayerHands)
{
foreach (var c in h.Cards)
{
if (c.Rank < Ranks.Seven)
{
count++;
}
else if (c.Rank > Ranks.Nine)
{
count--;
}
}
}
base.HandOver(info);
}
public ActionResult Draw(int[] arr, int betAmt)
{
drawCards = new List <Card>();
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] == 0)
{
drawCards.Add(dealCards[i + 5]);
}
else
{
drawCards.Add(dealCards[i]);
}
}
GameViewModel gameStatus = new GameViewModel
{
Message = "Game Over",
Hand = drawCards,
GameOver = true,
Credits = (int)userAccountInfo.Credits,
BetAmount = betAmt,
Paytable = dbContext.JacksOrBetterPayouts.ToList()
};
HandInfo.EvaluateHand(gameStatus, drawCards, userAccountInfo);
return(Json(gameStatus, JsonRequestBehavior.AllowGet));
}
public ActionResult Deal(int bet)
{
int userId = 1;
userAccountInfo = dbContext.UserAccounts.Where(u => u.UserId == userId).FirstOrDefault();
List <int> shuffle = GameAction.ShuffleDeck();
dealCards = new List <Card>();
foreach (var item in shuffle)
{
var card = dbContext.Cards.Where(c => c.CardId == item).FirstOrDefault();
dealCards.Add(card);
}
foreach (var item in dealCards)
{
item.ImageName = item.ImageName.Insert(0, "/Images/");
}
GameViewModel gameStatus = new GameViewModel
{
Message = "Hold / Draw 1 to 5 Cards",
Hand = dealCards.Take(5).ToList(),
GameOver = false,
BetAmount = bet
};
gameStatus.Paytable = dbContext.JacksOrBetterPayouts.ToList();
gameStatus.Credits = (int)userAccountInfo.Credits - gameStatus.BetAmount;
HandInfo.EvaluateHand(gameStatus, dealCards, userAccountInfo);
return(Json(gameStatus, JsonRequestBehavior.AllowGet));
}
public override bool Surrender(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (!soft && value == 15 && dealer == Ranks.Ten)
{
return(true);
}
if (!soft && value == 16 && dealer > Ranks.Eight)
{
return(true);
}
if (!soft && dealer > Ranks.Nine &&
hand.Cards.ElementAt(0).Rank == Ranks.Seven &&
hand.Cards.ElementAt(1).Rank == Ranks.Seven)
{
return(true);
}
return(base.Surrender(info));
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
if (input.bLeftShoulderReleased || input.bRightShoulderReleased)
{
cockpit.ActiveCamera.SetTargetVisible(false);
HandInfo hi = (HandInfo)data.custom_data;
if (hi.eMode == ActionMode.SetWorldScale)
{
hi.CompleteSetWorldScale(cockpit);
}
return(Capture.End);
}
else
{
HandInfo hi = (HandInfo)data.custom_data;
if (hi.eMode == ActionMode.SetWorldScale)
{
return(Update_SetWorldScale(input, data));
}
else
{
return(Update_TransformCamera(input, data));
}
}
}
public GameModel Draw(int[] arr, int bet)
{
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] == 0)
{
_drawCards.Add(_dealCards[i + 5]);
}
else
{
_drawCards.Add(_dealCards[i]);
}
}
GameModel model = new GameModel
{
Message = ApplicationConstants.GameOver,
Hand = _drawCards,
GameOver = true,
Credits = (int)_userAccountInfo.Credits,
BetAmount = bet,
DoubleBonusPaytable = dbContext.DoubleBonusPayouts.ToList()
};
HandInfo.EvaluateHand(model, _drawCards, _userAccountInfo);
if (model.Credits <= 0)
{
model.Credits = 100;
_userAccountInfo.Credits = 100;
dbContext.SaveChanges();
}
return(model);
}
private void MultiQuery(HandInfo info)
{
PrintHand(info);
Console.WriteLine();
PrintCount(info);
Console.WriteLine();
bool canSurrender = Game.CanSurrender(info.PlayerHands.ElementAt(info.HandToPlay));
bool canSplit = Game.CanSplit(info.PlayerHands.ElementAt(info.HandToPlay));
bool canDoubleDown = Game.CanDoubleDown(info.PlayerHands.ElementAt(info.HandToPlay));
while (nextAction != "h" &&
nextAction != "s" &&
(nextAction != "r" || !canSurrender) &&
(nextAction != "p" || !canSplit) &&
(nextAction != "d" || !canDoubleDown))
{
Console.Write("[h=hit, s=stand");
if (canSurrender)
{
Console.Write(", r=surrender");
}
if (canSplit)
{
Console.Write(", p=split");
}
if (canDoubleDown)
{
Console.Write(", d=double down");
}
Console.WriteLine("]");
Console.Write("Action? ");
nextAction = Console.ReadLine().ToLower();
}
}
public GameModel Deal(int bet)
{
List <int> shuffle = GameAction.ShuffleDeck();
_dealCards = new List <Card>();
foreach (var item in shuffle)
{
var card = dbContext.Cards.Where(c => c.CardId == item).FirstOrDefault();
_dealCards.Add(card);
}
GameModel model = new GameModel
{
Message = ApplicationConstants.HoldDrawMessage,
Hand = _dealCards.Take(5).ToList(),
GameOver = false,
BetAmount = bet,
DoubleBonusPaytable = dbContext.DoubleBonusPayouts.ToList(),
Credits = (int)_userAccountInfo.Credits - bet
};
HandInfo.EvaluateHand(model, _dealCards, _userAccountInfo);
if (model.Credits <= 0)
{
model.Credits = 100;
_userAccountInfo.Credits = 100;
dbContext.SaveChanges();
}
model.DoubleBonusPaytable = model.DoubleBonusPaytable.OrderByDescending(e => e.Id).ToList();
return(model);
}
public bool Split(HandInfo info)
{
var pRank = info.PlayerHands.ElementAt(info.HandToPlay).Cards.ElementAt(0).Rank;
var dRank = info.DealerHand.Cards.ElementAt(0).Rank;
return(splits[(int)pRank][(int)dRank]);
}
/// <summary>
/// Spawns a cube in front of the user when the user performs a Click Gesture and its detected by the system.
/// </summary>
private void SpawnCubewithclickTriggerGesture()
{
//All the information for a detected hand. It refers to a single hand.
HandInfo handInformation = ManomotionManager.Instance.Hand_infos[0].hand_info;
//All the gesture information for this hand.
GestureInfo gestureInformation = handInformation.gesture_info;
//The trigger gesture that is detected in this frame.
ManoGestureTrigger currentDetectedTriggerGesture = gestureInformation.mano_gesture_trigger;
if (currentDetectedTriggerGesture == ManoGestureTrigger.CLICK)
{
//A click has been performed by the user and it has been detected as the current trigger Gesture.
ManoClicked = true;
StartCoroutine(timer(1));
//GameObject newItem = Instantiate(itemPrefab);
////Spawn a cube at the position of the camera, also adding a small offset forward so it does not spawn right in front of it.
//Vector3 positionToMove = Camera.main.transform.position + (Camera.main.transform.forward * 2);
//newItem.transform.position = positionToMove;
////Make the phone vibrate for feedback.
Handheld.Vibrate();
}
else if (currentDetectedTriggerGesture == ManoGestureTrigger.RELEASE_GESTURE)
{
//A grab and release has been performed by the user and it has been detected as the current trigger Gesture.
ManoReleased = true;
StartCoroutine(timer(2));
Handheld.Vibrate();
}
}
public bool Surrender(HandInfo info)
{
var action = Table.GetAction(info);
return(action == ActionTable.ActionTypes.SurrenderOrHit ||
action == ActionTable.ActionTypes.SurrenderOrStand);
}
/*--------------------------------------------------------------------------------------------*/
private static HandInfo UpdateHandInfo(HandInfo pInfo) {
pInfo.IsAvailable = (pInfo.IsAvailableInterface.GetState().Value > 0);
pInfo.Confidence = (float)pInfo.ConfidenceInterface.GetState().Value;
pInfo.GrabStrength = (float)pInfo.GrabStrengthInterface.GetState().Value;
pInfo.PinchStrength = (float)pInfo.PinchStrengthInterface.GetState().Value;
pInfo.PalmWidth = (float)pInfo.PalmWidthInterface.GetState().Value;
return pInfo;
}
public void HandOver(HandInfo info)
{
handsPlayed++;
if (Print && handsPlayed % 100000 == 0)
{
Console.WriteLine(handsPlayed);
}
}
public HandInfo GenerateRandomHand()
{
HandInfo handInfo = new HandInfo();
Card[] cards = GetShuffledCards();
CardLayout playerDeck = new CardLayout(cards.Take(7));
CardLayout oppDeck = new CardLayout(cards.Skip(7).Take(2).Union(cards.Skip(2).Take(5)));
CardSet cardSet = new CardSet(new[] { playerDeck, oppDeck });
if (cardSet.IsWinning)
{
handInfo.WinningPlayer = 0;
}
else if (cardSet.IsLoosing)
{
handInfo.WinningPlayer = 1;
}
else
{
handInfo.WinningPlayer = -1;
}
//PreFlop,Flop,Turn,River hand evaluation
int hand = 0;
Card[] playerHand = playerDeck.Cards.Take(2).ToArray();
hand += EvaluatePreflop(playerHand);
Card[] playerFlop = playerDeck.Cards.Take(5).ToArray();
hand += EvaluateFlop(playerFlop) * _maxHandResolution;
Card[] playerTurn = playerDeck.Cards.Take(6).ToArray();
hand += EvaluateTurn(playerTurn) * _maxHandResolution * _maxHandResolution;
Card[] playerRiver = playerDeck.Cards.Take(7).ToArray();
hand += EvaluateRiver(playerRiver) * _maxHandResolution * _maxHandResolution * _maxHandResolution;
int hand2 = 0;
if (_twoPlayer)
{
Card[] oppHand = oppDeck.Cards.Take(2).ToArray();
hand2 += EvaluatePreflop(oppHand);
Card[] oppFlop = oppDeck.Cards.Take(5).ToArray();
hand2 += EvaluateFlop(oppFlop) * _maxHandResolution;
Card[] oppTurn = oppDeck.Cards.Take(6).ToArray();
hand2 += EvaluateTurn(oppTurn) * _maxHandResolution * _maxHandResolution;
Card[] oppRiver = oppDeck.Cards.Take(7).ToArray();
hand2 += EvaluateRiver(oppRiver) * _maxHandResolution * _maxHandResolution * _maxHandResolution;
}
handInfo.Hand = hand;
handInfo.OppHand = hand2;
return(handInfo);
}
/*--------------------------------------------------------------------------------------------*/
private static HandInfo UpdateHandInfo(HandInfo pInfo)
{
pInfo.IsAvailable = (pInfo.IsAvailableInterface.GetState().Value > 0);
pInfo.Confidence = (float)pInfo.ConfidenceInterface.GetState().Value;
pInfo.GrabStrength = (float)pInfo.GrabStrengthInterface.GetState().Value;
pInfo.PinchStrength = (float)pInfo.PinchStrengthInterface.GetState().Value;
pInfo.PalmWidth = (float)pInfo.PalmWidthInterface.GetState().Value;
return(pInfo);
}
public bool Hit(HandInfo info)
{
var action = Table.GetAction(info);
return(action == ActionTable.ActionTypes.SplitOrHit ||
action == ActionTable.ActionTypes.DoubleDownOrHit ||
action == ActionTable.ActionTypes.Hit ||
action == ActionTable.ActionTypes.SurrenderOrHit);
}
public virtual void HandOver(HandInfo info)
{
handsPlayed++;
if (handsPlayed == nextPrint)
{
Console.WriteLine(handsPlayed);
nextPrint += 100000L;
}
}
public void HandOver(HandInfo info)
{
_handsPlayed++;
handsTilPrint--;
if (handsTilPrint == 0)
{
handsTilPrint = 10000;
Console.WriteLine(_handsPlayed);
}
}
void ObjectGrabbingLogic(HandInfo hand)
{
Collider[] colliders = Physics.OverlapSphere(hand.previousPostion, hand.rigidbody.transform.localScale.x, grabbableObjectLayerMask);
if (Input.GetAxis(hand.gripAxis) >= 0.25f)
{
if (colliders.Length > 0 && hand.state == HandState.Empty)
{
Collider firstColliderFound = colliders[0];
Rigidbody rb = firstColliderFound.attachedRigidbody;
if (rb != null)
{
hand.grippedObjectIsKinematic = rb.isKinematic;
rb.isKinematic = false;
hand.grippedObjectOriginalLayer = rb.gameObject.layer;
if (changeGrabbedObjectLayer)
{
rb.gameObject.SetLayerRecursively(LayerMask.NameToLayer(grabbedLayerName));
}
//rb.gameObject.SetLayerRecursively(LayerMask.NameToLayer("Grabbed"));
hand.grabOffset = firstColliderFound.transform.position - hand.rigidbody.transform.position;
hand.grippedObject = rb;
FixedJoint joint = rb.gameObject.AddComponent <FixedJoint>();
joint.enablePreprocessing = false;
joint.connectedBody = hand.rigidbody;
hand.state = HandState.ObjectGrab;
hand.rigidbody.GetComponentInChildren <MeshRenderer>().enabled = false;
}
}
}
if (hand.state == HandState.ObjectGrab && Input.GetAxis(hand.gripAxis) < 0.25f)
{
Rigidbody rb = hand.grippedObject;
FixedJoint joint = rb.GetComponent <FixedJoint>();
Destroy(joint);
if (rb != null)
{
rb.velocity = (hand.rigidbody.transform.position - hand.previousPostion) / Time.deltaTime;
if (changeGrabbedObjectLayer)
{
rb.gameObject.SetLayerRecursively(hand.grippedObjectOriginalLayer);
}
rb.isKinematic = hand.grippedObjectIsKinematic;
}
hand.state = HandState.Empty;
hand.rigidbody.GetComponentInChildren <MeshRenderer>().enabled = true;
}
}
public void ApplyPose(Pose pose)
{
// Get the proper info using hand's type
HandInfo handInfo = pose.GetHandInfo(handType);
// Apply rotations
ApplyFingerRotations(handInfo.fingerRotations);
// Position, and rotate, this differs on the type of hand
ApplyOffset(handInfo.attachPosition, handInfo.attachRotation);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private HandInfo BuildHandInfo(string pPath) {
ClientContext c = ContextProvider.Context;
var info = new HandInfo();
info.IsAvailableInterface = AnalogInterface.GetInterface(c, pPath+"available");
info.ConfidenceInterface = AnalogInterface.GetInterface(c, pPath+"hand/confidence");
info.GrabStrengthInterface = AnalogInterface.GetInterface(c, pPath+"hand/grabStrength");
info.PinchStrengthInterface = AnalogInterface.GetInterface(c, pPath+"hand/pinchStrength");
info.PalmWidthInterface = AnalogInterface.GetInterface(c, pPath+"hand/palmWidth");
return info;
}
void OnTriggerStay(Collider trigCol)
{
if (trigCol.gameObject.tag.Equals("hand"))
{
HandInfo myTrackingInfo = ManomotionManager.Instance.Hand_infos[0].hand_info;
ManoGestureContinuous myGestureInfo = myTrackingInfo.gesture_info.mano_gesture_continuous;
grabMove(myTrackingInfo, myGestureInfo, trigCol);
}
}
public override bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
//if (!soft && value == 16 && fives > 1 && dealer == Ranks.Ten)
// return false;
return(base.Hit(info));
}
public void updateInfo(Hand hand)
{
_lastTimeUpdated = Time.time;
_leapHand = hand;
foreach (Finger finger in hand.Fingers)
{
Dictionary <Finger.FingerJoint, InteractionPoint> fingerPoints;
if (!_fingerPointMap.TryGetValue(finger.Type, out fingerPoints))
{
fingerPoints = new Dictionary <Finger.FingerJoint, InteractionPoint>();
_fingerPointMap[finger.Type] = fingerPoints;
}
for (int i = 0; i < 4; i++)
{
Finger.FingerJoint jointType = (Finger.FingerJoint)i;
Vector3 jointPosition = HandInfo.unityPos(finger.JointPosition(jointType));
InteractionPoint point;
if (!fingerPoints.TryGetValue(jointType, out point))
{
point = new InteractionPoint();
fingerPoints[jointType] = point;
}
point.update(jointPosition);
}
}
Vector3 palmPoint = HandInfo.unityPos(hand.PalmPosition);
Matrix basis = hand.Basis;
Vector3 xBasis = HandInfo.unityDir(basis.xBasis) * PALM_BASIS_WEIGHT;
Vector3 yBasis = HandInfo.unityDir(basis.yBasis) * PALM_BASIS_WEIGHT;
Vector3 zBasis = HandInfo.unityDir(basis.zBasis) * PALM_BASIS_WEIGHT;
_basisPoints[0].update(palmPoint + xBasis);
_basisPoints[1].update(palmPoint + yBasis);
_basisPoints[2].update(palmPoint + zBasis);
_basisPoints[3].update(palmPoint - xBasis);
_basisPoints[4].update(palmPoint - yBasis);
_basisPoints[5].update(palmPoint - zBasis);
_closeObjects.Clear();
Collider[] colliders = Physics.OverlapSphere(palmPoint, HandInfo.unityLength(0.25f), InteractionController.instance.grabbableLayer);
foreach (Collider c in colliders)
{
_closeObjects.Add(c.gameObject);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private HandInfo BuildHandInfo(string pPath)
{
ClientContext c = ContextProvider.Context;
var info = new HandInfo();
info.IsAvailableInterface = AnalogInterface.GetInterface(c, pPath + "available");
info.ConfidenceInterface = AnalogInterface.GetInterface(c, pPath + "hand/confidence");
info.GrabStrengthInterface = AnalogInterface.GetInterface(c, pPath + "hand/grabStrength");
info.PinchStrengthInterface = AnalogInterface.GetInterface(c, pPath + "hand/pinchStrength");
info.PalmWidthInterface = AnalogInterface.GetInterface(c, pPath + "hand/palmWidth");
return(info);
}
public bool Split(HandInfo info)
{
if (nextAction == "")
{
MultiQuery(info);
}
if (nextAction == "p")
{
nextAction = "";
return(true);
}
return(false);
}
public override bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
//if (count > 3 && dealer == Ranks.Six &&
// (value == 8 || (soft && value == 18)))
// return true;
return(base.DoubleDown(info));
}
public override bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
//if (count > 3 && dealer == Ranks.Six &&
// (value == 8 || (soft && value == 18)))
// return true;
return base.DoubleDown(info);
}
public override void HandOver(HandInfo info)
{
foreach (var c in info.DealerHand.Cards)
if (c.Rank == Ranks.Five)
fives++;
foreach (var h in info.PlayerHands)
foreach (var c in h.Cards)
if (c.Rank == Ranks.Five)
fives++;
base.HandOver(info);
}
void followPalmCenter()
{
Debug.Log("Shivam");
HandInfo curentHand = ManomotionManager.Instance.Hand_infos[0].hand_info;
ManoGestureContinuous gesture = curentHand.gesture_info.mano_gesture_continuous;
Vector3 palmPosition = curentHand.tracking_info.palm_center;
if (gesture == ManoGestureContinuous.CLOSED_HAND_GESTURE)
{
this.transform.position = ManoUtils.Instance.CalculateNewPosition(palmPosition, curentHand.tracking_info.depth_estimation);
}
}
void HandClick()
{
//All the information of the hand
HandInfo detectedHand = ManomotionManager.Instance.Hand_infos[0].hand_info;
//The click happens when I perform the Hand Gesture
if (detectedHand.gesture_info.mano_gesture_trigger == interactionTrigger1)
{
//Logic that should happen when I click
//ScreenSelect();
PlaceObject();
}
}
public override bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (soft)
{
if (value == 18 && dealer == Ranks.Two)
return false;
if (value == 16 && dealer < Ranks.Four)
return false;
if (value > 12 && value < 16 && dealer > Ranks.Four && dealer < Ranks.Seven)
return true;
if (value == 15 && dealer == Ranks.Four)
return true;
if (value == 13 && dealer == Ranks.Five)
return true;
if (value == 13 && dealer == Ranks.Four)
return true;
if (value == 14 && dealer == Ranks.Four)
return true;
if (value == 19 && dealer == Ranks.Six)
return true;
}
else
{
if (value == 8 && dealer > Ranks.Four && dealer < Ranks.Seven)
return true;
if (value == 11)
return true;
}
return base.DoubleDown(info);
}
public virtual bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (soft)
{
if (value == 16 || value == 17 || value == 18)
return dealer < Ranks.Seven;
return false;
}
if ((value == 10 || value == 11) && value > info.DealerHand.Value)
return true;
if (dealer < Ranks.Seven && value == 9)
return true;
return false;
}
public bool Split(HandInfo info)
{
var action = Table.GetAction(info);
return action == ActionTable.ActionTypes.SplitOrHit ||
action == ActionTable.ActionTypes.SplitOrStand;
}
public bool Surrender(HandInfo info)
{
var action = Table.GetAction(info);
return action == ActionTable.ActionTypes.SurrenderOrHit ||
action == ActionTable.ActionTypes.SurrenderOrStand;
}
public virtual bool BuyInsurance(HandInfo info)
{
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Start() {
LeftHand = BuildHandInfo("/arms/left/");
RightHand = BuildHandInfo("/arms/right/");
}
public override bool BuyInsurance(HandInfo info)
{
//if (count > 4)
// return true;
return base.BuyInsurance(info);
}
public virtual void HandOver(HandInfo info)
{
handsPlayed++;
if (handsPlayed == nextPrint)
{
Console.WriteLine(handsPlayed);
nextPrint += 100000L;
}
}
public override bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (!soft && value == 12 && dealer < Ranks.Four)
return true;
if (soft && value == 18 && dealer > Ranks.Six && dealer < Ranks.Nine)
return false;
if (soft && value == 18 && dealer == Ranks.Two)
return false;
if (soft && value == 17 && dealer == Ranks.Two)
return true;
if (!soft && dealer == Ranks.Ten &&
hand.Cards.ElementAt(0).Rank == Ranks.Seven &&
hand.Cards.ElementAt(1).Rank == Ranks.Seven)
return false;
return base.Hit(info);
}
public override bool Surrender(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (!soft && value == 15 && dealer == Ranks.Ten)
return true;
if (!soft && value == 16 && dealer > Ranks.Eight)
return true;
if (!soft && dealer > Ranks.Nine &&
hand.Cards.ElementAt(0).Rank == Ranks.Seven &&
hand.Cards.ElementAt(1).Rank == Ranks.Seven)
return true;
return base.Surrender(info);
}
public override bool Split(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var rank = hand.Cards.ElementAt(0).Rank;
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (rank == Ranks.Seven && dealer == Ranks.Seven)
return true;
if (rank == Ranks.Seven && dealer == Ranks.Eight)
return true;
if (rank == Ranks.Nine && dealer > Ranks.Seven && dealer < Ranks.Ten)
return true;
if (rank < Ranks.Four && dealer < Ranks.Eight)
return true;
if (rank == Ranks.Four && dealer < Ranks.Seven && dealer > Ranks.Three)
return true;
if (rank == Ranks.Three && dealer == Ranks.Eight)
return true;
if (rank == Ranks.Six && dealer == Ranks.Seven)
return true;
if (rank == Ranks.Nine && dealer == Ranks.Ace)
return true;
return base.Split(info);
}
public bool DoubleDown(HandInfo info)
{
var action = Table.GetAction(info);
return action == ActionTable.ActionTypes.DoubleDownOrHit ||
action == ActionTable.ActionTypes.DoubleDownOrStand;
}
public bool Hit(HandInfo info)
{
var action = Table.GetAction(info);
return action == ActionTable.ActionTypes.SplitOrHit ||
action == ActionTable.ActionTypes.DoubleDownOrHit ||
action == ActionTable.ActionTypes.Hit ||
action == ActionTable.ActionTypes.SurrenderOrHit;
}
public override void HandOver(HandInfo info)
{
//Adjust the count based on what was seen this hand.
foreach (var c in info.DealerHand.Cards)
if (c.Rank < Ranks.Seven)
count++;
else if (c.Rank > Ranks.Nine)
count--;
foreach (var h in info.PlayerHands)
foreach (var c in h.Cards)
if (c.Rank < Ranks.Seven)
count++;
else if (c.Rank > Ranks.Nine)
count--;
base.HandOver(info);
}
public void HandOver(HandInfo info)
{
handsPlayed++;
if (Print && handsPlayed % 100000 == 0)
Console.WriteLine(handsPlayed);
}
public void HandOver(HandInfo info)
{
_handsPlayed++;
handsTilPrint--;
if (handsTilPrint == 0)
{
handsTilPrint = 10000;
Console.WriteLine(_handsPlayed);
}
}
public override bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (count > 1 && value == 16 && !soft && dealer == Ranks.Ten)
return false;
if (count > 3 && value == 12 && !soft && dealer < Ranks.Four)
return false;
return base.Hit(info);
}
public bool Split(HandInfo info)
{
var pRank = info.PlayerHands.ElementAt(info.HandToPlay).Cards.ElementAt(0).Rank;
var dRank = info.DealerHand.Cards.ElementAt(0).Rank;
return splits[(int)pRank][(int)dRank];
}
public override bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
//if (!soft && value == 16 && fives > 1 && dealer == Ranks.Ten)
// return false;
return base.Hit(info);
}
/*--------------------------------------------------------------------------------------------*/
public void Update() {
LeftHand = UpdateHandInfo(LeftHand);
RightHand = UpdateHandInfo(RightHand);
}
public virtual bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (soft)
{
if (value < 16)
return true;
if (dealer < Ranks.Seven && value == 18)
return false;
if (value < 19)
return true;
return false;
}
if (value < 12)
return true;
if (value < 17 && dealer > Ranks.Six)
return true;
return false;
}
public bool Surrender(HandInfo info)
{
return false;
}
public virtual bool Split(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var card = hand.Cards.ElementAt(0).Rank;
if (info.DealerHand.Cards.ElementAt(0).Rank < Ranks.Seven)
{
if (card == Ranks.Two ||
card == Ranks.Three ||
card == Ranks.Six ||
card == Ranks.Seven ||
card == Ranks.Eight ||
card == Ranks.Nine ||
card == Ranks.Ace)
return true;
return false;
}
return card == Ranks.Eight || card == Ranks.Ace;
}
public virtual bool Surrender(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var value = hand.Value;
var soft = hand.Soft;
var dealer = info.DealerHand.Cards.ElementAt(0).Rank;
if (!soft && dealer == Ranks.Ten && value == 16)
return true;
return false;
}
public bool DoubleDown(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var c1 = hand.Cards.Max(c => c.Rank);
var c2 = hand.Cards.Min(c=>c.Rank);
var d1 = info.DealerHand.Cards.ElementAt(0).Rank;
if (c1 == Ranks.Ace)
{
switch (c2)
{
case Ranks.Two:
case Ranks.Three:
case Ranks.Four:
case Ranks.Five:
return d1 > Ranks.Three && d1 < Ranks.Seven;
case Ranks.Six:
return d1 < Ranks.Seven;
case Ranks.Seven:
return d1 > Ranks.Two && d1 < Ranks.Seven;
case Ranks.Eight:
case Ranks.Nine:
case Ranks.Ten:
case Ranks.Ace:
return false;
}
}
else if (c1 == c2)
{
switch (c1)
{
case Ranks.Two:
case Ranks.Three:
return false;
case Ranks.Four:
return d1 == Ranks.Six;
case Ranks.Five:
return d1 < Ranks.Ten;
case Ranks.Six:
case Ranks.Seven:
case Ranks.Eight:
case Ranks.Nine:
case Ranks.Ten:
case Ranks.Ace:
return false;
}
}
else if (hand.Value == 8)
{
if (c1 != Ranks.Six)
return d1 == Ranks.Five || d1 == Ranks.Six;
}
else if (hand.Value == 9)
{
return d1 < Ranks.Seven;
}
else if (hand.Value == 10)
{
return d1 < Ranks.Ten;
}
else if (hand.Value == 11)
{
return true;
}
return false;
}
public bool Hit(HandInfo info)
{
var hand = info.PlayerHands.ElementAt(info.HandToPlay);
var c1 = hand.Cards.Max(c => c.Rank);
var c2 = hand.Cards.Min(c => c.Rank);
var d1 = info.DealerHand.Cards.ElementAt(0).Rank;
if (hand.Value <= 10)
return true;
if (hand.Cards.Count() == 2)
{
if (c1 == Ranks.Ace)
{
switch (c2)
{
case Ranks.Two:
case Ranks.Three:
case Ranks.Four:
case Ranks.Five:
case Ranks.Six:
return true;
case Ranks.Seven:
return d1 == Ranks.Nine || d1 == Ranks.Ten;
case Ranks.Eight:
case Ranks.Nine:
case Ranks.Ten:
return false;
case Ranks.Ace:
return true;
}
}
if (c1 == c2)
{
switch (c1)
{
case Ranks.Six:
if (d1 > Ranks.Seven)
return true;
break;
case Ranks.Seven:
if (d1 == Ranks.Nine || d1 == Ranks.Ace)
return true;
else if (d1 == Ranks.Ten)
return false;
break;
case Ranks.Nine:
case Ranks.Ten:
return false;
case Ranks.Ace:
return true;
}
}
}
if (hand.Value >= 17)
return false;
if (hand.Value == 12)
return d1 <= Ranks.Three || d1 >= Ranks.Seven;
if (hand.Value >= 13 && hand.Value <= 15)
return d1 >= Ranks.Seven;
if (hand.Value == 16)
{
if (d1 < Ranks.Seven)
return false;
if (d1 == Ranks.Ten && hand.Cards.Count() > 2)
return false;
return true;
}
return false;
}
