static __u16 capi_put_message(__u16 applid, struct sk_buff *skb)
{
avmb1_ncci *np;
int contr;
if (ncards == 0)
return CAPI_REGNOTINSTALLED;
if (!VALID_APPLID(applid))
return CAPI_ILLAPPNR;
if (skb->len < 12
|| !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
|| !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
contr = CAPIMSG_CONTROLLER(skb->data);
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) {
contr = 1;
if (CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
}
if (CARD(contr)->blocked)
return CAPI_SENDQUEUEFULL;
if ( CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3
&& CAPIMSG_SUBCOMMAND(skb->data) == CAPI_REQ
&& (np = find_ncci(APPL(applid), CAPIMSG_NCCI(skb->data))) != 0
&& mq_enqueue(np, CAPIMSG_MSGID(skb->data)) == 0)
return CAPI_SENDQUEUEFULL;
B1_send_message(CARD(contr)->port, skb);
return CAPI_NOERROR;
}
static __u16 capi_put_message(__u16 applid, struct sk_buff *skb)
{
struct capi_ncci *np;
__u32 contr;
int showctl = 0;
__u8 cmd, subcmd;
if (ncards == 0)
return CAPI_REGNOTINSTALLED;
if (!VALID_APPLID(applid))
return CAPI_ILLAPPNR;
if (skb->len < 12
|| !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
|| !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
contr = CAPIMSG_CONTROLLER(skb->data);
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) {
contr = 1;
if (CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
}
if (CARD(contr)->blocked)
return CAPI_SENDQUEUEFULL;
cmd = CAPIMSG_COMMAND(skb->data);
subcmd = CAPIMSG_SUBCOMMAND(skb->data);
if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
if ((np = find_ncci(APPL(applid), CAPIMSG_NCCI(skb->data))) != 0
&& mq_enqueue(np, CAPIMSG_MSGID(skb->data)) == 0)
return CAPI_SENDQUEUEFULL;
CARD(contr)->nsentdatapkt++;
APPL(applid)->nsentdatapkt++;
if (CARD(contr)->traceflag > 2) showctl |= 2;
} else {
CARD(contr)->nsentctlpkt++;
APPL(applid)->nsentctlpkt++;
if (CARD(contr)->traceflag) showctl |= 2;
}
showctl |= (CARD(contr)->traceflag & 1);
if (showctl & 2) {
if (showctl & 1) {
printk(KERN_DEBUG "kcapi: put [0x%lx] id#%d %s len=%u\n",
(unsigned long) contr,
CAPIMSG_APPID(skb->data),
capi_cmd2str(cmd, subcmd),
CAPIMSG_LEN(skb->data));
} else {
printk(KERN_DEBUG "kcapi: put [0x%lx] %s\n",
(unsigned long) contr,
capi_message2str(skb->data));
}
}
CARD(contr)->driver->send_message(CARD(contr), skb);
return CAPI_NOERROR;
}
static __u16 capi_get_version(__u32 contr, struct capi_version *verp)
{
if (contr == 0) {
*verp = driver_version;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
memcpy((void *) verp, &CARD(contr)->version, sizeof(capi_version));
return CAPI_NOERROR;
}
static __u16 capi_get_manufacturer(__u32 contr, __u8 buf[CAPI_MANUFACTURER_LEN])
{
if (contr == 0) {
strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
strncpy(buf, CARD(contr)->manu, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR;
}
static __u16 capi_get_serial(__u32 contr, __u8 serial[CAPI_SERIAL_LEN])
{
if (contr == 0) {
strncpy(serial, driver_serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
strncpy((void *) serial, CARD(contr)->serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR;
}
static __u16 capi_get_profile(__u16 contr, struct capi_profile *profp)
{
if (contr == 0) {
profp->ncontroller = ncards;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) profp, CARD(contr)->version[VER_PROFILE],
sizeof(struct capi_profile));
return CAPI_NOERROR;
}
static __u16 capi_get_version(__u16 contr, struct capi_version *verp)
{
if (contr == 0) {
*verp = driver_version;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) verp, CARD(contr)->version[VER_SERIAL],
sizeof(capi_version));
return CAPI_NOERROR;
}
static __u16 capi_get_profile(__u32 contr, struct capi_profile *profp)
{
if (contr == 0) {
profp->ncontroller = ncards;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
memcpy((void *) profp, &CARD(contr)->profile,
sizeof(struct capi_profile));
return CAPI_NOERROR;
}
static __u16 capi_get_serial(__u16 contr, __u8 serial[CAPI_SERIAL_LEN])
{
if (contr == 0) {
strncpy(serial, driver_serial, 8);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) serial, CARD(contr)->version[VER_SERIAL],
CAPI_SERIAL_LEN);
serial[CAPI_SERIAL_LEN - 1] = 0;
return CAPI_NOERROR;
}
static void printDesk (int cnt) {
printf("desk:");
for (int z = 0; z < cnt; z++) {
printf(" %s%s(%2i)", cFaceS[xDeskFaces[z]-7], cSuitS[xDeskSuits[z]], CARD(xDeskFaces[z], xDeskSuits[z]));
}
printf("\n");
}
static void
aisleriot_slot_renderer_paint_card (AisleriotSlotRenderer *srend,
guint card_num)
{
AisleriotSlotRendererPrivate *priv = srend->priv;
Card card = CARD (priv->slot->cards->data[card_num]);
CoglHandle cogl_tex;
guint tex_width, tex_height;
int cardx, cardy;
cogl_tex = ar_card_textures_cache_get_card_texture (priv->cache, card);
if (G_UNLIKELY (cogl_tex == COGL_INVALID_HANDLE))
return;
tex_width = cogl_texture_get_width (cogl_tex);
tex_height = cogl_texture_get_height (cogl_tex);
aisleriot_game_get_card_offset (priv->slot, card_num,
FALSE,
&cardx, &cardy);
aisleriot_slot_renderer_set_material_for_card
(srend, cogl_tex,
priv->show_highlight && card_num >= priv->highlight_start);
cogl_rectangle (cardx, cardy, cardx + tex_width, cardy + tex_height);
}
DefMarking(struct net_object *netobj, struct net_object *unf_netobj)
{
struct place_object *place;
list curr = NULL;
markPTR m;
multisetPTR p_MS;
int i;
char *tag;
while ( (curr = list_iterator(gListMarking, curr)) != NULL ){
m = DATA(curr);
if(m->type==0){
evalMarking(m, &p_MS);
for(i=0; i<CARD(p_MS) ; i++)
if( VALUE(SET(p_MS)[i])>0 ){
tag = NewStringCat(m->place->tag, STR_INDEX(SET(p_MS)[i]));
for(place = unf_netobj->places; place!=NULL && (strcmp(place->tag, tag)!=0) ; place = place->next);
if(place == NULL)
Error(UNKN_PLACE_ERR, "DefMarking", tag);
else
place->m0 = VALUE(SET(p_MS)[i]);
}
}
else{
tag = NewStringCat(m->place->tag, "_");
for(place = unf_netobj->places; place!=NULL && (strcmp(place->tag, tag)!=0) ; place = place->next);
if(place == NULL)
Error(UNKN_PLACE_ERR, "DefMarking", tag);
else
place->mpar = m->mrk;
}
}
}
static void notify_up(__u32 contr)
{
struct capi_interface_user *p;
__u16 appl;
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
if (!VALID_APPLID(appl)) continue;
if (APPL(appl)->releasing) continue;
CARD(contr)->driver->register_appl(CARD(contr), appl, &APPL(appl)->rparam);
}
printk(KERN_NOTICE "kcapi: notify up contr %d\n", contr);
spin_lock(&capi_users_lock);
for (p = capi_users; p; p = p->next) {
if (!p->callback) continue;
(*p->callback) (KCI_CONTRUP, contr, &CARD(contr)->profile);
}
spin_unlock(&capi_users_lock);
}
static void notify_up(__u32 contr)
{
struct capi_interface_user *p;
printk(KERN_NOTICE "kcapi: notify up contr %d\n", contr);
spin_lock(&capi_users_lock);
for (p = capi_users; p; p = p->next) {
if (!p->callback) continue;
(*p->callback) (KCI_CONTRUP, contr, &CARD(contr)->profile);
}
spin_unlock(&capi_users_lock);
}
static void notify_up(__u16 contr)
{
struct capi_interface_user *p;
printk(KERN_NOTICE "b1capi: notify up contr %d\n", contr);
for (p = capi_users; p; p = p->next) {
if (p->callback)
(*p->callback) (KCI_CONTRUP, contr,
(capi_profile *)
CARD(contr)->version[VER_PROFILE]);
}
}
static void printHand (tHand *hand) {
int z;
for (z = 0; z < 10; z++) {
if (hand->faces[z]) {
printf(" %s%s(%2i)", cFaceS[hand->faces[z]-7], cSuitS[hand->suits[z]], CARD(hand->faces[z], hand->suits[z]));
} else {
printf(" ...");
}
}
printf(" 0:(%i,%i); 1:(%i,%i); 2:(%i,%i); 3:(%i,%i)",
hand->suitCount[0], hand->suitStart[0],
hand->suitCount[1], hand->suitStart[1],
hand->suitCount[2], hand->suitStart[2],
hand->suitCount[3], hand->suitStart[3]);
printf("\n");
}
int avmb1_unregistercard(int cnr, int freeio)
{
avmb1_card * card;
if (!VALID_CARD(cnr))
return -ESRCH;
card = CARD(cnr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card, freeio);
free_irq(card->irq, card);
if (freeio)
release_region(card->port, AVMB1_PORTLEN);
card->cardstate = CARD_FREE;
return 0;
}
void
randomize_set(set * S)
{
int e1, e2, i, count = CARD(S);
void * aux;
time_t t;
time(&t);
srand((long)t);
if (count <= 2)
return;
for (i=0; i < count; i++)
{
e1 = (int) (((double)count)*rand()/(RAND_MAX + 1.0));
while ((e2 = (int) (((double)count)*rand()/(RAND_MAX + 1.0))) == e1)
continue;
aux = MEMB(S,e1);
MEMB(S,e1) = MEMB(S,e2);
MEMB(S,e2) = aux;
}
}
int avmb1_resetcard(int cnr)
{
avmb1_card * card;
if (!VALID_CARD(cnr))
return -ESRCH;
card = CARD(cnr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card, 0);
B1_reset(card->port);
B1_reset(card->port);
card->cardstate = CARD_DETECTED;
return 0;
}
int main(){
char buffer[128];
char*c,rank;
unsigned hand,bit,n=0;
do {
c=fgets(buffer,128,stdin); //read a whole line
printf("%s\n",c);
} while (*c=='#'); //skip comments
rank=*c++; //extract rank char
sscanf(c,"%x",&hand); //convert remainder to hex
for (bit=26;bit-->0;) { //extract bits downto 0
if (hand & (1<<bit)) {
cards[n++]=(bit)%13;
}
}
switch (rank){
case '9': printf("Straight Flush, %s high\n",CARD(0));break;
case '8': printf("Error\n");break;
case '7': printf("4 of a Kind, %ss with a %s\n",CARD(0),CARD(1));break;
case '6': printf("Full House, %ss over %ss\n",CARD(0),CARD(1));break;
case '5': printf("Flush, %s %s %s %s %s\n",CARD(0),CARD(1),CARD(2),CARD(3),CARD(4));break;
case '4': printf("Straight, %s high\n",CARD(0));break;
case '3': printf("3 of a Kind, %ss over %s %s\n",CARD(0),CARD(1),CARD(2));break;
case '2': printf("2 Pair, %ss and %ss with a %s\n",CARD(0),CARD(1),CARD(2));break;
case '1': printf("Pair, %ss over %s %s %s\n",CARD(0),CARD(1),CARD(2),CARD(3));break;
case '0': printf("High Card, %s with %s %s %s %s\n",CARD(0),CARD(1),CARD(2),CARD(3),CARD(4));break;
}
}
static int old_capi_manufacturer(unsigned int cmd, void *data)
{
avmb1_loadandconfigdef ldef;
avmb1_extcarddef cdef;
avmb1_resetdef rdef;
avmb1_getdef gdef;
struct capi_driver *driver;
struct capi_ctr *card;
capicardparams cparams;
capiloaddata ldata;
int retval;
switch (cmd) {
case AVMB1_ADDCARD:
case AVMB1_ADDCARD_WITH_TYPE:
if (cmd == AVMB1_ADDCARD) {
if ((retval = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return retval;
cdef.cardtype = AVM_CARDTYPE_B1;
} else {
if ((retval = copy_from_user((void *) &cdef, data,
sizeof(avmb1_extcarddef))))
return retval;
}
cparams.port = cdef.port;
cparams.irq = cdef.irq;
cparams.cardnr = cdef.cardnr;
switch (cdef.cardtype) {
case AVM_CARDTYPE_B1:
driver = find_driver("b1isa");
break;
case AVM_CARDTYPE_T1:
driver = find_driver("t1isa");
break;
default:
driver = 0;
break;
}
if (!driver) {
printk(KERN_ERR "kcapi: driver not loaded.\n");
return -EIO;
}
if (!driver->add_card) {
printk(KERN_ERR "kcapi: driver has no add card function.\n");
return -EIO;
}
return driver->add_card(driver, &cparams);
case AVMB1_LOAD:
case AVMB1_LOAD_AND_CONFIG:
if (cmd == AVMB1_LOAD) {
if ((retval = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return retval;
ldef.t4config.len = 0;
ldef.t4config.data = 0;
} else {
if ((retval = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loadandconfigdef))))
return retval;
}
if (!VALID_CARD(ldef.contr))
return -ESRCH;
card = CARD(ldef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->driver->load_firmware == 0) {
printk(KERN_DEBUG "kcapi: load: driver \%s\" has no load function\n", card->driver->name);
return -ESRCH;
}
if (ldef.t4file.len <= 0) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
return -EINVAL;
}
if (ldef.t4file.data == 0) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
return -EINVAL;
}
ldata.firmware.user = 1;
ldata.firmware.data = ldef.t4file.data;
ldata.firmware.len = ldef.t4file.len;
ldata.configuration.user = 1;
ldata.configuration.data = ldef.t4config.data;
ldata.configuration.len = ldef.t4config.len;
if (card->cardstate != CARD_DETECTED) {
printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
retval = card->driver->load_firmware(card, &ldata);
if (retval) {
card->cardstate = CARD_DETECTED;
return retval;
}
while (card->cardstate != CARD_RUNNING) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((retval = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return retval;
if (!VALID_CARD(rdef.contr))
return -ESRCH;
card = CARD(rdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_DETECTED)
return 0;
card->driver->reset_ctr(card);
while (card->cardstate > CARD_DETECTED) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_GET_CARDINFO:
if ((retval = copy_from_user((void *) &gdef, data,
sizeof(avmb1_getdef))))
return retval;
if (!VALID_CARD(gdef.contr))
return -ESRCH;
card = CARD(gdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
gdef.cardstate = card->cardstate;
if (card->driver == find_driver("t1isa"))
gdef.cardtype = AVM_CARDTYPE_T1;
else gdef.cardtype = AVM_CARDTYPE_B1;
if ((retval = copy_to_user(data, (void *) &gdef,
sizeof(avmb1_getdef))))
return retval;
return 0;
case AVMB1_REMOVECARD:
if ((retval = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return retval;
if (!VALID_CARD(rdef.contr))
return -ESRCH;
card = CARD(rdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate != CARD_DETECTED)
return -EBUSY;
card->driver->remove_ctr(card);
while (card->cardstate != CARD_FREE) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
}
int
main(int argc, char ** argv)
{
char * patfilename = NULL;
char * posfilename = NULL;
char * ignfilename = NULL;
char * negfilename = NULL;
int ifd, pfd, gfd, nfd;
void * buf = (void *) malloc(INIT_BUF_SIZ);
set * P; // patterns
set * pS; // positive words
set * gS; // positive words to ignore
set * nS; // negative words
set * auxS;
int pScnt; // count of positive words in P
int nScnt; // count of negative words in P
double p, n, accuracy;
extern int verbosity;
int opt;
extern char * optarg;
char * options = "p:t:n:f:v";
options = op_add_getopt(options);
while ((opt = getopt(argc, argv, options)) != EOF)
switch (opt)
{
case 'p':
if (!optarg)
{
error("Please specify pattern file.");
exit(_EBADINPUT);
}
patfilename = strdup(optarg);
break;
case 't':
if (optarg)
posfilename = strdup(optarg);
break;
case 'n':
if (optarg)
ignfilename = strdup(optarg);
break;
case 'f':
if (optarg)
negfilename = strdup(optarg);
break;
case 'v':
verbosity = 2;
out(2, "Verbose mode\n");
break;
default:
op_configure_cmdline_options(opt, optarg);
break;
}
if (!patfilename || !(posfilename || negfilename))
{
printf("Evaluates the accuracy of a k-mmg\n");
printf("Usage: %s [-e] -p <patfile> -t <posfile> [-n <ignorefile>] -f <negfile>\n", argv[0]);
printf("where\n");
printf(" -e makes the patterns erasing\n");
printf(" patfile is the file containing the patterns\n");
printf(" posfile is the file containing the positive examples\n");
printf(" ignorefile is the file containing the positive examples to ignore\n");
printf(" negfile is the file containing the negative examples\n\n");
printf("Copyright (C) 2005 Kyushu Institute of Technology\n");
printf("Refer to the \"COPYRIGHT\" file for details.\n");
exit(_EBADINPUT);
}
out(1, "Opening pattern file %s\n", patfilename);
if ((ifd = open(patfilename, 0666)) < 0)
{
error("Cannot open pattern file %s\n", patfilename);
exit(_EBADIO);
}
out(1, "Opening positive example file %s\n", posfilename);
if (posfilename && (pfd = open(posfilename, 0666)) < 0)
{
error("Cannot open positive example file %s\n", posfilename);
exit(_EBADIO);
}
out(1, "Opening ignore example file %s\n", ignfilename);
if (ignfilename && (gfd = open(ignfilename, 0666)) < 0)
{
error("Cannot open ignore example file %s\n", ignfilename);
exit(_EBADIO);
}
out(1, "Opening negative example file %s\n", negfilename);
if (negfilename && (nfd = open(negfilename, 0666)) < 0)
{
error("Cannot open negative example file %s\n", negfilename);
exit(_EBADIO);
}
pS = set_init(128);
if (posfilename)
while (read_string(pfd, buf, INIT_BUF_SIZ, '\n'))
if (*((char *) buf) != '\0')
set_add_member(pS, strdup((char *)buf));
op_init_samples(pS);
gS = set_init(128);
if (ignfilename)
while (read_string(gfd, buf, INIT_BUF_SIZ, '\n'))
if (*((char *) buf) != '\0')
set_add_member(gS, strdup((char *)buf));
op_init_samples(gS);
pS = set_excluding_set(pS, gS);
nS = set_init(128);
if (negfilename)
while (read_string(nfd, buf, INIT_BUF_SIZ, '\n'))
if (*((char *) buf) != '\0')
set_add_member(nS, strdup((char *)buf));
op_init_samples(nS);
P = set_init(128);
while (read_string(ifd, buf, INIT_BUF_SIZ, '\n'))
if (*((char *) buf) != '\0')
set_add_member(P, printable_to_pattern(trim((char *)buf)));
out(1, "Computation commenced (#pat=%i, #pos=%i, #neg=%i)\n",
CARD(P), CARD(pS), CARD(nS));
auxS = set_excluding_patterns(pS, P);
pScnt = CARD(pS) - CARD(auxS);
set_free(auxS);
auxS = set_excluding_patterns(nS, P);
nScnt = CARD(auxS);
set_free(auxS);
p = CARD(pS)? 100.0 * pScnt/ CARD(pS): 100.0;
n = CARD(nS)? 100.0 * nScnt/ CARD(nS): 100.0;
accuracy = sqrt(p * n);
printf("p = %lf n = %lf acc = %lf\n", p, n, accuracy);
exit(0);
}
static int capi_manufacturer(unsigned int cmd, void *data)
{
unsigned long flags;
avmb1_loaddef ldef;
avmb1_carddef cdef;
avmb1_resetdef rdef;
avmb1_card *card;
int rc;
switch (cmd) {
case AVMB1_ADDCARD:
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return rc;
if (!B1_valid_irq(cdef.irq))
return -EINVAL;
if ((rc = avmb1_probecard(cdef.port, cdef.irq)) != 0)
return rc;
return avmb1_addcard(cdef.port, cdef.irq);
case AVMB1_LOAD:
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return rc;
if (!VALID_CARD(ldef.contr) || ldef.t4file.len <= 0) {
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: invalid parameter contr=%d len=%d\n", ldef.contr, ldef.t4file.len);
return -EINVAL;
}
card = CARD(ldef.contr);
save_flags(flags);
cli();
if (card->cardstate != CARD_DETECTED) {
restore_flags(flags);
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: reseting contr %d\n",
ldef.contr);
}
B1_reset(card->port);
if ((rc = B1_load_t4file(card->port, &ldef.t4file))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load t4file!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
B1_disable_irq(card->port);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: ready contr %d: checking\n",
ldef.contr);
}
if (!B1_loaded(card->port)) {
card->cardstate = CARD_DETECTED;
printk(KERN_ERR "b1capi: failed to load t4file.\n");
return -EIO;
}
/*
* enable interrupt
*/
card->cardstate = CARD_INITSTATE;
save_flags(flags);
cli();
B1_assign_irq(card->port, card->irq);
B1_enable_irq(card->port);
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: irq enabled contr %d\n",
ldef.contr);
}
/*
* init card
*/
B1_send_init(card->port, AVM_NAPPS, AVM_NNCCI, card->cnr - 1);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: waiting for init reply contr %d\n",
ldef.contr);
}
while (card->cardstate != CARD_RUNNING) {
current->timeout = jiffies + HZ / 10; /* 0.1 sec */
current->state = TASK_INTERRUPTIBLE;
schedule();
if (current->signal & ~current->blocked)
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((rc = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return rc;
if (!VALID_CARD(rdef.contr))
return -EINVAL;
card = CARD(rdef.contr);
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card);
card->cardstate = CARD_DETECTED;
B1_reset(card->port);
B1_reset(card->port);
return 0;
}
return -EINVAL;
}
static void tsuroCreateDeck()
{
tsuroCard cards[tsuroNumBaseCards];
int n;
#define CARD(a,b, c,d, e,f, g,h) { int _data[4][2] = {{a,b},{c,d},{e,f},{g,h}}; tsuroCardCreate((&cards[n]),_data); n++; }
n = 0;
CARD( 0,1, 2,3, 4,5, 6,7);
CARD( 0,7, 1,6, 2,5, 3,4);
CARD( 0,6, 1,7, 2,4, 3,5);
CARD( 0,7, 1,2, 3,4, 5,6);
CARD( 0,5, 1,4, 2,7, 3,6);
CARD( 0,4, 1,5, 2,6, 3,7); // Need better drawing
CARD( 0,4, 1,5, 2,7, 3,6);
CARD( 1,7, 0,2, 3,4, 5,6);
CARD( 1,7, 0,3, 2,4, 5,6);
CARD( 1,6, 0,3, 2,4, 5,7);
CARD( 2,7, 3,6, 0,1, 4,5);
CARD( 3,7, 2,6, 0,1, 4,5);
CARD( 3,6, 4,5, 0,2, 1,7);
CARD( 3,4, 5,6, 0,2, 1,7);
CARD( 3,5, 4,6, 0,2, 1,7);
CARD( 2,5, 4,7, 0,3, 1,6);
CARD( 0,7, 1,6, 2,4, 3,5);
CARD( 2,7, 0,6, 1,3, 4,5);
CARD( 0,3, 7,4, 1,5, 6,2); // Need better drawing
CARD( 2,7, 1,6, 0,3, 4,5);
CARD( 2,7, 1,3, 0,4, 6,5);
CARD( 2,7, 0,6, 1,5, 3,4);
CARD( 1,5, 7,3, 0,2, 4,6);
CARD( 0,4, 6,2, 1,7, 5,3);
CARD( 0,3, 1,2, 4,5, 6,7);
CARD( 0,3, 1,5, 4,2, 6,7);
CARD( 5,2, 4,0, 1,3, 6,7);
CARD( 5,3, 4,0, 1,2, 6,7);
CARD( 1,2, 0,6, 7,4, 5,3);
CARD( 0,6, 1,7, 2,3, 4,5);
// Replicate the last 5 cards!
CARD( 0,3, 1,5, 4,2, 6,7);
CARD( 5,2, 4,0, 1,3, 6,7);
CARD( 5,3, 4,0, 1,2, 6,7);
CARD( 1,2, 0,6, 7,4, 5,3);
CARD( 0,6, 1,7, 2,3, 4,5);
if (n>tsuroNumBaseCards)
{
printf("error: you need to increase numBaseCards!\n");
exit(0);
}
// Copy the deck
memcpy(g_game.deck, cards, sizeof(g_game.deck));
}
void
aisleriot_slot_renderer_set_animations (AisleriotSlotRenderer *srend,
guint n_anims,
const AisleriotAnimStart *anims,
guint n_unexposed_animated_cards)
{
AisleriotSlotRendererPrivate *priv;
guint i;
gint card_num;
g_return_if_fail (AISLERIOT_IS_SLOT_RENDERER (srend));
priv = srend->priv;
g_return_if_fail (n_anims <= priv->slot->exposed);
/* Destroy the current animations */
for (i = 0; i < priv->animations->len; i++) {
AnimationData *anim_data;
anim_data = &g_array_index (priv->animations, AnimationData, i);
if (anim_data->move)
g_object_unref (anim_data->move);
if (anim_data->rotate)
g_object_unref (anim_data->rotate);
if (anim_data->depth)
g_object_unref (anim_data->depth);
clutter_actor_destroy (anim_data->card_tex);
g_object_unref (anim_data->card_tex);
}
g_array_set_size (priv->animations, 0);
card_num = priv->slot->cards->len - n_anims;
for (i = 0; i < n_anims; i++) {
AnimationData anim_data;
ClutterAlpha *alpha;
ClutterKnot knots[2];
Card card = CARD (priv->slot->cards->data[card_num]);
guint card_width, card_height;
memset (&anim_data, 0, sizeof (anim_data));
anim_data.card_tex = aisleriot_card_new (priv->cache,
anims[i].old_card,
card);
card_width = clutter_actor_get_width (anim_data.card_tex);
card_height = clutter_actor_get_height (anim_data.card_tex);
g_object_ref_sink (anim_data.card_tex);
if (priv->animation_layer)
clutter_container_add (priv->animation_layer,
CLUTTER_ACTOR (anim_data.card_tex), NULL);
clutter_actor_set_position (anim_data.card_tex,
anims[i].cardx, anims[i].cardy);
knots[0].x = anims[i].cardx;
knots[0].y = anims[i].cardy;
aisleriot_game_get_card_offset (priv->slot, card_num, FALSE,
&knots[1].x, &knots[1].y);
knots[1].x += priv->slot->rect.x;
knots[1].y += priv->slot->rect.y;
alpha = clutter_alpha_new_full (priv->timeline, CLUTTER_LINEAR);
anim_data.move
= clutter_behaviour_path_new_with_knots (alpha, knots,
G_N_ELEMENTS (knots));
clutter_behaviour_apply (anim_data.move, anim_data.card_tex);
if (anims[i].old_card.value != card.value) {
int center_x, center_y;
center_x = card_width / 2;
center_y = card_height / 2;
clutter_actor_set_rotation (anim_data.card_tex, CLUTTER_Y_AXIS,
180.0,
center_x, center_y, 0);
anim_data.rotate = clutter_behaviour_rotate_new (alpha,
CLUTTER_Y_AXIS,
CLUTTER_ROTATE_CW,
180.0, 0.0);
clutter_behaviour_rotate_set_center (CLUTTER_BEHAVIOUR_ROTATE
(anim_data.rotate),
center_x, center_y, 0);
clutter_behaviour_apply (anim_data.rotate, anim_data.card_tex);
}
if (anims[i].raise) {
alpha = clutter_alpha_new_with_func (priv->timeline,
aisleriot_slot_sine_animation_mode,
NULL, NULL);
anim_data.depth = clutter_behaviour_depth_new (alpha,
0, card_height);
clutter_behaviour_apply (anim_data.depth, anim_data.card_tex);
}
g_array_append_val (priv->animations, anim_data);
card_num++;
}
if (n_anims > 0) {
clutter_timeline_rewind (priv->timeline);
clutter_timeline_start (priv->timeline);
}
priv->n_unexposed_animated_cards = n_unexposed_animated_cards;
clutter_actor_queue_redraw (CLUTTER_ACTOR (srend));
}
static int capi_manufacturer(unsigned int cmd, void *data)
{
unsigned long flags;
avmb1_loadandconfigdef ldef;
avmb1_extcarddef cdef;
avmb1_resetdef rdef;
avmb1_getdef gdef;
avmb1_card *card;
int rc;
switch (cmd) {
case AVMB1_ADDCARD:
case AVMB1_ADDCARD_WITH_TYPE:
if (cmd == AVMB1_ADDCARD) {
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return rc;
cdef.cardtype = AVM_CARDTYPE_B1;
} else {
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_extcarddef))))
return rc;
}
if ((rc = avmb1_probecard(cdef.port, cdef.irq, cdef.cardtype)) != 0)
return rc;
return avmb1_addcard(cdef.port, cdef.irq, cdef.cardtype);
case AVMB1_LOAD:
case AVMB1_LOAD_AND_CONFIG:
if (cmd == AVMB1_LOAD) {
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return rc;
ldef.t4config.len = 0;
ldef.t4config.data = 0;
} else {
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loadandconfigdef))))
return rc;
}
if (!VALID_CARD(ldef.contr))
return -ESRCH;
if (ldef.t4file.len <= 0) {
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: invalid parameter length of t4file is %d ?\n", ldef.t4file.len);
return -EINVAL;
}
card = CARD(ldef.contr);
save_flags(flags);
cli();
if (card->cardstate != CARD_DETECTED) {
restore_flags(flags);
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: reseting contr %d\n",
ldef.contr);
}
B1_reset(card->port);
if ((rc = B1_load_t4file(card->port, &ldef.t4file))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load t4file!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
B1_disable_irq(card->port);
if (ldef.t4config.len > 0) { /* load config */
if (loaddebug) {
printk(KERN_DEBUG "b1capi: loading config to contr %d\n",
ldef.contr);
}
if ((rc = B1_load_config(card->port, &ldef.t4config))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load config!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
}
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: ready contr %d: checking\n",
ldef.contr);
}
if (!B1_loaded(card->port)) {
card->cardstate = CARD_DETECTED;
printk(KERN_ERR "b1capi: failed to load t4file.\n");
return -EIO;
}
/*
* enable interrupt
*/
card->cardstate = CARD_INITSTATE;
save_flags(flags);
cli();
B1_assign_irq(card->port, card->irq, card->cardtype);
B1_enable_irq(card->port);
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: irq enabled contr %d\n",
ldef.contr);
}
/*
* init card
*/
B1_send_init(card->port, AVM_NAPPS, AVM_NNCCI, card->cnr - 1);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: waiting for init reply contr %d\n",
ldef.contr);
}
while (card->cardstate != CARD_RUNNING) {
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((rc = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return rc;
return avmb1_resetcard(rdef.contr);
case AVMB1_GET_CARDINFO:
if ((rc = copy_from_user((void *) &gdef, data,
sizeof(avmb1_getdef))))
return rc;
if (!VALID_CARD(gdef.contr))
return -ESRCH;
card = CARD(gdef.contr);
gdef.cardstate = card->cardstate;
gdef.cardtype = card->cardtype;
if ((rc = copy_to_user(data, (void *) &gdef,
sizeof(avmb1_getdef))))
return rc;
return 0;
}
return -EINVAL;
}
list expand_arc(struct arc_object *arc, multisetPTR p_MS, set *p_S, struct net_object *unf_net)
{
int i, opd, vpd;
list result;
struct arc_object *new_arc;
struct place_object *p=NULL;
char *tag;
opd = atoi(opt_list[OPT_ORIZ_PLACE_DISPLACEMENT].arg_val);
vpd = atoi(opt_list[OPT_VERT_PLACE_DISPLACEMENT].arg_val);
init_list(&result);
for(i=0; i<CARD(p_MS) ; i++)
if( VALUE(SET(p_MS)[i])>0 ){
p =NULL;
tag = NewStringCat(arc->place->tag, STR_INDEX(SET(p_MS)[i]));
if(set_member(p_S, i)==FALSE){
set_insert(p_S, i);
p = create_place(arc->place, tag);
p->center.x += i*opd;
p->center.y += i*vpd;
#if DEBUG_UNFOLD
printf("Add place %s\n\n", p->tag);
#endif
if(unf_net->places != NULL)
p->next = unf_net->places;
unf_net->places = p;
}
if(p==NULL)
p = unf_net->places;
while(p!=NULL && (strcmp(p->tag, tag)!=0))
p = p->next;
if(p==NULL)
Error(UNKN_PLACE_ERR, "expand_arc", tag);
new_arc = (struct arc_object*) Emalloc(sizeof(struct arc_object));
new_arc->type = arc->type;
new_arc->mult = VALUE(SET(p_MS)[i]);
new_arc->place = p;
new_arc->colpos.x = 0;
new_arc->colpos.y = 0;
new_arc->point = arc->point;
new_arc->color = NULL;
new_arc->lisp = NULL;
new_arc->layer = NewLayerList(WHOLENET,NULL);
new_arc->next = NULL;
append(&result, (generic_ptr) new_arc);
}
return(result);
}
/*
* aLeftPlayer: next in turn
* aRightPlayer: prev in turn
* 0, 1th
* 1th, 2nd
*/
Card *AlphaBetaPlayer::makeMove (Card *lMove, Card *rMove, Player *aLeftPlayer, Player *aRightPlayer, bool isPassOut) {
qDebug() << type() << "("<< mPlayerNo << ") moves";
card_t hands[3][10];
card_t desk[3];
int crdLeft = 0;
int trumpSuit = 0;
Player *plst[3];
//again:
plst[0] = plst[1] = plst[2] = 0;
plst[mPlayerNo-1] = this;
plst[aLeftPlayer->number()-1] = aLeftPlayer;
plst[aRightPlayer->number()-1] = aRightPlayer;
// build hands
for (int c = 0; c < 3; c++) {
Q_ASSERT(plst[c]);
CardList *clst = &(plst[c]->mCards);
//for (int f = 0; f < 10; f++) hds[c][f] = hands[c][f] = 0;
int pos = 0;
for (int f = 0; f < clst->size(); f++) {
Card *ct = clst->at(f);
if (!ct) continue;
hands[c][pos++] = CARD(ct->face(), ct->suit()-1);
if (pos > crdLeft) crdLeft = pos;
}
for (int f = pos; f < 10; f++) hands[c][f] = 0;
xsortCards(hands[c], pos);
}
if (!lMove && !rMove && crdLeft == 10) {
return AiPlayer::makeMove(lMove, rMove, aLeftPlayer, aRightPlayer, isPassOut);
}
// find game
const eGameBid bid = m_model->currentGame();
gPassOutOrMisere = (bid == g86 || bid == g86catch || bid == raspass);
trumpSuit = bid%10-1;//(bid-(bid/10)*10)-1;
/*
if (bid == g86catch || bid == g86 || bid == raspass) {
return Player::moveSelectCard(lMove, rMove, aLeftPlayer, aRightPlayer);
}
*/
if (bid == g86catch || bid == g86 || bid == raspass) {
trumpSuit = 4;
}
if (trumpSuit < 0) trumpSuit = 4;
fprintf(stderr, "po:%s; lm:%s, rm:%s\n", isPassOut?"y":"n", lMove?"y":"n", rMove?"y":"n");
if (isPassOut && rMove && !lMove) {
// это распасы, первый или второй круг, первый ход
gPassOutSuit = rMove->suit()-1;
fprintf(stderr, "pass-out: %i\n", gPassOutSuit);
rMove = 0;
} else gPassOutSuit = -1;
// build desk
int turn = 0;
if (lMove) {
desk[turn++] = CARD(lMove->face(), lMove->suit()-1);
if (rMove) desk[turn++] = CARD(rMove->face(), rMove->suit()-1);
} else if (rMove) {
desk[turn++] = CARD(rMove->face(), rMove->suit()-1);
}
// build hands
for (int f = 0; f < 3; f++) {
xHands[f].suitCount[0] = xHands[f].suitCount[1] = xHands[f].suitCount[2] = xHands[f].suitCount[3] = 0;
xHands[f].suitStart[0] = xHands[f].suitStart[1] = xHands[f].suitStart[2] = xHands[f].suitStart[3] = 11;
xHands[f].tricks = plst[f]->tricksTaken();
int st;
for (int z = 0; z < 10; z++) {
if (hands[f][z]) {
xHands[f].faces[z] = FACE(hands[f][z]);
st = xHands[f].suits[z] = SUIT(hands[f][z]);
if (xHands[f].suitCount[st]++ == 0) xHands[f].suitStart[st] = z;
} else xHands[f].faces[z] = 0;
}
}
// build desk
for (int f = 0; f < turn; f++) {
xDeskFaces[f] = FACE(desk[f]);
xDeskSuits[f] = SUIT(desk[f]);
}
int a, b, c, move;
int me = this->number()-1;
xCardsLeft = crdLeft;
gTrumpSuit = trumpSuit;
gIterations = 0;
printf("%shand 0:", this->number()==0?"*":" ");
printHand(&(xHands[0]));
printf("%shand 1:", this->number()==1?"*":" ");
printHand(&(xHands[1]));
printf("%shand 2:", this->number()==2?"*":" ");
printHand(&(xHands[2]));
printDesk(turn);
// оптимизации
/*
if (turn > 0) {
// можем вообще взять?
if (hands[me].suitCount(
}
*/
stTime = QTime::currentTime();
stTime.start();
abcPrune(turn, me, -666, 666, 666, &a, &b, &c, &move);
qDebug() <<
"face:" << FACE(hands[me][move]) <<
"suit:" << SUIT(hands[me][move])+1 <<
"move:" << move <<
"turn:" << turn <<
"moves:" << crdLeft <<
"trump:" << trumpSuit <<
"iters:" << gIterations <<
"";
/*
for (int h = 0; h < 3; h++) {
fprintf(stderr, (h == me)?"*":" ");
fprintf(stderr, "hand %i:", h);
for (int f = 0; f < 10; f++) {
if (hands[h][f]) {
fprintf(stderr, " %2i.%i(%3i)", FACE(hands[h][f]), SUIT(hands[h][f]), hands[h][f]);
} else {
fprintf(stderr, " %2i.%i(%3i)", 0, 0, hands[h][f]);
}
}
fprintf(stderr, "\n");
}
fprintf(stderr, "desk:");
for (int f = 0; f < turn; f++) {
fprintf(stderr, " %2i.%i(%3i)", FACE(desk[f]), SUIT(desk[f]), desk[f]);
}
fprintf(stderr, "\n");
*/
Q_ASSERT(move >= 0);
Card *moveCard = getCard(FACE(hands[me][move]), SUIT(hands[me][move])+1);
qDebug() << "move:" << moveCard->toString();
mCards.remove(moveCard);
mCardsOut.insert(moveCard);
return moveCard;
}
