void
Album::
insert_row()
{
for(int x = 0; x < table_width; ++x){
for(int y = table_height-1; y > cursor.y; --y){
get_card(x,y) = get_card(x,y-1);
}}
}
void
Album::
remove_row()
{
for(int x = 0; x < table_width ; ++x){
for(int y = cursor.y; y < table_height-1; ++y){
get_card(x,y) = get_card(x,y+1);
}}
}
void
Album::
insert_column()
{
for(int y = 0; y < table_height; ++y){
for(int x = table_width-1; x > cursor.x; --x){
get_card(x,y) = get_card(x-1,y);
}}
}
void
Album::
remove_column()
{
for(int y = 0; y < table_height ; ++y){
for(int x = cursor.x; x < table_width-1; ++x){
get_card(x,y) = get_card(x+1,y);
}}
}
int null_spielen(Player *p, Game *g) {
//Null (selbst):
//-zwingend: auf jeder farbe die 7 (oder blank, notfalls auch eine blanke 8/9) (wenn nur eine farbe nicht passt -> auf skat reizen?)
//-wenn auf jeder farbe 7,9,B,K (oder besser, oder blank): dann null hand/ouvert
//-7,9,D,K,A auf einer Farbe auch okay (also wenn farbe sehr lang, dann können auch tiefe karten fehlen)
int ret = 47;
int risk = 0;
for(int i = 0; i < 4; i++) {
if(!player_has_card(p, get_card(i, SIEBEN)) && !blank(p, i) && !(length_of_color(p, i) == 1 && (player_has_card(p, get_card(i, NEUN)) || player_has_card(p, get_card(i, ACHT)))))
risk += length_of_color(p, i);
int val = 0;
for(int j = 0; j < p->hcardcount; j++)
if(get_col(p->hand[j]) == i)
val += get_val(p->hand[j]);
int min_val[] = {0, 7, 12, 15, 16, 15, 18, 22, 0};
if(val < min_val[length_of_color(p,i)])
ret = 23;
}
if(risk == 0) { //keine unsicheren Karten -> Hand
ret += 12;
}
if(risk < 3) return ret; //max 2 unsichere Karten
return 0;
}
void MicEnvVar::add_env_var(
int card_number,
char *env_var_name,
int env_var_name_length,
char *env_var_def
)
{
VarValue *var;
CardEnvVars *card;
// The case corresponds to common env var definition of kind
// <mic-prefix>_<var>
if (card_number == any_card) {
card = &common_vars;
}
else {
card = get_card(card_number);
if (!card) {
// definition for new card occurred
card = new CardEnvVars(card_number);
card_spec_list.push_back(card);
}
}
var = card->find_var(env_var_name, env_var_name_length);
if (!var) {
// put new env var definition in "env_var" list
var = new VarValue(env_var_name, env_var_name_length, env_var_def);
card->env_vars.push_back(var);
}
}
int main(int argc, char *argv[])
{
int i = 1;
char *input = (char *) malloc(MAX_INPUT_LENGTH * sizeof(char));
char *a = input, *b = input+MAX_INPUT_INDIV,
*c = input + (2 * MAX_INPUT_INDIV),
*d = input + (3 * MAX_INPUT_INDIV),
*e = input + (4 * MAX_INPUT_INDIV),
*f = input + (5 * MAX_INPUT_INDIV);
casn_t asn = BEGIN_ASSIGNER;
card_t ca, cb, cc, cd, ce, cf;
pthread_t threads[THREAD_NUM];
//do {
printf(PROMPT);
i = scanf("%s %s %s %s %s", a, b, c, d, e, f);
ca = get_card(a), cb = get_card(b), cc = get_card(c),
cd = get_card(d), ce = get_card(e), cf = get_card(f);
card_t cards[] = {ca, cb, cc, cd, ce, cf};
for(int j = 0; j < NUM_MASKS; j++) {
marg_t *m = (marg_t *) malloc(sizeof(marg_t));
if (m) {
m->assigner = &asn;
int takenum = 0;
int cribnum = 0;
for (int k = 0; k < NUM_CARDS; k++) {
if (bit(masks[j], k)) {
m->taken[takenum++] = cards[k];
} else {
m->thrown[cribnum++] = cards[k];
}
}
}
}
//} while (i);
free(input);
return 0;
}
int main(void){
unsigned long long deck = 0xFFFFFFFFFFFFF;
unsigned bankroll;
do{
char buffer[8];
printf("Bankroll: ");
if(!fgets(buffer, sizeof(buffer), stdin)){
fprintf(stderr, "ERROR: Problem reading input.\n");
continue;
}
int retval = sscanf(buffer, "%u", &bankroll);
if(retval < 1){
fprintf(stderr, "ERROR: Unable to parse input.\n");
continue;
}
break;
}while(1);
unsigned pot;
do{
char buffer[8];
printf("Pot: ");
if(!fgets(buffer, sizeof(buffer), stdin)){
fprintf(stderr, "ERROR: Problem reading input.\n");
continue;
}
int retval = sscanf(buffer, "%u", &pot);
if(retval < 1){
fprintf(stderr, "ERROR: Unable to parse input.\n");
continue;
}
break;
}while(1);
printf("==Hole Cards==\n");
unsigned long long hand = get_card(&deck);
hand |= get_card(&deck);
const size_t H = get_lookup_index(hand);
const unsigned long HAND_COMB = 2097572400UL;
betting_round(&bankroll, &pot, begin_prob[H].counter, HAND_COMB);
printf("Pot: %u\n", pot);
printf("==Flop==\n");
unsigned long long flop = get_card(&deck);
flop |= get_card(&deck);
flop |= get_card(&deck);
struct win_counter counter = {0};
determine_win_counter(&counter, deck, flop, hand, 2);
const unsigned long FLOP_COMB = 1070190UL;
betting_round(&bankroll, &pot, counter, FLOP_COMB);
printf("Pot: %u\n", pot);
printf("==Turn==\n");
unsigned long long turn = get_card(&deck);
counter.split = 0;
counter.win = 0;
determine_win_counter(&counter, deck, flop|turn, hand, 1);
const unsigned TURN_COMB = 45540U;
betting_round(&bankroll, &pot, counter, TURN_COMB);
printf("Pot: %u\n", pot);
printf("==River==\n");
unsigned long long river = get_card(&deck);
struct hand best_hand;
determine_hand(&best_hand, hand|flop|turn|river);
counter.split = 0;
counter.win = 0;
showdown(&counter, &best_hand, flop|turn|river, deck);
const unsigned RIVER_COMB = 990;
betting_round(&bankroll, &pot, counter, RIVER_COMB);
printf("Pot: %u\n", pot);
return 0;
}
S_C Human::play(Deck & deck, bool is_lead)
{
char tmp_s;
char tmp_v;
printf("%s:\n", name_);
S_C card;
auto cards = legal_plays(deck, is_lead);
if(0) {
for(auto c : cards) {
printf(" %s\n", c->string());
}
}
assert(!cards.empty());
while(1) {
scanf("%s %s", &tmp_s, &tmp_v);
Suit s;
unsigned char c;
try {
s = char_to_suit(tmp_s);
} catch(...) {
continue;
}
try {
c = char_to_card(tmp_v);
} catch(...) {
continue;
}
/*
if(!tmp->is_valid()) {
printf("invalid card\n");
fflush(stdout);
continue;
}
*/
try {
card = get_card(s, c);
} catch(Player::card_not_in_hand & e) {
printf("you dont have that card\n");
continue;
}
auto it = std::find(cards.begin(), cards.end(), card);
if(it == cards.end()) {
printf("not a legal move\n");
fflush(stdout);
continue;
}
break;
}
remove_from_hand(card);
return card;
}
/*
* draw chance card
*/
void
chance(void)
{
get_card(&CH_D);
}
/*
* draw community chest card
*/
void
cc(void)
{
get_card(&CC_D);
}
