auf der Suche nach Hilfe habe ich diese Forum entdeckt! Hoffe hier kann mir jemand helfen. (Bestimmt schon xD)

ich programmiere zurzeit ein kleines Black Jack Programm in Cpp. Dort benutze ich folgende Schleife:

do
{
   cout << "Wie viele Chips moechten sie setzen? ";
   cin >> setcoins;
} while ((coins < setcoins) /* && (setcoins <= 0)*/);

Wenn ich den auskommentierten Teil nicht benutze tut es das was es soll. Nämlich verhindern, dass der Spieler mehr Chips setzt als er hat. Benutze ich den auskommentierten Teil jedoch mit, macht er nichts mehr. Eigentlich soll er dann nämlich noch zusätzlich dafür sorgen, dass kein Wert <= 0 eingegeben werden kann. Wie gesagt funktioniert das nicht. Man kann dann nämlich alles eingeben wie man lustig ist.

Hier der ganze Source:

/*
#########################
#		BLACKJACK		#
#		BY PALONE		#
#########################		
#		HAVE FUN		#
#		AND LEARN		#
#########################
*/

#include <stdlib.h>
#include <iostream>
#include <time.h>
#include <windows.h>

using namespace std;

int main() 
{
	//VAR_DEKLARATION
	int score,dscore,choice,again,coins,opencard,setcoins,bet;
	srand((unsigned)time( NULL ));//Bindet RAND() an Sekunden. Wichtig weil RAND() sonst immer den gleiche Wert ausgeben würde.

	score = 0;//Spieler Punkte
	dscore = 0;//Dealer Punkte
	choice = 0;//Entscheidung ob Karte gezogen wird
	coins = 100;//Spieler Geld
	setcoins = 0;//Gesetzte Coins
	opencard = 0;//Die offene karte des Dealers
	bet = 0;//Verhindert ein mehrmaliges Setzen innerhalb einer Runde

	do
	{
	//START

		//Entscheidung ob Spiel wiederholt wird
		again = 0;//Muss hierhin sonst Bug beim restarten!

		system("cls");
		cout << "Willkommen bei: 'BlackJack'" << endl;
		system("pause");
		cout << endl << "Die karten werden neu gemischt..."  << endl;
		cout  << "Sie erhalten 2 karten!" << endl;

		//VERGABE DER ERSTEN BEIDEN KARTEN
		score = (rand() % 9 + 2) + (rand() % 9 + 2);
		_sleep(123);//Ohne sleep gibt es manchmal die gleichen Punktzahlen!!!
		opencard = (rand() % 9 + 2);
		dscore = (rand() % 9 + 2) + opencard;

		//HAUPTSCHLEIFE
		do
		{
			//START

			//COINS SETZEN
			cout << "Chips: " << coins << endl << endl;

			if (bet == 0)//Man kann nur setzen wenn noch nicht gesetzt wurde nämlich (BET = 0)
			{	
				do
				{
					cout << "Wie viele Chips moechten sie setzen? ";
					cin >> setcoins;
				} while ((coins < setcoins) /* && (setcoins <= 0)*/);//Verhindert das mehr Chips gesetzt werden als vorhanden und das mindestens "1" gesetzt wird!

				coins = coins - setcoins;
				bet = 1;//(BET = 1) bedeutet es wurde schon gesetzt
			}
			system("cls");

			//KARTE ZIEHEN?
			cout << endl << "Eigene Punktzahl: " << score << endl << endl;
			cout << "Dealer: " << dscore << endl;
			cout << "Offene Karte des Dealers: " << opencard << endl;//Zeigt die offene Karte ded Dealers an.
			cout << endl << "Moechten sie eine weitere Karte? <0=NEIN|1=JA>" << endl;
			cin >> choice;//Entscheidung ob Karte gezogen wird

			if (choice >= 1)
			{
				score = score + (rand() % 9 + 2);
				_sleep(123);//Ohne Sleep gibt es manchmal die gleichen Punktzahlen!!!
			}

			if (dscore <= 16)//Der Dealer zieht seine Karten immer nach der “Dealer must stand on 17 and must draw to 16“ Regel. Siehe Wikipedia!
			{
				dscore = dscore + (rand() % 9 + 2);
			}

			system("cls");
			//ENDE
		} while ((score <= 21) && (choice == 1) && (coins >= 0) && (dscore <= 21));//Alle Abbruchkriterien

		//LETZTE ANZEIGE DER PUNKTE
		cout << endl << "Punktzahl: " << score << endl;
		cout << "Dealer: " << dscore << endl << endl;

		//SPIEL_ÜBERPRÜFUNG

		if ((score > 21) && (dscore <= 21))
		{
			cout << "Sie haben mehr als 21! Verloren!" << endl;
			setcoins = 0;
		}

		else if ((score > 21) && (dscore > 21))
		{
			cout << "Sie beide haben mehr als 21! Untentschieden!" << endl;
			setcoins = 0;
		}

		else if ((dscore > 21) && (score <= 21))
		{
			cout << "Der Dealer hat mehr als 21! Gewonnen!" << endl;
			setcoins = setcoins * 2; 
		}

		else  if (score > dscore)
		{
			cout << "Sie haben mehr als der Dealer! Gewonnen!" << endl;
			setcoins = setcoins * 2;
		}

		else if (score == dscore)
		{
			cout << "Sie beide haben gleich viel! Unentschieden!" << endl;
			setcoins = 0;
		}

		else if (dscore > score)
		{
			cout << "Der Dealer hat mehr! Verloren!" << endl;
			setcoins = 0;
		}

		//Herausgabe des Gewinns
		coins = coins + setcoins;
		cout << "Chips: " << coins << endl << endl;

		//Überprüfung des Geldes
		if (coins <= 0)
		{
			cout << "Sie sind Pleite!!! GAME OVER!!!" << endl;
			break;//Spiel wird beendet. GAME OVER!
		}

		//AGAIN ABFRAGE
		cout << endl << "Nochmal? (1=Ja) ";
		cin >> again;

		bet = 0;//Das Setzen für nächste Runde wieder aktivieren!!!

	} while (again == 1);	

//ENDE
system("pause");
return 0;	
}

