You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1066 lines
44 KiB

/******************************************************************************
* Copyright © 2014-2016 The SuperNET Developers. *
* *
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
* the top-level directory of this distribution for the individual copyright *
* holder information and the developer policies on copyright and licensing. *
* *
* Unless otherwise agreed in a custom licensing agreement, no part of the *
* SuperNET software, including this file may be copied, modified, propagated *
* or distributed except according to the terms contained in the LICENSE file *
* *
* Removal or modification of this copyright notice is prohibited. *
* *
******************************************************************************/
#include "pangea777.h"
#define PANGEA_GOTDECKS 1
#define PANGEA_GOTFINAL 2
struct pangea_queueitem { struct queueitem DL; struct tai start,last; int32_t waitevent; };
struct pangea_queueitem *pangea_queuefind(struct table_info *tp,int32_t waitevent)
{
int32_t iter; struct pangea_queueitem *ptr;
for (iter=0; iter<2; iter++)
{
while ( (ptr= queue_dequeue(&tp->stateQ[iter])) != 0 )
{
if ( ptr->waitevent == waitevent )
return(ptr);
queue_enqueue("stateQ",&tp->stateQ[iter ^ 1],&ptr->DL);
}
}
return(0);
}
void pangea_queuestate(struct table_info *tp,int32_t currentstate,int32_t waitevent)
{
struct pangea_queueitem *ptr;
if ( (ptr= pangea_queuefind(tp,currentstate)) == 0 )
ptr = calloc(1,sizeof(*ptr));
ptr->last = ptr->start = tai_now();
ptr->waitevent = waitevent;
char str[65]; printf("table.%s current.%d -> wait.%d\n",bits256_str(str,tp->G.tablehash),currentstate,waitevent);
queue_enqueue("stateQ",&tp->stateQ[0],&ptr->DL);
}
int32_t pangea_slotA(struct table_info *tp) { return(0); }
int32_t pangea_slotB(struct table_info *tp) { return(1); }
int32_t pangea_lastnode(struct table_info *tp) { return(tp->G.numactive-1); }
int32_t pangea_nextnode(struct table_info *tp) { return(tp->priv.myind+1); }
int32_t pangea_prevnode(struct table_info *tp) { return(tp->priv.myind-1); }
void pangea_rwaudit(int32_t saveflag,bits256 *audit,bits256 *audits,int32_t cardi,int32_t destplayer,int32_t N)
{
int32_t i;
audits = &audits[(cardi * N + destplayer) * N];
if ( saveflag != 0 )
{
for (i=0; i<N; i++)
audits[i] = audit[i];
}
else
{
for (i=0; i<N; i++)
audit[i] = audits[i];
}
}
int32_t pangea_tableismine(struct supernet_info *myinfo,struct table_info *tp)
{
int32_t i;
if ( tp->G.creatorbits == myinfo->myaddr.nxt64bits )
{
tp->G.ismine = tp->G.numactive;
return(tp->G.numactive);
}
else
{
for (i=0; i<tp->G.numactive; i++)
if ( tp->G.P[i].nxt64bits == myinfo->myaddr.nxt64bits )
{
tp->G.ismine = 1;
return(i);
}
}
return(-1);
}
int32_t pangea_Pind(struct table_info *tp,bits256 playerpub)
{
int32_t i;
for (i=0; i<tp->G.N; i++)
{
if ( memcmp(tp->G.P[i].playerpub.bytes,playerpub.bytes,sizeof(playerpub)) == 0 )
return(i);
}
return(-1);
}
int32_t pangea_actives(int32_t *activej,struct table_info *tp)
{
int32_t i,n; struct player_info *p;
*activej = -1;
for (i=n=0; i<tp->G.numactive; i++)
{
if ( (p= tp->active[i]) != 0 && p->betstatus != CARDS777_FOLD )
{
if ( *activej < 0 )
*activej = i;
n++;
}
}
return(n);
}
int32_t pangea_myrank(struct supernet_info *myinfo,struct table_info *tp,struct player_info *p)
{
int32_t i; uint32_t myrank = p->handrank;
for (i=0; i<tp->G.numactive; i++)
if ( tp->active[i] != 0 && tp->active[i] != p && tp->active[i]->handrank > myrank )
return(-1);
return(myrank != 0);
}
void pangea_clearhand(struct table_info *tp)
{
int32_t i; struct hand_info *hand = &tp->hand;
memset(hand,0,sizeof(*hand));
for (i=0; i<5; i++)
hand->community[i] = 0xff;
for (i=0; i<tp->G.N; i++)
memset(tp->G.P[i].hand,0xff,sizeof(tp->G.P[i].hand));
tp->priv.hole[0] = tp->priv.hole[1] = tp->priv.cardis[0] = tp->priv.cardis[1] = 0xff;
memset(tp->priv.holecards,0,sizeof(tp->priv.holecards));
}
uint32_t pangea_rank(struct supernet_info *myinfo,struct table_info *tp,int32_t senderind)
{
int32_t i; char handstr[128]; struct player_info *p; struct hand_info *hand = &tp->hand;
if ( senderind < tp->G.N && (p= tp->active[senderind]) != 0 )
{
if ( p->handrank != 0 )
return(p->handrank);
for (i=0; i<7; i++)
{
if ( i < 5 )
p->hand[i] = hand->community[i];
if ( p->hand[i] == 0xff )
break;
}
if ( i == 7 )
{
p->handrank = set_handstr(handstr,p->hand,0);
hand->handmask |= (1 << senderind);
PNACL_message("sender.%d (%s) rank.%x handmask.%x\n",senderind,handstr,p->handrank,hand->handmask);
}
return(p->handrank);
}
printf("pangea_rank.%d illegal senderind\n",senderind);
return(0);
}
// "state machine" funcs
int32_t pangea_newdeck(struct supernet_info *myinfo,struct table_info *tp)
{
bits256 *playerpubs; int32_t i,j,n,datalen,button; struct hand_info *hand = &tp->hand;
if ( tp->G.N < tp->G.numactive )
tp->G.N = tp->G.numactive;
button = (tp->numhands % tp->G.N);
pangea_clearhand(tp);
playerpubs = &hand->cardpubs[tp->G.numcards + 1];
for (j=n=0; j<tp->G.N; j++)
{
i = (j + button) % tp->G.N;
//if ( tp->G.P[i].balance > 0 )
playerpubs[n++] = tp->G.P[i].playerpub;
if ( bits256_cmp(tp->G.P[i].playerpub,myinfo->myaddr.persistent))
{
tp->priv.myind = i;
char str[65],str2[65]; printf("player.%d (%s) vs persistent.(%s) myind.%d\n",i,bits256_str(str,tp->G.P[i].playerpub),bits256_str(str2,myinfo->myaddr.persistent),tp->priv.myind );
}
}
if ( n < tp->G.minplayers )
{
printf("pangea_newdeck %d < %d minplayers\n",n,tp->G.minplayers);
return(-1);
}
hand->checkprod = hand->cardpubs[tp->G.numcards] = cards777_initdeck(tp->priv.outcards,hand->cardpubs,tp->G.numcards,n,playerpubs,0);
hand->othercardpubs[tp->priv.myind] = hand->checkprod;
datalen = (tp->G.numcards + 1 + n) * sizeof(bits256);
pangea_sendcmd(myinfo,tp,"newhand",-1,hand->cardpubs[0].bytes,datalen,n,n);
printf("host sends NEWDECK checkprod.%llx numhands.%d\n",(long long)hand->checkprod.txid,tp->numhands);
{
bits256 checkprod; char str[65],str2[65];
checkprod = cards777_pubkeys(hand->cardpubs,tp->G.numcards,hand->cardpubs[tp->G.numcards]);
if ( bits256_cmp(checkprod,hand->checkprod) != 0 )
printf("checkprod err.(%s) != (%s)\n",bits256_str(str,checkprod),bits256_str(str2,hand->checkprod));
for (i=0; i<tp->G.numcards; i++)
printf("%d: %s\n",i,bits256_str(str,hand->cardpubs[i]));
printf("cardpubs.(%s)\n",bits256_str(str,hand->cardpubs[tp->G.numcards]));
}
pangea_queuestate(tp,PANGEA_GOTDECKS,PANGEA_GOTDECKS);
return(0);
}
void pangea_newhand(PANGEA_HANDARGS)
{
int32_t i,handid,numcards,n,ind; struct hand_info *hand; bits256 *pubkeys; char str[65],str2[65];
hand = &tp->hand;
numcards = tp->G.numcards;
if ( data == 0 || datalen != (numcards + 1 + tp->G.numactive) * sizeof(bits256) )
{
PNACL_message("pangea_newhand invalid datalen.%d vs %ld\n",datalen,(long)((numcards + 1) * sizeof(bits256)));
return;
}
pubkeys = (bits256 *)data;
n = turni;
tp->priv.myind = -1;
tp->priv.mypriv = myinfo->persistent_priv, tp->priv.mypub = myinfo->myaddr.persistent;
tp->G.M = (tp->G.numactive >> 1) + 1;
for (i=0; i<n; i++)
{
if ( (ind= pangea_Pind(tp,pubkeys[numcards + 1 + i])) >= 0 && ind > i )
{
tp->G.P[i] = tp->G.P[ind];
printf("init player[%d] with.%d\n",i,ind);
}
ind = i;
tp->G.P[ind].playerpub = pubkeys[numcards + 1 + i];
tp->G.P[ind].nxt64bits = acct777_nxt64bits(pubkeys[numcards + 1 + i]);
tp->active[i] = &tp->G.P[ind];
if ( i == 0 )
hand->button = ind;
if ( bits256_cmp(tp->G.P[ind].playerpub,myinfo->myaddr.persistent))
{
tp->priv.myind = i;
printf("player.%d (%s) vs persistent.(%s) myind.%d\n",i,bits256_str(str,tp->G.P[ind].playerpub),bits256_str(str2,myinfo->myaddr.persistent),tp->priv.myind );
}
}
hand->startdecktime = (uint32_t)time(NULL);//pm->sig.timestamp;
memcpy(hand->cardpubs,pubkeys,(numcards +1 + tp->G.numactive) * sizeof(bits256));
PNACL_message("player.%d NEWHAND.%llx received numhands.%d button.%d cardi.%d | N %d numactive.%d\n",tp->priv.myind,(long long)hand->cardpubs[numcards].txid,tp->numhands,hand->button,hand->cardi,tp->G.N,n);
//printf("check.%s\n",bits256_str(str,hand->cardpubs[numcards]));
hand->checkprod = cards777_pubkeys(hand->cardpubs,numcards,hand->cardpubs[numcards]);
//printf("B check.%s\n",bits256_str(str,hand->checkprod));
//printf("P0.%s\n",bits256_str(str,hand->cardpubs[numcards+1]));
//printf("P1.%s\n",bits256_str(str,hand->cardpubs[numcards+2]));
if ( bits256_cmp(hand->checkprod,hand->cardpubs[numcards]) != 0 )
{
for (i=0; i<tp->G.numcards; i++)
printf("%d: %s\n",i,bits256_str(str,hand->cardpubs[i]));
printf("checkprod mismatch myind.%d %s\n",tp->priv.myind,bits256_str(str,hand->cardpubs[i]));
return;
}
if ( tp->priv.myind >= 0 )
{
hand->othercardpubs[tp->priv.myind] = hand->checkprod;
tp->G.numactive = n;
memset(tp->summary,0,sizeof(tp->summary));
hand->summaries = hand->mismatches = tp->summarysize = 0;
handid = tp->numhands++;
pangea_summaryadd(myinfo,tp,CARDS777_START,&handid,sizeof(handid),hand->cardpubs[0].bytes,sizeof(bits256) * (numcards + 1));
pangea_sendcmd(myinfo,tp,"gothand",-1,hand->checkprod.bytes,sizeof(bits256),hand->cardi,hand->button);
printf("sent gotdeck\n");
}
}
int32_t pangea_checkstart(struct supernet_info *myinfo,struct table_info *tp)
{
int32_t i,matches = 0; struct hand_info *hand = &tp->hand;
if ( bits256_nonz(hand->checkprod) > 0 && hand->encodestarted == 0 )
{
for (i=0; i<tp->G.numactive; i++)
{
if ( bits256_cmp(hand->othercardpubs[i],hand->checkprod) == 0 )
matches++;
char str[65],str2[65]; printf("matches.%d (%s vs %s)\n",matches,bits256_str(str,hand->othercardpubs[i]),bits256_str(str2,hand->checkprod));
}
if ( matches == tp->G.numactive )
{
if ( tp->priv.myind == pangea_slotA(tp) )
{
//if ( PANGEA_PAUSE > 0 )
// sleep(PANGEA_PAUSE);
hand->encodestarted = (uint32_t)time(NULL);
tp->hand.sentencoded |= (1 << tp->priv.myind);
pangea_queuestate(tp,PANGEA_GOTDECKS,PANGEA_GOTFINAL);
PNACL_message("start encoded %llx destplayer.%d vs myind.%d\n",(long long)hand->checkprod.txid,pangea_slotB(tp),tp->priv.myind);
pangea_sendcmd(myinfo,tp,"encoded",pangea_slotB(tp),tp->priv.outcards[0].bytes,sizeof(bits256) * tp->G.numactive * tp->G.numcards,tp->G.numactive*tp->G.numcards,-1);
return(matches);
}
} else printf("i.%d != numactive.%d\n",matches,tp->G.numactive);
} else printf("zero checkprod or encodestarted.%u\n",hand->encodestarted);
return(-1);
}
void pangea_gothand(PANGEA_HANDARGS)
{
int32_t i; uint64_t total = 0;
printf("P%d: gothand from p%d\n",tp->priv.myind,senderind);
tp->hand.othercardpubs[senderind] = *(bits256 *)data;
if ( Debuglevel > 2 )
{
for (i=0; i<tp->G.N; i++)
{
total += tp->G.P[i].balance;
PNACL_message("(p%d %.8f) ",i,dstr(tp->G.P[i].balance));
}
PNACL_message("balances %.8f [%.8f] | ",dstr(total),dstr(total + tp->G.hostrake + tp->G.pangearake));
PNACL_message("player.%d pangea_gotdeck from P.%d otherpubs.%llx\n",tp->priv.myind,senderind,(long long)tp->hand.othercardpubs[senderind].txid);
}
pangea_checkstart(myinfo,tp);
}
void pangea_sentencoded(PANGEA_HANDARGS)
{
tp->hand.sentencoded |= (1 << senderind);
printf("P%d: got sentencoded from %d\n",tp->priv.myind,senderind);
}
void pangea_gotfinal(PANGEA_HANDARGS)
{
tp->hand.gotfinal |= (1 << senderind);
printf("P%d: gotfinal from %d\n",tp->priv.myind,senderind);
}
void pangea_encoded(PANGEA_HANDARGS)
{
bits256 audit[CARDS777_MAXPLAYERS]; int32_t i,iter;
struct hand_info *hand = &tp->hand;
printf("pangea_encoded\n");
if ( N <= 1 || data == 0 || datalen != (tp->G.numcards * N) * sizeof(bits256) )
{
PNACL_message("pangea_encode invalid datalen.%d vs %ld\n",datalen,(long)((tp->G.numcards * N) * sizeof(bits256)));
return;
}
hand->encodestarted = (uint32_t)time(NULL);//pm->sig.timestamp;
cards777_encode(myinfo,tp->priv.outcards,tp->priv.xoverz,tp->priv.allshares,tp->priv.myshares,hand->sharenrs[tp->priv.myind],tp->G.M,(void *)data,tp->G.numcards,N);
PNACL_message("player.%d ind.%d encodes into %p %llx -> %llx next.%d N %d\n",tp->priv.myind,tp->priv.myind,tp->priv.outcards,(long long)*(uint64_t *)data,(long long)tp->priv.outcards[0].txid,pangea_nextnode(tp),N);
if ( tp->priv.myind > 0 )
{
if ( tp->priv.myind < tp->G.numactive-1 )
{
//PNACL_message("send encoded\n");
pangea_sendcmd(myinfo,tp,"encoded",pangea_nextnode(tp),tp->priv.outcards[0].bytes,datalen,N*tp->G.numcards,-1);
pangea_sendcmd(myinfo,tp,"sentencoded",-1,0,0,tp->priv.myind,pangea_nextnode(tp));
}
else
{
memcpy(hand->final,tp->priv.outcards,sizeof(bits256)*N*tp->G.numcards);
pangea_sendcmd(myinfo,tp,"final",-1,tp->priv.outcards[0].bytes,datalen,N*tp->G.numcards,-1);
for (iter=cardi=0; iter<2; iter++)
for (i=0; i<N; i++,cardi++)
for (destplayer=0; destplayer<N; destplayer++)
{
pangea_rwaudit(0,audit,tp->priv.audits,cardi,destplayer,N);
audit[0] = hand->final[cardi*N + destplayer];
pangea_rwaudit(1,audit,tp->priv.audits,cardi,destplayer,N);
}
PNACL_message("send preflop %ld\n",(long)((2 * N) * (N * N * sizeof(bits256))));
pangea_preflop(myinfo,N,turni,cardi,destplayer,senderind,tp,tp->priv.audits[0].bytes,(2 * N) * (N * N * sizeof(bits256)));
}
}
}
void pangea_final(PANGEA_HANDARGS)
{
if ( data == 0 || datalen != (tp->G.numcards * tp->G.numactive) * sizeof(bits256) )
{
PNACL_message("pangea_final invalid datalen.%d vs %ld\n",datalen,(long)((tp->G.numcards * tp->G.numactive) * sizeof(bits256)));
return;
}
if ( Debuglevel > 2 )
PNACL_message("player.%d final into %p\n",tp->priv.myind,tp->priv.outcards);
memcpy(tp->hand.final,data,sizeof(bits256) * tp->G.numactive * tp->G.numcards);
pangea_sendcmd(myinfo,tp,"gotfinal",-1,0,0,tp->priv.myind,tp->priv.myind);
}
int32_t pangea_queueprocess(struct supernet_info *myinfo,struct table_info *tp)
{
int32_t iter,retval,flag = 0; double diff; struct pangea_queueitem *ptr;
//char str[65]; printf("queueprocess.(%s)\n",bits256_str(str,tp->G.tablehash));
for (iter=0; iter<2; iter++)
{
while ( (ptr= queue_dequeue(&tp->stateQ[iter])) != 0 )
{
retval = 0;
diff = tai_diff(ptr->last,tai_now());
if ( diff > 10000 )
{
printf("its been over 10 seconds %.3f no state.%d yet\n",diff,ptr->waitevent);
}
switch ( ptr->waitevent )
{
case PANGEA_GOTDECKS:
if ( pangea_checkstart(myinfo,tp) > 0 )
return(1);
break;
case PANGEA_GOTFINAL:
//printf("sentencoded.%x, waiting for gotfinal\n",tp->hand.sentencoded);
break;
}
if ( retval != 0 )
{
flag++;
free(ptr);
}
else
{
ptr->last = tai_now();
queue_enqueue("stateQ",&tp->stateQ[iter ^ 1],&ptr->DL);
}
}
}
return(flag);
}
void pangea_queues(struct supernet_info *myinfo)
{
struct gecko_chain *cat,*subchain,*tmp; //struct table_info *tp;
pangea_update(myinfo);
if ( (cat= category_find(calc_categoryhashes(0,"pangea",0),GENESIS_PUBKEY)) != 0 )
{
HASH_ITER(hh,cat->subchains,subchain,tmp)
{
printf("undeprecate\n");
//if ( (tp= sub->info) != 0 )
// pangea_queueprocess(myinfo,tp);
}
}
}
void pangea_preflop(PANGEA_HANDARGS)
{
int32_t i,iter,maxlen; bits256 audit[CARDS777_MAXPLAYERS];
maxlen = (int32_t)(2 * N * N * CARDS777_MAXCARDS * sizeof(bits256));
if ( N <= 1 || data == 0 || datalen != (2 * N) * (N * N * sizeof(bits256)) )
{
PNACL_message("pangea_preflop invalid datalen.%d vs %ld\n",datalen,(long)(2 * N) * (N * N * sizeof(bits256)));
return;
}
PNACL_message("preflop player.%d\n",tp->priv.myind);
memcpy(tp->priv.audits,data,datalen);
if ( tp->priv.myind != pangea_slotA(tp) && tp->priv.myind != pangea_slotB(tp) )
{
//for (i=0; i<tp->G.numcards*N; i++)
// PNACL_message("%llx ",(long long)tp->priv.outcards[i].txid);
PNACL_message("player.%d outcards\n",tp->priv.myind);
for (cardi=0; cardi<N*2; cardi++)
for (destplayer=0; destplayer<N; destplayer++)
{
pangea_rwaudit(0,audit,tp->priv.audits,cardi,destplayer,N);
//if ( 1 && (card= cards777_checkcard(&cardpriv,cardi,tp->priv.myind,destplayer,hn->client->H.privkey,hand->cardpubs,tp->G.numcards,audit[0])) >= 0 )
//PNACL_message("ERROR: unexpected decode player.%d got card.[%d]\n",tp->priv.myind,card);
audit[0] = cards777_decode(&audit[tp->priv.myind],tp->priv.xoverz,destplayer,audit[0],tp->priv.outcards,tp->G.numcards,N);
pangea_rwaudit(1,audit,tp->priv.audits,cardi,destplayer,N);
}
//PNACL_message("issue preflop\n");
pangea_sendcmd(myinfo,tp,"preflop",pangea_prevnode(tp),tp->priv.audits[0].bytes,datalen,N * 2 * N,-1);
}
else
{
PNACL_message("P%d sendout cards\n",tp->priv.myind);
for (iter=cardi=0; iter<2; iter++)
for (i=0; i<N; i++,cardi++)
{
destplayer = (tp->hand.button + i) % N;
pangea_rwaudit(0,audit,tp->priv.audits,cardi,destplayer,N);
//PNACL_message("audit[0] %llx -> ",(long long)audit[0].txid);
audit[0] = cards777_decode(&audit[tp->priv.myind],tp->priv.xoverz,destplayer,audit[0],tp->priv.outcards,tp->G.numcards,N);
pangea_rwaudit(1,audit,tp->priv.audits,cardi,destplayer,N);
//PNACL_message("[%llx + %llx] ",*(long long *)&audit[0],(long long)&audit[tp->priv.myind]);
if ( destplayer == tp->priv.myind )
{
printf("send card to myself\n");
// pangea_card(myinfo,N,turni,cardi,destplayer,tp->priv.myind,tp,audit[0].bytes,sizeof(bits256)*N);
}
// else
pangea_sendcmd(myinfo,tp,"card",destplayer,audit[0].bytes,sizeof(bits256)*N,cardi,-1);
}
}
}
void pangea_card(PANGEA_HANDARGS)
{
struct hand_info *hand; int32_t card,selector,validcard = -1;
bits256 cardpriv,audit[CARDS777_MAXPLAYERS]; char cardAstr[8],cardBstr[8]; struct player_info *destp;
hand = &tp->hand;
destp = tp->active[destplayer];
if ( N <= 1 || data == 0 || datalen != sizeof(bits256)*N || destp == 0 || destplayer < 0 )
{
PNACL_message("pangea_card invalid datalen.%d vs %ld destplayer.%d destp.%p\n",datalen,(long)sizeof(bits256)*N,destplayer,destp);
return;
}
pangea_rwaudit(1,(void *)data,tp->priv.audits,cardi,destplayer,N);
pangea_rwaudit(0,audit,tp->priv.audits,cardi,destplayer,N);
PNACL_message("pangea_card.%d destplayer.%d [%llx]\n",cardi,destplayer,(long long)audit[0].txid);
if ( (card= cards777_checkcard(&cardpriv,cardi,tp->priv.myind,destplayer,myinfo->persistent_priv,hand->cardpubs,tp->G.numcards,audit[0])) >= 0 )
{
destplayer = tp->priv.myind;
//if ( Debuglevel > 2 )
PNACL_message("player.%d got card.[%d]\n",tp->priv.myind,card);
selector = (cardi / N);
tp->priv.holecards[selector] = cardpriv;
tp->priv.cardis[selector] = cardi;
destp->hand[5 + selector] = tp->priv.hole[selector] = cardpriv.bytes[1];
validcard = 1;
cardAstr[0] = cardBstr[0] = 0;
if ( tp->priv.hole[0] != 0xff )
cardstr(cardAstr,tp->priv.hole[0]);
if ( tp->priv.hole[1] != 0xff )
cardstr(cardBstr,tp->priv.hole[1]);
PNACL_message(">>>>>>>>>> dest.%d holecards[%02d] cardi.%d / N %d (%02d %02d) -> (%s %s)\n",destplayer,tp->priv.hole[cardi / N],cardi,N,tp->priv.hole[0],tp->priv.hole[1],cardAstr,cardBstr);
if ( cards777_validate(cardpriv,hand->final[cardi*N + destplayer],hand->cardpubs,tp->G.numcards,audit,N,tp->priv.mypub) < 0 )
PNACL_message("player.%d decoded cardi.%d card.[%02d] but it doesnt validate\n",tp->priv.myind,cardi,card);
} else PNACL_message("ERROR player.%d got no card %llx\n",tp->priv.myind,*(long long *)data);
if ( cardi < N*2 )
pangea_sendcmd(myinfo,tp,"facedown",-1,(void *)&cardi,sizeof(cardi),cardi,validcard);
else pangea_sendcmd(myinfo,tp,"faceup",-1,cardpriv.bytes,sizeof(cardpriv),cardi,0xff);
}
int64_t pangea_snapshot(struct table_info *tp,int64_t *snapshot)
{
struct player_info *p; int64_t betsize; int32_t i,N = tp->G.numactive;
memset(snapshot,0,N * sizeof(int64_t));
for (betsize=i=0; i<N; i++)
{
if ( (p= tp->active[i]) != 0 )
{
if ( p->bets > betsize )
betsize = p->bets;
snapshot[i] = p->bets;
} else snapshot[i] = 0;
}
snapshot[N] = betsize;
return(betsize);
}
void pangea_startbets(struct supernet_info *myinfo,struct table_info *tp,int32_t cardi)
{
uint32_t now,i,N = tp->G.numactive; struct player_info *p; int64_t snapshot[CARDS777_MAXPLAYERS+1];
struct hand_info *hand = &tp->hand;
if ( PANGEA_PAUSE > 0 )
sleep(PANGEA_PAUSE);
if ( hand->betstarted == 0 )
hand->betstarted = 1;
else hand->betstarted++;
hand->numactions = 0;
hand->cardi = cardi;
now = (uint32_t)time(NULL);
for (i=0; i<CARDS777_MAXPLAYERS; i++)
{
p = &tp->G.P[i];
p->action = 0;
p->turni = 0xff;
if ( cardi > N*2 )
p->snapshot = p->bets;
}
hand->undergun = ((hand->button + 3) % N);
if ( cardi < N*2 )
pangea_checkantes(myinfo,tp);
hand->betsizesnapshot = hand->betsize = pangea_snapshot(tp,snapshot);
printf("STARTBETS.%d cardi.%d numactions.%d undergun.%d betsize %.8f N %d\n",hand->betstarted,cardi,hand->numactions,hand->undergun,dstr(hand->betsize),N);
pangea_sendcmd(myinfo,tp,"turn",-1,(void *)snapshot,sizeof(*snapshot)*(N+1),cardi,hand->undergun);
}
void pangea_facedown(PANGEA_HANDARGS)
{
int32_t i,validcard,n = 0; uint64_t havemask; struct player_info *p;
p = tp->active[senderind];
if ( p == 0 || N <= 1 || data == 0 || datalen != sizeof(int32_t) )
{
PNACL_message("pangea_facedown invalid datalen.%d vs %ld\n",datalen,(long)sizeof(bits256));
return;
}
validcard = turni;
if ( validcard > 0 )
p->havemask |= (1LL << cardi);
//if ( Debuglevel > 2 )
PNACL_message(" | player.%d sees that destplayer.%d got cardi.%d valid.%d | %llx | n.%d\n",tp->priv.myind,senderind,cardi,validcard,(long long)p->havemask,n);
for (i=0; i<N; i++)
{
if ( (p= tp->active[i]) != 0 )
{
havemask = p->havemask;
if ( Debuglevel > 2 )
PNACL_message("%llx ",(long long)havemask);
if ( bitweight(havemask) == 2 )
n++;
}
}
if ( tp->priv.myind == pangea_slotA(tp) && n == N )
pangea_startbets(myinfo,tp,N*2);
}
void pangea_faceup(PANGEA_HANDARGS)
{
int32_t validcard,i; struct hand_info *hand; uint16_t tmp; struct player_info *p,*destp;
hand = &tp->hand;
destp = tp->active[senderind];
if ( destp == 0 || N <= 1 || data == 0 || datalen != sizeof(bits256) )
{
PNACL_message("pangea_faceup invalid datalen.%d vs %ld\n",datalen,(long)((tp->G.numcards + 1) * sizeof(bits256)));
return;
}
validcard = (turni >= 0);
if ( Debuglevel > 2 || tp->priv.myind == pangea_slotA(tp) )
{
PNACL_message("from.%d -> player.%d COMMUNITY.[%d] cardi.%d valid.%d\n",senderind,tp->priv.myind,data[1],cardi,validcard);
}
PNACL_message("got FACEUP cardi.%d validcard.%d [%d]\n",cardi,validcard,data[1]);
if ( validcard > 0 )
{
tmp = (cardi << 8);
tmp |= (turni & 0xff);
pangea_summaryadd(myinfo,tp,CARDS777_FACEUP,&tmp,sizeof(tmp),data,sizeof(bits256));
if ( cardi >= N*2 && cardi < N*2+5 )
{
hand->community[cardi - N*2] = data[1];
for (i=0; i<N; i++)
{
if ( (p= tp->active[i]) != 0 )
p->hand[cardi - N*2] = data[1];
}
memcpy(hand->community256[cardi - N*2].bytes,data,sizeof(bits256));
PNACL_message("set community[%d] <- %d\n",cardi - N*2,data[1]);
if ( senderind == tp->priv.myind )
pangea_rank(myinfo,tp,senderind);
if ( tp->priv.myind == pangea_slotA(tp) && cardi >= N*2+2 && cardi < N*2+5 )
pangea_startbets(myinfo,tp,cardi+1);
//else PNACL_message("dont start bets %d\n",cardi+1);
}
else
{
PNACL_message("valid.%d cardi.%d vs N.%d\n",validcard,cardi,N);
if ( cardi < N*2 )
{
memcpy(hand->cards[senderind][cardi/N].bytes,data,sizeof(bits256));
destp->hand[5 + cardi/N] = data[1];
pangea_rank(myinfo,tp,senderind);
}
}
}
}
void pangea_turn(PANGEA_HANDARGS)
{
struct player_info *destp; int64_t snapshot[CARDS777_MAXPLAYERS+1]; struct hand_info *hand = &tp->hand;
destp = tp->active[senderind];
if ( destp == 0 || N <= 1 )
{
PNACL_message("pangea_turn illegal arg\n");
return;
}
//if ( Debuglevel > 2 )
printf("P%d: got turn.%d from %d | cardi.%d summary[%d] crc.%u\n",tp->priv.myind,turni,senderind,cardi,tp->summarysize,calc_crc32(0,tp->summary,tp->summarysize));
destp->turni = turni;
if ( senderind == 0 )
{
hand->cardi = cardi;
hand->betstarted = 1;
hand->undergun = turni;
if ( tp->priv.myind != pangea_slotA(tp) )
{
pangea_checkantes(myinfo,tp);
hand->betsizesnapshot = pangea_snapshot(tp,snapshot);
//printf("player.%d sends confirmturn.%d\n",tp->priv.myind,turni);
pangea_sendcmd(myinfo,tp,"confirm",-1,(void *)snapshot,sizeof(uint64_t)*(N+1),cardi,turni);
}
}
}
void pangea_confirm(PANGEA_HANDARGS)
{
uint32_t starttime; int32_t i; uint64_t betsize=0,amount=0;
int64_t snapshot[CARDS777_MAXPLAYERS+1]; struct player_info *p; struct hand_info *hand;
hand = &tp->hand; p = tp->active[senderind];
if ( p == 0 || N <= 1 || data == 0 )
{
printf("pangea_turn: null data\n");
return;
}
printf("P%d: got confirmturn.%d cardi.%d sender.%d\n",tp->priv.myind,turni,cardi,senderind);
//if ( datalen == sizeof(betsize) )
// memcpy(&betsize,data,sizeof(betsize));
starttime = hand->starttime;
if ( senderind == 0 && tp->priv.myind != pangea_slotA(tp) )
{
hand->undergun = turni;
hand->cardi = cardi;
betsize = pangea_snapshot(tp,snapshot);
if ( betsize != hand->betsizesnapshot )
printf("T%d ERROR BETSIZE MISMATCH: %.8f vs %.8f\n",tp->priv.myind,dstr(betsize),dstr(hand->betsizesnapshot));
hand->betsize = betsize;
}
p->turni = turni;
for (i=0; i<N; i++)
{
if ( (p= tp->active[i]) != 0 && p->turni != turni )
break;
}
//printf("sp.%p vs turni.%d cardi.%d hand.cardi %d\n",sp,turni,cardi,hand->cardi);
if ( tp->priv.myind == pangea_slotA(tp) && i == N )
{
betsize = pangea_snapshot(tp,snapshot);
hand->betsize = hand->betsizesnapshot = betsize;
//if ( Debuglevel > 2 )
printf("player.%d sends confirmturn.%d cardi.%d betsize %.0f\n",tp->priv.myind,hand->undergun,hand->cardi,dstr(betsize));
if ( senderind != 0 )
pangea_sendcmd(myinfo,tp,"confirm",-1,(void *)snapshot,sizeof(*snapshot)*(N+1),hand->cardi,hand->undergun);
}
if ( senderind == 0 && (turni= hand->undergun) == tp->priv.myind && (p= tp->active[senderind]) != 0 )
{
if ( hand->betsize != betsize )
printf("P%d: pangea_turn warning hand.betsize %.8f != betsize %.8f\n",tp->priv.myind,dstr(hand->betsize),dstr(betsize));
//if ( sp->isbot[tp->priv.myind] != 0 )
// pangea_bot(myinfo,tp,turni,cardi,betsize);
//else
if ( p->betstatus == CARDS777_FOLD || p->betstatus == CARDS777_ALLIN )
pangea_sendcmd(myinfo,tp,"action",-1,(void *)&amount,sizeof(amount),cardi,0);
else if ( tp->priv.autofold != 0 )
pangea_sendcmd(myinfo,tp,"action",-1,(void *)&amount,sizeof(amount),cardi,0);
else
{
hand->userinput_starttime = (uint32_t)time(NULL);
hand->cardi = cardi;
hand->betsize = betsize;
fprintf(stderr,"Waiting for user input cardi.%d: ",cardi);
}
if ( tp->priv.myind == pangea_slotA(tp) )
{
char *str = jprint(pangea_tablestatus(myinfo,tp),1);
printf("%s\n",str);
free(str);
}
//pangea_statusprint(dp,priv,tp->priv.myind);
}
}
void pangea_finish(struct supernet_info *myinfo,struct table_info *tp)
{
int64_t tsnap,sidepots[CARDS777_MAXPLAYERS][CARDS777_MAXPLAYERS];//,list[CARDS777_MAXPLAYERS];
uint64_t pangearake,rake; int64_t balances[CARDS777_MAXPLAYERS],bets[CARDS777_MAXPLAYERS+1];
uint32_t changes; uint16_t busted,rebuy; int32_t j,n,r,N,norake = 0; struct hand_info *hand;
N = tp->G.numactive, hand = &tp->hand;
if ( hand->finished == 0 )
{
memset(sidepots,0,sizeof(sidepots));
pangea_snapshot(tp,bets);
n = pangea_sidepots(myinfo,tp,1,sidepots,bets);
if ( hand->community[0] == 0xff )
norake = 1;
for (pangearake=rake=j=0; j<n; j++)
rake += pangea_splitpot(myinfo,tp,&pangearake,sidepots[j],norake == 0 ? tp->G.rakemillis : 0);
hand->finished = (uint32_t)time(NULL);
tp->hostrake += rake;
tp->pangearake += pangearake;
tp->G.hostrake = rake;
tp->G.pangearake = pangearake;
for (j=busted=rebuy=r=0; j<N; j++)
{
if ( tp->active[j] != 0 )
{
balances[j] = tp->active[j]->balance;
tsnap = tp->snapshot[tp->active[j]->ind];
//balances[j] += hand->won[j];
//sp->balances[pangea_slot(sp,j)] = balances[j];
if ( tsnap > 0 && balances[j] <= 0 )
{
busted |= (1 << j);
//list[r++] = sp->active[j];
}
else if ( tsnap <= 0 && balances[j] > 0 )
rebuy |= (1 << j);
}
}
changes = (((uint32_t)rebuy<<20) | ((uint32_t)busted<<4) | (tp->G.N&0xf));
pangea_summaryadd(myinfo,tp,CARDS777_CHANGES,(void *)&changes,sizeof(changes),(void *)balances,sizeof(uint64_t)*tp->G.N);
pangea_summaryadd(myinfo,tp,CARDS777_RAKES,(void *)&rake,sizeof(rake),(void *)&pangearake,sizeof(pangearake));
if ( tp->priv.myind == pangea_slotA(tp) )
{
char *sumstr,*statstr;
statstr = jprint(pangea_tablestatus(myinfo,tp),1);
sumstr = pangea_dispsummary(myinfo,tp,1,tp->summary,tp->summarysize,tp->G.tablehash,tp->numhands-1,tp->G.N);
printf("%s\n\n%s",statstr,sumstr);
free(statstr), free(sumstr);
pangea_sendcmd(myinfo,tp,"summary",-1,tp->summary,tp->summarysize,0,0);
}
/*if ( 0 && busted != 0 )
{
for (j=0; j<r; j++)
{
if ( list[j] != sp->active[0] )
{
pangea_inactivate(dp,sp,list[j]);
printf("T%d: INACTIVATE.[%d] %llu\n",sp->myslot,j,(long long)list[j]);
}
}
}*/
}
}
int32_t pangea_lastman(struct supernet_info *myinfo,struct table_info *tp)
{
int32_t activej = -1; struct hand_info *hand = &tp->hand;
if ( hand->betstarted != 0 && pangea_actives(&activej,tp) <= 1 )
{
if ( hand->finished != 0 )
{
printf("DUPLICATE LASTMAN!\n");
return(1);
}
if ( 0 && tp->priv.myind == activej && tp->priv.automuck == 0 )
{
pangea_sendcmd(myinfo,tp,"faceup",-1,tp->priv.holecards[0].bytes,sizeof(tp->priv.holecards[0]),tp->priv.cardis[0],tp->priv.cardis[0] != 0xff);
pangea_sendcmd(myinfo,tp,"faceup",-1,tp->priv.holecards[1].bytes,sizeof(tp->priv.holecards[1]),tp->priv.cardis[1],tp->priv.cardis[1] != 0xff);
}
pangea_finish(myinfo,tp);
return(1);
}
return(0);
}
void pangea_action(PANGEA_HANDARGS)
{
uint32_t now; struct player_info *p; int64_t x,snapshot[CARDS777_MAXPLAYERS + 1]; int32_t action,i,j;
bits256 audit[CARDS777_MAXPLAYERS]; struct hand_info *hand; uint8_t tmp; int64_t amount = 0;
hand = &tp->hand;
p = tp->active[senderind];
memcpy(&amount,data,sizeof(amount));
if ( N <= 1 || p == 0 || cardi < 2*N )
{
printf("pangea_action: illegal cardi.%d\n",cardi);
return;
}
action = cardi;
if ( senderind != hand->undergun )
{
printf("T%d: out of turn action.%d by player.%d (undergun.%d) cardi.%d amount %.8f\n",tp->priv.myind,action,senderind,hand->undergun,cardi,dstr(amount));
return;
}
tmp = senderind;
p->action = action;
p->actualaction = pangea_playerbet(myinfo,&p->actualbet,tp,tp->active[senderind],amount,CARDS777_CHECK);
hand->undergun = (hand->undergun + 1) % N;
hand->numactions++;
//if ( Debuglevel > 2 )//|| tp->priv.myind == 0 )
printf("player.%d: got action.%d cardi.%d senderind.%d -> undergun.%d numactions.%d\n",tp->priv.myind,action,cardi,senderind,hand->undergun,hand->numactions);
if ( pangea_lastman(myinfo,tp) > 0 )
return;
if ( tp->priv.myind == pangea_slotA(tp) )
{
now = (uint32_t)time(NULL);
for (i=j=0; i<N; i++)
{
j = (hand->undergun + i) % N;
if ( (p= tp->active[j]) != 0 )
{
if ( p->betstatus == CARDS777_FOLD || p->betstatus == CARDS777_ALLIN )
{
p->action = p->betstatus;
//printf("skip player.%d\n",j);
hand->numactions++;
} else break;
}
}
hand->undergun = j;
if ( hand->numactions < N )
{
//printf("T%d: senderind.%d i.%d j.%d -> undergun.%d numactions.%d\n",tp->priv.myind,senderind,i,j,hand->undergun,hand->numactions);
//if ( senderind != 0 )
memset(snapshot,0,sizeof(*snapshot)*(N+1));
for (x=i=0; i<N; i++)
if ( (p= tp->active[i]) != 0 )
{
if ( p->snapshot > x )
x = p->snapshot;
snapshot[i] = p->snapshot;
}
snapshot[N] = x;
pangea_sendcmd(myinfo,tp,"turn",-1,(void *)snapshot,sizeof(*snapshot)*(N+1),hand->cardi,hand->undergun);
}
else
{
for (i=0; i<5; i++)
{
if ( hand->community[i] == 0xff )
break;
printf("%02x ",hand->community[i]);
}
printf("COMMUNITY\n");
if ( i == 0 )
{
if ( hand->cardi != N * 2 )
printf("cardi mismatch %d != %d\n",hand->cardi,N * 2);
cardi = hand->cardi;
printf("decode flop\n");
for (i=0; i<3; i++,cardi++)
{
memset(audit,0,sizeof(audit));
audit[0] = hand->final[cardi*N + destplayer];
pangea_sendcmd(myinfo,tp,"decoded",-1,audit[0].bytes,sizeof(bits256)*N,cardi,N-1);
}
}
else if ( i == 3 )
{
if ( hand->cardi != N * 2+3 )
printf("cardi mismatch %d != %d\n",hand->cardi,N * 2 + 3);
cardi = hand->cardi;
printf("decode turn\n");
memset(audit,0,sizeof(audit));
audit[0] = hand->final[cardi*N + destplayer];
pangea_sendcmd(myinfo,tp,"decoded",-1,audit[0].bytes,sizeof(bits256)*N,cardi,N-1);
//pangea_sendcmd(myinfo,tp,"decoded",-1,hand->final[cardi*N + destplayer].bytes,sizeof(hand->final[cardi*N + destplayer]),cardi,N-1);
}
else if ( i == 4 )
{
printf("decode river\n");
if ( hand->cardi != N * 2+4 )
printf("cardi mismatch %d != %d\n",hand->cardi,N * 2+4);
cardi = hand->cardi;
memset(audit,0,sizeof(audit));
audit[0] = hand->final[cardi*N + destplayer];
pangea_sendcmd(myinfo,tp,"decoded",-1,audit[0].bytes,sizeof(bits256)*N,cardi,N-1);
//pangea_sendcmd(myinfo,tp,"decoded",-1,hand->final[cardi*N + destplayer].bytes,sizeof(hand->final[cardi*N + destplayer]),cardi,N-1);
}
else
{
cardi = N * 2 + 5;
if ( hand->cardi != N * 2+5 )
printf("cardi mismatch %d != %d\n",hand->cardi,N * 2+5);
for (i=0; i<N; i++)
{
j = (hand->lastbettor + i) % N;
if ( tp->active[j] != 0 && tp->active[j]->betstatus != CARDS777_FOLD )
break;
}
hand->undergun = j;
printf("sent showdown request for undergun.%d\n",j);
pangea_sendcmd(myinfo,tp,"showdown",-1,(void *)&hand->betsize,sizeof(hand->betsize),cardi,hand->undergun);
}
}
}
if ( Debuglevel > 2 )// || tp->priv.myind == 0 )
{
char *str = jprint(pangea_tablestatus(myinfo,tp),1);
printf("player.%d got pangea_action.%d for player.%d action.%d amount %.8f | numactions.%d\n%s\n",tp->priv.myind,cardi,senderind,action,dstr(amount),hand->numactions,str);
free(str);
}
}
void pangea_decoded(PANGEA_HANDARGS)
{
int32_t card; bits256 cardpriv,audit[CARDS777_MAXPLAYERS]; struct hand_info *hand;
hand = &tp->hand;
if ( N <= 1 || data == 0 || datalen != sizeof(bits256)*N )
{
PNACL_message("pangea_decoded invalid datalen.%d vs %ld\n",datalen,(long)sizeof(bits256));
return;
}
if ( cardi < N*2 || cardi >= N*2 + 5 )
{
PNACL_message("pangea_decoded invalid cardi.%d\n",cardi);
return;
}
destplayer = 0;
pangea_rwaudit(1,(void *)data,tp->priv.audits,cardi,destplayer,N);
pangea_rwaudit(0,audit,tp->priv.audits,cardi,destplayer,N);
if ( turni == tp->priv.myind )
{
if ( tp->priv.myind != pangea_slotA(tp) )
{
audit[0] = cards777_decode(&audit[tp->priv.myind],tp->priv.xoverz,destplayer,audit[0],tp->priv.outcards,tp->G.numcards,N);
pangea_rwaudit(1,audit,tp->priv.audits,cardi,destplayer,N);
pangea_sendcmd(myinfo,tp,"decoded",-1,audit[0].bytes,sizeof(bits256)*N,cardi,pangea_prevnode(tp));
}
else
{
if ( (card= cards777_checkcard(&cardpriv,cardi,tp->priv.myind,tp->priv.myind,tp->priv.mypriv,hand->cardpubs,tp->G.numcards,audit[0])) >= 0 )
{
if ( cards777_validate(cardpriv,hand->final[cardi*N + destplayer],hand->cardpubs,tp->G.numcards,audit,N,tp->priv.mypub) < 0 )
PNACL_message("player.%d decoded cardi.%d card.[%d] but it doesnt validate\n",tp->priv.myind,cardi,card);
pangea_sendcmd(myinfo,tp,"faceup",-1,cardpriv.bytes,sizeof(cardpriv),cardi,cardpriv.txid!=0?0xff:-1);
//PNACL_message("-> FACEUP.(%s)\n",hex);
}
}
}
}
void pangea_showdown(PANGEA_HANDARGS)
{
struct player_info *p; int32_t i,myind; struct hand_info *hand; uint64_t amount=0;
hand = &tp->hand;
myind = tp->priv.myind;
if ( (p= tp->active[myind]) == 0 )
{
printf("error nullp myind.%d\n",myind);
return;
}
//if ( Debuglevel > 2 )
printf("P%d: showdown from sender.%d\n",myind,senderind);
if ( p->betstatus != CARDS777_FOLD && ((tp->priv.automuck == 0 && p->action != CARDS777_SENTCARDS) || (turni == myind && hand->lastbettor == myind)) )
{
if ( tp->priv.automuck != 0 && pangea_myrank(myinfo,tp,p) < 0 )
pangea_sendcmd(myinfo,tp,"action",-1,(void *)&amount,sizeof(amount),cardi,CARDS777_FOLD);
else
{
pangea_sendcmd(myinfo,tp,"faceup",-1,tp->priv.holecards[0].bytes,sizeof(tp->priv.holecards[0]),tp->priv.cardis[0],myind);
pangea_sendcmd(myinfo,tp,"faceup",-1,tp->priv.holecards[1].bytes,sizeof(tp->priv.holecards[1]),tp->priv.cardis[1],myind);
p->action = CARDS777_SENTCARDS;
}
}
if ( pangea_lastman(myinfo,tp) > 0 )
return;
if ( myind == pangea_slotA(tp) && senderind != 0 )
{
for (i=0; i<N; i++)
{
hand->undergun = (hand->undergun + 1) % N;
if ( hand->undergun == hand->lastbettor )
{
printf("all players queried with showdown handmask.%x finished.%u\n",hand->handmask,hand->finished);
return;
}
if ( (p= tp->active[hand->undergun]) != 0 && p->betstatus != CARDS777_FOLD )
break;
}
printf("senderind.%d host sends showdown for undergun.%d\n",senderind,hand->undergun);
pangea_sendcmd(myinfo,tp,"showdown",-1,(void *)&hand->betsize,sizeof(hand->betsize),cardi,hand->undergun);
}
}
int32_t pangea_anotherhand(struct supernet_info *myinfo,struct table_info *tp,int32_t sleepflag)
{
int32_t i,n,activej = -1; int64_t balance,onlybalance = 0,total = 0;
for (i=n=0; i<tp->G.N; i++)
{
PNACL_message("(p%d %.8f) ",i,dstr(tp->G.P[i].balance));
if ( (balance= tp->G.P[i].balance) != 0 )
{
total += balance;
onlybalance = balance;
if ( activej < 0 )
activej = i;
n++;
}
}
PNACL_message("balance %.8f [%.8f]\n",dstr(total),dstr(total + tp->G.hostrake + tp->G.pangearake));
if ( n == 1 )
{
PNACL_message("Only player.%d left with %.8f | get sigs and cashout after numhands.%d\n",activej,dstr(onlybalance),tp->numhands);
sleep(60);
return(1);
}
else
{
if ( sleepflag != 0 )
sleep(sleepflag);
//hand->betstarted = 0;
pangea_newdeck(myinfo,tp);
if ( sleepflag != 0 )
sleep(sleepflag);
}
return(n);
}