int Dictionary::get_int(char *key) {
NMString strkey(key);
for(Iterator i = start(); i.has_val(); i.next()) {
KeyValue kv = i.val();
if(kv.first == strkey) {
return atoi(kv.second.text);
}
}
return 0;
}
bool Dictionary::get_string(char *key, char *buff, int buffsize) {
NMString strkey(key);
for(Iterator i = start(); i.has_val(); i.next()) {
KeyValue kv = i.val();
if(kv.first == strkey) {
mir_snprintf(buff, buffsize, "%s", kv.second.text);
return true;
}
}
return false;
}
/*
* Delete a specified keyword from a string if it appears there
*/
void
strcut(char *src, const char *key)
{
char *s, *d;
if ((s = strkey(src, key)) != 0) {
d = s + strlen(key);
while (*d != '\0' && !LETTER(*d))
d++;
while ((*s++ = *d++) != '\0') ;
}
}
unsigned long
csport(register Cs_t* state, const char* type, const char* serv)
{
unsigned long n;
char* t;
if (streq(serv, "reserved"))
return CS_PORT_RESERVED;
if (streq(serv, "normal"))
return CS_PORT_NORMAL;
n = strtol(serv, &t, 0);
if (t > serv && *t == '.')
strtol(t + 1, &t, 0);
if (*t)
{
if (strneq(serv, CS_SVC_INET, sizeof(CS_SVC_INET) - 1))
{
serv += sizeof(CS_SVC_INET) - 1;
#if CS_LIB_SOCKET || CS_LIB_V10
{
struct servent* sp;
#if CS_LIB_V10
if (sp = in_service(serv, type, 0))
return sp->port;
#endif
#if CS_LIB_SOCKET
if (sp = getservbyname(serv, type))
return ntohs(sp->s_port);
#endif
}
#endif
switch (strkey(serv))
{
case HASHKEY6('t','c','p','m','u','x'):
return 1;
case HASHKEY4('e','c','h','o'):
return 7;
case HASHKEY6('d','i','s','c','a','r'):
return 9;
case HASHKEY6('s','y','s','t','a','t'):
return 11;
case HASHKEY6('d','a','y','t','i','m'):
return 13;
case HASHKEY6('n','e','t','s','t','a'):
return 15;
case HASHKEY4('q','o','t','d'):
return 17;
case HASHKEY6('c','h','a','r','g','e'):
return 19;
case HASHKEY3('f','t','p'):
return 21;
case HASHKEY6('t','e','l','n','e','t'):
return 23;
case HASHKEY4('s','m','t','p'):
return 25;
case HASHKEY4('t','i','m','e'):
return 37;
case HASHKEY3('r','l','p'):
return 39;
case HASHKEY4('n','a','m','e'):
return 42;
case HASHKEY5('w','h','o','i','s'):
return 43;
case HASHKEY6('d','o','m','a','i','n'):
return 53;
case HASHKEY3('m','t','p'):
return 57;
case HASHKEY5('b','o','o','t','p'):
return 67;
case HASHKEY6('b','o','o','t','p','c'):
return 68;
case HASHKEY4('t','f','t','p'):
return 69;
case HASHKEY6('g','o','p','h','e','r'):
return 70;
case HASHKEY3('r','j','e'):
return 77;
case HASHKEY6('f','i','n','g','e','r'):
return 79;
case HASHKEY4('h','t','t','p'):
return 80;
case HASHKEY4('l','i','n','k'):
return 87;
case HASHKEY6('s','u','p','d','u','p'):
return 95;
case HASHKEY6('h','o','s','t','n','a'):
return 101;
case HASHKEY4('x',HASHKEYN('4'),HASHKEYN('0'),HASHKEYN('0')):
return 103;
case HASHKEY6('s','u','n','r','p','c'):
return 111;
case HASHKEY4('a','u','t','h'):
return 113;
case HASHKEY4('s','f','t','p'):
return 115;
case HASHKEY4('n','n','t','p'):
return 119;
case HASHKEY4('e','r','p','c'):
return 121;
case HASHKEY3('n','t','p'):
return 123;
case HASHKEY4('i','m','a','p'):
return 143;
case HASHKEY4('s','n','m','p'):
return 161;
case HASHKEY5('p','r','o','x','y'):
return 402;
case HASHKEY3('a','t','x'):
if (access("/etc/in.atxd", F_OK))
break;
return 512;
case HASHKEY4('b','i','f','f'):
return 512;
case HASHKEY4('e','x','e','c'):
return 512;
case HASHKEY5('l','o','g','i','n'):
return 513;
case HASHKEY3('w','h','o'):
return 513;
case HASHKEY5('s','h','e','l','l'):
return 514;
case HASHKEY6('s','y','s','l','o','g'):
return 514;
case HASHKEY6('p','r','i','n','t','e'):
return 515;
case HASHKEY4('t','a','l','k'):
return 517;
case HASHKEY5('n','t','a','l','k'):
return 518;
case HASHKEY5('r','o','u','t','e'):
return 520;
case HASHKEY5('t','i','m','e','d'):
return 525;
case HASHKEY5('t','e','m','p','o'):
return 526;
case HASHKEY4('u','u','c','p'):
return 540;
}
}
return CS_PORT_INVALID;
}
return n;
}
/*
* Get OS name, version & architecture we're running on
*/
void platform(state *st)
{
#ifdef HAVE_UNAME
#if defined(_AIX) || defined(__linux) || defined(__APPLE__)
FILE *fp;
#endif
#if defined(__arm__) || defined(__mips__) || defined(__APPLE__)
char buf[BUFSIZE];
#endif
#ifdef __linux
struct stat file;
#endif
struct utsname name;
char sysname[64];
char release[64];
char machine[64];
char *c;
/* Fetch system information */
uname(&name);
strclear(sysname);
strclear(release);
strclear(machine);
/* AIX-specific */
#ifdef _AIX
/* Fix uname() results */
sstrlcpy(machine, "powerpc");
snprintf(release, sizeof(release), "%s.%s",
name.version,
name.release);
/* Get CPU type */
if ((fp = popen("/usr/sbin/getsystype -i", "r"))) {
fgets(machine, sizeof(machine), fp);
pclose(fp);
strreplace(machine, ' ', '_');
}
/* Get hardware name using shell uname */
if (!*st->server_description &&
(fp = popen("/usr/bin/uname -M", "r"))) {
fgets(st->server_description,
sizeof(st->server_description), fp);
pclose(fp);
strreplace(st->server_description, ',', ' ');
chomp(st->server_description);
}
#endif
/* Mac OS X, just like Unix but totally different... */
#ifdef __APPLE__
/* Hardcode OS name */
sstrlcpy(sysname, "MacOSX");
/* Get OS X version */
if ((fp = popen("/usr/bin/sw_vers -productVersion", "r"))) {
fgets(release, sizeof(release), fp);
pclose(fp);
}
/* Get hardware name */
if (!*st->server_description &&
(fp = popen("/usr/sbin/sysctl -n hw.model", "r"))) {
/* Read hardware name */
fgets(buf, sizeof(buf), fp);
pclose(fp);
/* Clones are gone now so we'll hardcode the manufacturer */
sstrlcpy(st->server_description, "Apple ");
sstrlcat(st->server_description, buf);
/* Remove hardware revision */
for (c = st->server_description; *c; c++)
if (*c >= '0' && *c <= '9') { *c = '\0'; break; }
}
#endif
/* Linux uname() just says Linux/2.6 - let's dig deeper... */
#ifdef __linux
/* Most Linux ARM/MIPS boards have hardware name in /proc/cpuinfo */
#if defined(__arm__) || defined(__mips__)
if (!*st->server_description && (fp = fopen("/proc/cpuinfo" , "r"))) {
while (fgets(buf, sizeof(buf), fp)) {
#ifdef __arm__
if ((c = strkey(buf, "Hardware"))) {
#else
if ((c = strkey(buf, "machine"))) {
#endif
sstrlcpy(st->server_description, c);
chomp(st->server_description);
break;
}
}
fclose(fp);
}
#endif
/* Identify RedHat */
if (!*sysname && (fp = fopen("/etc/redhat-release", "r"))) {
fgets(sysname, sizeof(sysname), fp);
fclose(fp);
if ((c = strstr(sysname, "release "))) sstrlcpy(release, c + 8);
if ((c = strchr(release, ' '))) *c = '\0';
if ((c = strchr(sysname, ' '))) *c = '\0';
if (strcmp(sysname, "Red") == MATCH) sstrlcpy(sysname, "RedHat");
}
/* Identify Slackware */
if (!*sysname && (fp = fopen("/etc/slackware-version", "r"))) {
fgets(sysname, sizeof(sysname), fp);
fclose(fp);
if ((c = strchr(sysname, ' '))) {
sstrlcpy(release, c + 1);
*c = '\0';
}
}
/* Uh-oh.... how about a standard Linux with lsb_release? */
if (stat("/usr/bin/lsb_release", &file) == OK && (file.st_mode & S_IXOTH)) {
if (!*sysname && (fp = popen("/usr/bin/lsb_release -i -s", "r"))) {
fgets(sysname, sizeof(sysname), fp);
pclose(fp);
}
if (!*release && (fp = popen("/usr/bin/lsb_release -r -s", "r"))) {
fgets(release, sizeof(release), fp);
pclose(fp);
}
}
/* OK, nothing worked - let's try /etc/issue for sysname */
if (!*sysname && (fp = fopen("/etc/issue", "r"))) {
fgets(sysname, sizeof(sysname), fp);
fclose(fp);
if ((c = strchr(sysname, ' '))) *c = '\0';
if ((c = strchr(sysname, '\\'))) *c = '\0';
}
/* Debian version should be in /etc/debian_version */
if (!*release && (fp = fopen("/etc/debian_version", "r"))) {
fgets (release, sizeof(release), fp);
fclose(fp);
if ((c = strchr(release, '/'))) *c = '\0';
}
#endif
/* Haiku OS */
#ifdef __HAIKU__
/* Fix release name */
snprintf(release, sizeof(release), "R%s", name.release);
#endif
/* Fill in the blanks using uname() data */
if (!*sysname) sstrlcpy(sysname, name.sysname);
if (!*release) sstrlcpy(release, name.release);
if (!*machine) sstrlcpy(machine, name.machine);
/* I always liked weird Perl-only functions */
chomp(sysname);
chomp(release);
chomp(machine);
/* We're only interested in major.minor version */
if ((c = strchr(release, '.'))) if ((c = strchr(c + 1, '.'))) *c = '\0';
if ((c = strchr(release, '-'))) *c = '\0';
if ((c = strchr(release, '/'))) *c = '\0';
/* Create a nicely formatted platform string */
snprintf(st->server_platform, sizeof(st->server_platform), "%s/%s %s",
sysname,
#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__)
machine,
release);
#else
release,
machine);
#endif
/* Debug */
if (st->debug) {
syslog(LOG_INFO, "generated platform string \"%s\"",
st->server_platform);
}
#else
/* Fallback reply */
sstrlcpy(st->server_platform, "Unknown computer-like system");
#endif
}
/*
* Return current CPU load
*/
float loadavg(void)
{
FILE *fp;
char buf[BUFSIZE];
/* Faster Linux version */
#ifdef __linux
buf[0] = '\0';
if ((fp = fopen("/proc/loadavg" , "r")) == NULL) return 0;
fgets(buf, sizeof(buf), fp);
fclose(fp);
return (float) atof(buf);
/* Generic slow version - parse the output of uptime */
#else
#ifdef HAVE_POPEN
char *c;
if ((fp = popen("/usr/bin/uptime", "r"))) {
fgets(buf, sizeof(buf), fp);
pclose(fp);
if ((c = strstr(buf, "average: ")) || (c = strstr(buf, "averages: ")))
return (float) atof(c + 10);
}
#endif
/* Fallback reply */
return 0;
#endif
}
bool Session::initialize()
{
// Get URN's wich are supported by this addon
if (!license_type_.empty())
GetSupportedDecrypterURN(dashtree_.adp_pssh_);
// Open mpd file
const char* delim(strrchr(mpdFileURL_.c_str(), '/'));
if (!delim)
{
xbmc->Log(ADDON::LOG_ERROR, "Invalid mpdURL: / expected (%s)", mpdFileURL_.c_str());
return false;
}
dashtree_.base_url_ = std::string(mpdFileURL_.c_str(), (delim - mpdFileURL_.c_str()) + 1);
if (!dashtree_.open(mpdFileURL_.c_str()) || dashtree_.empty())
{
xbmc->Log(ADDON::LOG_ERROR, "Could not open / parse mpdURL (%s)", mpdFileURL_.c_str());
return false;
}
xbmc->Log(ADDON::LOG_INFO, "Successfully parsed .mpd file. Download speed: %0.4f Bytes/s", dashtree_.download_speed_);
if (dashtree_.encryptionState_ == dash::DASHTree::ENCRYTIONSTATE_ENCRYPTED)
{
xbmc->Log(ADDON::LOG_ERROR, "Unable to handle decryption. Unsupported!");
return false;
}
uint32_t min_bandwidth(0), max_bandwidth(0);
{
int buf;
xbmc->GetSetting("MINBANDWIDTH", (char*)&buf); min_bandwidth = buf;
xbmc->GetSetting("MAXBANDWIDTH", (char*)&buf); max_bandwidth = buf;
}
// create SESSION::STREAM objects. One for each AdaptationSet
unsigned int i(0);
const dash::DASHTree::AdaptationSet *adp;
for (std::vector<STREAM*>::iterator b(streams_.begin()), e(streams_.end()); b != e; ++b)
SAFE_DELETE(*b);
streams_.clear();
while ((adp = dashtree_.GetAdaptationSet(i++)))
{
streams_.push_back(new STREAM(dashtree_, adp->type_));
STREAM &stream(*streams_.back());
stream.stream_.prepare_stream(adp, width_, height_, min_bandwidth, max_bandwidth);
const dash::DASHTree::Representation *rep(stream.stream_.getRepresentation());
stream.info_.m_Width = rep->width_;
stream.info_.m_Height = rep->height_;
stream.info_.m_Aspect = rep->aspect_;
stream.info_.m_pID = i;
switch (adp->type_)
{
case dash::DASHTree::VIDEO:
stream.info_.m_streamType = INPUTSTREAM_INFO::TYPE_VIDEO;
break;
case dash::DASHTree::AUDIO:
stream.info_.m_streamType = INPUTSTREAM_INFO::TYPE_AUDIO;
break;
case dash::DASHTree::TEXT:
stream.info_.m_streamType = INPUTSTREAM_INFO::TYPE_TELETEXT;
break;
default:
break;
}
// we currently use only the first track!
std::string::size_type pos = rep->codecs_.find(",");
if (pos == std::string::npos)
pos = rep->codecs_.size();
strncpy(stream.info_.m_codecInternalName, rep->codecs_.c_str(), pos);
stream.info_.m_codecInternalName[pos] = 0;
if (rep->codecs_.find("mp4a") == 0)
strcpy(stream.info_.m_codecName, "aac");
else if (rep->codecs_.find("ec-3") == 0 || rep->codecs_.find("ac-3") == 0)
strcpy(stream.info_.m_codecName, "eac3");
else if (rep->codecs_.find("avc") == 0)
strcpy(stream.info_.m_codecName, "h264");
else if (rep->codecs_.find("hevc") == 0)
strcpy(stream.info_.m_codecName, "hevc");
stream.info_.m_FpsRate = rep->fpsRate_;
stream.info_.m_FpsScale = rep->fpsScale_;
stream.info_.m_SampleRate = rep->samplingRate_;
stream.info_.m_Channels = rep->channelCount_;
stream.info_.m_Bandwidth = rep->bandwidth_;
strcpy(stream.info_.m_language, adp->language_.c_str());
}
// Try to initialize an SingleSampleDecryptor
if (dashtree_.encryptionState_)
{
AP4_DataBuffer init_data;
if (dashtree_.adp_pssh_.second == "FILE")
{
std::string strkey(dashtree_.adp_pssh_.first.substr(9));
while (size_t pos = strkey.find('-') != std::string::npos)
strkey.erase(pos, 1);
if (strkey.size() != 32)
{
xbmc->Log(ADDON::LOG_ERROR, "Key system mismatch (%s)!", dashtree_.adp_pssh_.first.c_str());
return false;
}
unsigned char key_system[16];
AP4_ParseHex(strkey.c_str(), key_system, 16);
Session::STREAM *stream(streams_[0]);
stream->enabled = true;
stream->stream_.start_stream(0);
stream->stream_.select_stream(true);
stream->input_ = new AP4_DASHStream(&stream->stream_);
stream->input_file_ = new AP4_File(*stream->input_, AP4_DefaultAtomFactory::Instance, true);
AP4_Movie* movie = stream->input_file_->GetMovie();
if (movie == NULL)
{
xbmc->Log(ADDON::LOG_ERROR, "No MOOV in stream!");
stream->disable();
return false;
}
AP4_Array<AP4_PsshAtom*>& pssh = movie->GetPsshAtoms();
for (unsigned int i = 0; !init_data.GetDataSize() && i < pssh.ItemCount(); i++)
{
if (memcmp(pssh[i]->GetSystemId(), key_system, 16) == 0)
init_data.AppendData(pssh[i]->GetData().GetData(), pssh[i]->GetData().GetDataSize());
}
if (!init_data.GetDataSize())
{
xbmc->Log(ADDON::LOG_ERROR, "Could not extract license from video stream (PSSH not found)");
stream->disable();
return false;
}
stream->disable();
}
else
{
init_data.SetBufferSize(1024);
unsigned int init_data_size(1024);
b64_decode(dashtree_.pssh_.second.data(), dashtree_.pssh_.second.size(), init_data.UseData(), init_data_size);
init_data.SetDataSize(init_data_size);
}
return (single_sample_decryptor_ = CreateSingleSampleDecrypter(init_data))!=0;
}
return true;
}
int
buraco_interpret_game(struct ROOM *room, char *buf, int *who, int *newcard, int *garbage)
{
struct USER_idx *uidx;
struct ROOM_idx *ridx;
char *gameargs[4];
int i, x, card;
char ret[SZ_STRING_MAX];
ridx = NULL;
ridx = buraco_mem_get_room(room->roomid);
if (!ridx)
return -1;
uidx = NULL;
uidx = buraco_mem_get_user(ridx->users[*who]);
if (!uidx)
return -1;
gameargs[0] = (char *)strkey(buf, 0, ' '); gameargs[1] = (char *)strkey(buf, 1, ' ');
gameargs[2] = (char *)strkey(buf, 2, ' '); gameargs[3] = (char *)strkey(buf, 3, ' ');
if (gameargs[0])
{
if (!strncmp("USERCARD", gameargs[0], strlen(gameargs[0])))
{
buraco_show_cards_to_user(uidx->userid, room);
}
else if (*newcard==0 && !strncmp("GETNCARD", gameargs[0], strlen(gameargs[0])))
{
if (gameargs[1])
{
i = atoi(gameargs[1]);
if (i) // TABLE CARD
{
card = buraco_get_table_card(room, uidx->userid);
snprintf(ret, sizeof(ret)-1, "*GAME* you got a new card *%s*\n\0", BARALHO[card]);
}
else // LIXO
{
buraco_get_garbage_card(room, uidx->userid);
snprintf(ret, sizeof(ret)-1, "*GAME* you got new cards\n\0");
//++*garbage;
}
send(uidx->userid, ret, strlen(ret), 0);
++*newcard;
}
else
{
snprintf(ret, sizeof(ret)-1, "*ERROR* command *GETNCARD* had too few arguments. (eg.: GETNCARD 1)\n\0");
send(uidx->userid, ret, strlen(ret), 0);
}
}
else if (!strncmp("MOVEHAND", gameargs[0], strlen(gameargs[0])))
{
if (gameargs[2])
{
x = atoi(gameargs[2]);
if (ridx->users[0]==uidx->userid || ridx->users[2]==uidx->userid)
i=0;
else if (ridx->users[1]==uidx->userid || ridx->users[3]==uidx->userid)
i=1;
buraco_move_cards_to_group(room, uidx->userid, gameargs[1], i, x);
}
else
{
snprintf(ret, sizeof(ret)-1, "*ERROR* MOVEHAND: too few arguments. (eg.: MOVEHAND 8h,Tc,KD 1)\n\0");
send(uidx->userid, ret, strlen(ret), 0);
}
}
else if (*newcard!=0 && !strncmp("LEFTCARD", gameargs[0], strlen(gameargs[0])))
{
if (gameargs[1])
{
if (buraco_discard_to_garbage(room, uidx->userid, gameargs[1]) != -1)
{
snprintf(ret, sizeof(ret)-1, "*GAME ROOM* user *%s* move card(s) *%s* to garbage.\n\n", uidx->nick, gameargs[1]);
buraco_message_to_room(uidx->roomid, ret);
++*who;
if (ridx->players==2 && *who==2)
*who = 0;
else if (ridx->players==4 && *who==4)
*who = 0;
*newcard = 0; *garbage = 0;
}
else
{
snprintf(ret, sizeof(ret)-1, "*ERROR* you dont have this card *%s*\n", gameargs[1]);
send(uidx->roomid, ret, strlen(ret), 0);
}
}
}
else
{
buraco_interpret(uidx->userid, buf);
}
fprintf(stdout, "*GAME ROOM* id *%d* user *%s* inGame:%d sends command *%s*\n\0", room->roomid, uidx->nick, uidx->inGame, buf);
}
else
fprintf(stdout, "*GAME ROOM* id *%d* COMMAND ERROR..\n\0", room->roomid);
return 0;
}
int
buraco_move_cards_to_group(struct ROOM *table, int userid, char *rcards, int group, int game_cards)
{
struct CARDS *cardsidx, *t;
struct USER_idx *uidx;
int aces, joker;
int i, x, j, card, exists, verify;
char *cards[SZ_NAIPE];
char gcards[SZ_STRING_MID], ret[SZ_STRING_MAX];
fprintf(stdout, "buraco_move_cards_to_group() init group:%d\n");
if (!rcards)
return -1;
exists = 0; card = 0; i = 0; x = 0;
cards[0] = (char *)strkey(rcards, 0, ','); cards[1] = (char *)strkey(rcards, 1, ',');
cards[2] = (char *)strkey(rcards, 2, ','); cards[3] = (char *)strkey(rcards, 3, ',');
cards[4] = (char *)strkey(rcards, 4, ','); cards[5] = (char *)strkey(rcards, 5, ',');
cards[6] = (char *)strkey(rcards, 6, ','); cards[7] = (char *)strkey(rcards, 7, ',');
cards[8] = (char *)strkey(rcards, 8, ','); cards[9] = (char *)strkey(rcards, 9, ',');
cards[10] = (char *)strkey(rcards, 10, ','); cards[11] = (char *)strkey(rcards, 11, ',');
cards[12] = (char *)strkey(rcards, 12, ','); cards[13] = (char *)strkey(rcards, 13, ',');
cards[14] = (char *)strkey(rcards, 14, ','); cards[15] = (char *)strkey(rcards, 15, ',');
// Algo
//
// Process cards
// Count one per one
// Verify if they had the same suit
// Update Points
// Move cards
//
// REMOVE CARD FROM USER
verify = 0; verify = tolower(cards[0][1]);
cardsidx = NULL;
cardsidx = buraco_mem_get_gcards(table->roomid, group, game_cards);
if (cardsidx==NULL)
{
buraco_mem_add_gcards(table->roomid, group, game_cards); usleep(9);
if (!cards[2])
{
snprintf(ret, sizeof(ret)-1, "*ERROR* You need to move at least three cards of your hand.\n\0");
send(userid, ret, strlen(ret), 0);
return -1;
}
cardsidx = NULL;
cardsidx = buraco_mem_get_gcards(table->roomid, group, game_cards);
if (cardsidx)
cardsidx->suit = verify;
}
else
{
if (cardsidx->id == game_cards)
exists++;
}
t = cfst;
while (t)
{
fprintf(stdout, "\033[1mcards--debug: roomid:%d->%d group:%d->%d id:%d->%d suit:%.3d:%c\n\033[m", t->roomid, table->roomid, t->group, group, t->id, game_cards, t->suit, t->suit);
t = t->next;
}
i = 0; aces = 0; joker = 0;
while (cards[i] != NULL && cards[i][0]!=0)
{
verify = 0;
verify = tolower((int)cards[i][1]);
if (cards[i][0] == 'A')
aces++;
if (cards[i][0] == '2' || cards[i][0] == 'c' || cards[i][0] == 'C')
{
fprintf(stdout, "2 ou coringa na area\n");
joker++;
}
if (cardsidx->suit != verify)
{
if (!joker)
{
buraco_mem_del_gcards(table->roomid, group, game_cards);
snprintf(ret, sizeof(ret)-1, "*ERROR* These cards doesn't have the same suit.\n\0");
send(userid, ret, strlen(ret), 0);
return -1;
}
}
if (buraco_verify_user_card(table, userid, cards[i]) != 0)
{
buraco_mem_del_gcards(table->roomid, group, game_cards);
snprintf(ret, sizeof(ret)-1, "*ERROR* You don't have this card *%s*.\n\0", cards[i]);
send(userid, ret, strlen(ret), 0);
return -1;
}
i++;
}
if (joker>=3 || aces>=2)
{
buraco_mem_del_gcards(table->roomid, group, game_cards);
snprintf(ret, sizeof(ret)-1, "*ERROR* Too many 'joker' cards in game.\n\0");
send(userid, ret, strlen(ret), 0);
return -1;
}
fprintf(stdout, "buraco_move_cards_to_group() ...1\n");
i = 0;
while (cards[i]!=NULL && cards[i][0]!=0)
{
x = -1;
if (cards[i][0] == 'A')
{
if (cardsidx->cards[13] == -1 && cardsidx->cards[12] != -1)
x=13;
else if (cardsidx->cards[0] == -1)
x=0;
}
else if ((cards[i][0] == '2' || cards[i][0] == 'c' || cards[i][0] == 'C') && joker!=0)
x=14;
if (x==-1)
x = buraco_return_pos_gcard(cards[i][0]);
fprintf(stdout, "buraco_move_cards_to_group() ...111111\n");
if (!cards[1])
{
fprintf(stdout, "APENAS UMAAAAAAAAAAAAAAA x-1:%d x+1:%d\n", cardsidx->cards[x-1], cardsidx->cards[x+1]);
if (x==0 && cardsidx->cards[1] != -1)
return -1;
else if (cardsidx->cards[x-1] == -1 && cardsidx->cards[x+1] == -1 && x!=14)
return -1;
else if (x==13 && cardsidx->cards[x-1] != -1)
return -1;
fprintf(stdout, "buraco_move_cards_to_group() ...1222222 x:%d cardsidx->cards[x]:%d\n", x, cardsidx->cards[x]);
if (cardsidx->cards[x]!=-1 && (cardsidx->cards[x]=='2' || cardsidx->cards[x]=='c' || cardsidx->cards[x]=='C'))
{
fprintf(stdout, "cardsidx->cards[%d] = %d", x , cardsidx->cards[x]);
if (cardsidx->cards[13]==-1)
for (j=x; cardsidx->cards[j]!=-1; j++);
else
for (j=x; cardsidx->cards[j]!=-1; j--);
fprintf(stdout, "cardsidx->cards[%d] = %d", j, cardsidx->cards[x]);
cardsidx->cards[j] = cardsidx->cards[x];
}
else if (cardsidx->cards[x]!=-1)
{
fprintf(stdout, "cardsidx->cards[%d] = %d", x , cardsidx->cards[x]);
if (cardsidx->cards[13]==-1)
for (j=x; cardsidx->cards[j]!=-1; j++);
else
for (j=x; cardsidx->cards[j]!=-1; j--);
fprintf(stdout, "cardsidx->cards[%d] = %d", j, cardsidx->cards[x]);
cardsidx->cards[j] = cardsidx->cards[x];
}
fprintf(stdout, "buraco_move_cards_to_group() ...133333\n");
}
card = buraco_get_card_value(table, cards[i]);
cardsidx->cards[x] = table->in_game.baralho[card];
i++;
}
fprintf(stdout, "buraco_move_cards_to_group() ...2\n");
x=0; verify = 0; j=0;
for (i=0;i<SZ_NAIPE;i++)
{
if (x>2)
verify++;
if (!x)
{
if (cardsidx->cards[i] != -1)
x++;
}
else
{
if (cardsidx->cards[i] != -1)
x++;
else if (cardsidx->cards[i] == -1 && joker>0)
{ x++; j=i; joker--; }
else
x=0;
}
}
fprintf(stdout, "buraco_move_cards_to_group() ...3 ... verify:%d j:%d\n", verify, j);
if (!verify)
{
buraco_mem_del_gcards(table->roomid, group, game_cards);
t = cfst;
while (t)
{
fprintf(stdout, "\033[1mcards--debug: roomid:%d->%d group:%d->%d id:%d->%d suit:%.3d:%c\n\033[m", t->roomid, table->roomid, t->group, group, t->id, game_cards, t->suit, t->suit);
t = t->next;
}
snprintf(ret, sizeof(ret)-1, "*ERROR* Not a sequential cards..\n\0");
send(userid, ret, strlen(ret), 0);
return -1;
}
fprintf(stdout, "buraco_move_cards_to_group() ...4\n");
if (j>=0 && j<=SZ_NAIPE)
{
if (cardsidx->cards[1]==-1 && cardsidx->cards[2]!=-1 && strncmp((char*)&cardsidx->cards[14], "2", 1)==0)
cardsidx->cards[1] = cardsidx->cards[14];
else
cardsidx->cards[j] = cardsidx->cards[14];
cardsidx->cards[14] = -1;
}
fprintf(stdout, "buraco_move_cards_to_group() ...5\n");
i=0;
while (cards[i])
{
buraco_remove_card_from_user(table, userid, cards[i]);
i++;
}
for (i=0;i<(int)strlen(gcards);i++)
gcards[i] = '\0';
fprintf(stdout, "buraco_move_cards_to_group() ...6 strlen(gcards):%d\n", strlen(gcards));
//FIXME
//buraco_count_points_of_cards(table, rcards);
//
uidx = buraco_mem_get_user(userid);
if (uidx)
{
for (i=0; i<SZ_NAIPE; i++)
{
card = 0;
if (cardsidx->cards[i] != -1)
{
card = cardsidx->cards[i];
if (!strlen(gcards))
strcpy(gcards, BARALHO[card]);
else
{
snprintf(ret, sizeof(ret)-1, ",%s\0", BARALHO[card]);
strcat(gcards, ret);
}
}
}
if (exists)
snprintf(ret, sizeof(ret)-1, "*GAME ROOM* user *%s* added cards *%s* to group *%d*\n\0", uidx->nick, gcards, cardsidx->id);
else
snprintf(ret, sizeof(ret)-1, "*GAME ROOM* user *%s* make a new group of cards *%s*\n\0", uidx->nick, gcards);
buraco_message_to_room(table->roomid, ret);
}
/*
x = 0;
for (i=0; i<SZ_NAIPE; i++)
{
card = 0;
if (cardsidx->cards[i] != -1)
{
card = cardsidx->cards[i];
gcards[x] = BARALHO[card];
x++;
}
}
snprintf(ret, sizeof(ret)-1, "*GAME ROOM* user *%s* make a new group of cards *%s\0", uidx->nick);
buraco_message_to_room(table->roomid, ret);
*/
fprintf(stdout, "buraco_move_cards_to_group() END\n");
return 0;
}