Was mich dabei am meisten verwirrt ist, dass ich in der Hauptschleife eine do-while Schleife ,mit 4 Abbruchkriterien benutzen kann, und alle funktionieren ohne je probleme gemacht zu haben...

Vielen Dank schonmal für die Hilfe

GREETS PALone

EDIT: Ich benutze Visual Studio 2012 Professional, falls das wichtig ist

//VERGABE DER ERSTEN BEIDEN KARTEN
		score = (rand() % 9 + 2) + (rand() % 9 + 2);
		_sleep(123);//Ohne sleep gibt es manchmal die gleichen Punktzahlen!!!
		opencard = (rand() % 9 + 2);
		dscore = (rand() % 9 + 2) + opencard;

So ein Bullshit. Auf das hat das _sleep() an der stelle genau garkeinen Einfluß.

Zu _sleep:

Ich habe die Idee, RAND() an die Millisekunden zu "hängen" aus irgendeinem anderen Forum. Da stand bei das man eben SLEEP benutzen muss. Habs grad ohne gestest geht auch. Danke ihr beiden

srand((unsigned)time( NULL ));//Bindet RAND() an Sekunden. Wichtig weil RAND() sonst immer den gleiche Wert ausgeben würde.

Da wird nichts gebunden. Der seed für rand wird auf einen Wert gesetzt.

Man nimmt da gerne die Epoche (Sekunden seit irgendwann (i.A. 1.1.1970)).
So bekommt nur dieselbe (Zufalls-)Zahlenfolge, wenn das Programm nochmal in derselben Sekunde gestartet wird.