struct slName *randomBamIds(char *table, struct sqlConnection *conn, int count)
/* Return some semi-random qName based IDs from a BAM file. */
{
/* Read 10000 items from bam file, or if they ask for a big list, then 4x what they ask for. */
char *fileName = bamFileName(table, conn, NULL);
samfile_t *fh = bamOpen(fileName, NULL);
struct lm *lm = lmInit(0);
int orderedCount = count * 4;
if (orderedCount < 10000)
orderedCount = 10000;
struct samAlignment *sam, *samList = bamReadNextSamAlignments(fh, orderedCount, lm);
/* Shuffle list and extract qNames from first count of them. */
shuffleList(&samList);
struct slName *randomIdList = NULL;
int i;
for (i=0, sam = samList; i<count && sam != NULL; ++i, sam = sam->next)
slNameAddHead(&randomIdList, sam->qName);
/* Clean up and go home. */
lmCleanup(&lm);
bamClose(&fh);
freez(&fileName);
return randomIdList;
}
struct slName *randomBigBedIds(char *table, struct sqlConnection *conn, int count)
/* Return some arbitrary IDs from a bigBed file. */
{
/* Figure out bigBed file name and open it. Get contents for first chromosome as an example. */
struct slName *idList = NULL;
char *fileName = bigBedFileName(table, conn);
struct bbiFile *bbi = bigBedFileOpen(fileName);
struct bbiChromInfo *chromList = bbiChromList(bbi);
struct lm *lm = lmInit(0);
int orderedCount = count * 4;
if (orderedCount < 100)
orderedCount = 100;
struct bigBedInterval *iv, *ivList = getNElements(bbi, chromList, lm, orderedCount);
shuffleList(&ivList);
// Make a list of item names from intervals.
int outCount = 0;
for (iv = ivList; iv != NULL && outCount < count; iv = iv->next)
{
char *row[bbi->fieldCount];
char startBuf[16], endBuf[16];
bigBedIntervalToRow(iv, chromList->name, startBuf, endBuf, row, bbi->fieldCount);
if (idList == NULL || differentString(row[3], idList->name))
{
slAddHead(&idList, slNameNew(row[3]));
outCount++;
}
}
lmCleanup(&lm);
bbiFileClose(&bbi);
freeMem(fileName);
return idList;
}
void shuffleLines(char *in, char *out)
/* shuffleLines - Create a version of file with lines shuffled.. */
{
struct lineFile *lf = lineFileOpen(in, TRUE);
FILE *f = mustOpen(out, "w");
struct slName *list = NULL, *el;
char *line;
while (lineFileNext(lf, &line, NULL))
slNameAddHead(&list, line);
shuffleList(&list);
for (el = list; el != NULL; el = el->next)
fprintf(f, "%s\n", el->name);
carefulClose(&f);
}
void *slListRandomSample(void *list, int maxCount)
/* Return a sublist of list with at most maxCount. Destroy list in process */
{
if (list == NULL)
return list;
int initialCount = slCount(list);
if (initialCount <= maxCount)
return list;
double reduceRatio = (double)maxCount/initialCount;
if (reduceRatio < 0.9)
{
double conservativeReduceRatio = reduceRatio * 1.05;
list = slListRandomReduce(list, conservativeReduceRatio);
}
int midCount = slCount(list);
if (midCount <= maxCount)
return list;
shuffleList(list);
struct slList *lastEl = slElementFromIx(list, maxCount-1);
lastEl->next = NULL;
return list;
}
struct slName *randomVcfIds(char *table, struct sqlConnection *conn, int count, boolean isTabix)
/* Return some semi-random IDs from a VCF file. */
{
/* Read 10000 items from vcf file, or if they ask for a big list, then 4x what they ask for. */
struct trackDb *tdb = hashFindVal(fullTableToTdbHash, table);
char *fileName = vcfFileName(tdb, conn, table, hDefaultChrom(database));
struct lineFile *lf = isTabix ? lineFileTabixMayOpen(fileName, TRUE) :
lineFileMayOpen(fileName, TRUE);
if (lf == NULL)
noWarnAbort();
int orderedCount = count * 4;
if (orderedCount < 100)
orderedCount = 100;
struct slName *idList = NULL;
char *words[4];
int i;
for (i = 0; i < orderedCount && lineFileChop(lf, words); i++)
{
// compress runs of identical ID, in case most are placeholder
if (i == 0 || !sameString(words[2], idList->name))
slAddHead(&idList, slNameNew(words[2]));
}
lineFileClose(&lf);
/* Shuffle list and trim it to count if necessary. */
shuffleList(&idList);
struct slName *sl;
for (sl = idList, i = 0; sl != NULL; sl = sl->next, i++)
{
if (i+1 >= count)
{
slNameFreeList(&(sl->next));
break;
}
}
freez(&fileName);
return idList;
}
void outputPicks(struct scoredWindow *winList, char *database,
struct hash *chromLimitHash, struct stats *stats, FILE *f)
/* Output picked regions. */
{
struct scoredWindow *strata[strataCount][strataCount];
double geneCuts[strataCount], consCuts[strataCount];
struct scoredWindow *win, *next;
int geneIx, consIx, pickIx;
FILE *html = NULL;
struct region *avoidList = NULL, *avoid;
/* Get list of regions to avoid */
if (avoidFile != NULL)
avoidList = loadRegionFile(database, avoidFile);
if (htmlOutput != NULL)
{
html = mustOpen(htmlOutput, "w");
htmStart(html, "Random Regions for 1% Project");
}
fprintf(f, "Cuts at:\n");
calcCuts(stats->consCounts, histSize,
stats->totalConsCount, 1.0, consCuts, strataCount);
uglyf("cons %f %f %f\n", consCuts[0], consCuts[1], consCuts[2]);
fprintf(f, "cons %f %f %f\n", consCuts[0], consCuts[1], consCuts[2]);
calcCuts(stats->geneCounts, histSize,
stats->totalGeneCount, 1.0/geneScale, geneCuts, strataCount);
uglyf("gene %f %f %f\n", geneCuts[0], geneCuts[1], geneCuts[2]);
uglyf("gene %f %f %f\n", geneCuts[0], geneCuts[1], geneCuts[2]);
fprintf(f, "\n");
/* Move winList to strata. */
zeroBytes(strata, sizeof(strata));
for (win = winList; win != NULL; win = next)
{
/* Calculate appropriate strata and move. */
next = win->next;
consIx = cutIx(consCuts, strataCount, win->consRatio);
geneIx = cutIx(geneCuts, strataCount, win->geneRatio);
slAddHead(&strata[consIx][geneIx], win);
}
/* Shuffle strata and output first picks in each. */
srand(randSeed);
for (consIx=strataCount-1; consIx>=0; --consIx)
{
for (geneIx=strataCount-1; geneIx>=0; --geneIx)
{
int cs=0, gs=0;
if (geneIx>0)
gs = round(100*genoCuts[geneIx-1]);
if (consIx>0)
cs = round(100*genoCuts[consIx-1]);
fprintf(f, "consNonTx %d%%-%d%%, gene %d%%-%d%%\n",
cs, round(100*genoCuts[consIx]),
gs, round(100*genoCuts[geneIx]));
if (html)
{
fprintf(html, "<H2>consNonTx %d%% - %d%%, gene %d%% - %d%%</H3>\n",
cs, round(100*genoCuts[consIx]),
gs, round(100*genoCuts[geneIx]));
}
shuffleList(&strata[consIx][geneIx]);
pickIx = 0;
for (win = strata[consIx][geneIx]; win != NULL; win = win->next)
{
int end = win->start + bigWinSize;
if (!hitsRegions(win->chrom, win->start, end, avoidList))
{
if (withinChromLimits(chromLimitHash, win->chrom))
{
AllocVar(avoid);
avoid->chrom = cloneString(win->chrom);
avoid->start = win->start;
avoid->end = end;
slAddHead(&avoidList, avoid);
fprintf(f, "%s:%d-%d\t", win->chrom, win->start+1, end);
fprintf(f, "consNonTx %4.1f%%, gene %4.1f%%\n",
100*win->consRatio, 100*win->geneRatio);
if (html)
{
fprintf(html, "<A HREF=\"http://genome.ucsc.edu/cgi-bin/");
fprintf(html, "hgTracks?db=%s&position=%s:%d-%d\">",
database, win->chrom, win->start+1, end);
fprintf(html, "%s:%d-%d</A>", win->chrom, win->start+1, end);
fprintf(html, "\tconsNonTx %4.1f%%, gene %4.1f%%<BR>\n",
100*win->consRatio, 100*win->geneRatio);
}
if (++pickIx >= picksPer)
break;
}
}
}
fprintf(f, "\n");
}
}
if (html)
{
htmEnd(html);
carefulClose(&html);
}
}
void VoidAI::requestWithAction()
{
qDebug() << QString("VoidAI (%1): onActionRequest(%2)").arg(m_id).arg(m_requestType);
if (mp_playerCtrl->publicGameView().gameContextData().requestedPlayerId != mp_playerCtrl->privatePlayerView().id()) {
QString("VoidAI (%1): Not requested!").arg(m_id);
return;
}
QList<PlayingCard*> hand = mp_playerCtrl->privatePlayerView().hand();
switch(m_requestType) {
case REQUEST_DRAW:
qDebug() << QString("VoidAI (%1): REQUEST_DRAW").arg(m_id);
// Drawing two cards
try {
mp_playerCtrl->draw();
} catch (BadPredrawException& e) {
e.debug();
QList<PlayingCard*> table = mp_playerCtrl->privatePlayerView().table();
foreach(PlayingCard* c, table) {
try {
qDebug() << "Trying to play some card to bypass predraw exception";
mp_playerCtrl->playCard(c);
return;
} catch (GameException& e) {
qDebug() << "Predraw exception test exception:";
e.debug();
}
}
}
break;
case REQUEST_PLAY: {
qDebug() << QString("VoidAI (%1): REQUEST_PLAY").arg(m_id);
// Try to use blue cards:
foreach (PlayingCard* card, hand) {
try {
switch(card->type()) {
case CARD_APPALOSSA:
case CARD_MUSTANG:
case CARD_VOLCANIC:
case CARD_SCHOFIELD:
case CARD_REMINGTON:
case CARD_CARABINE:
case CARD_WINCHESTER:
case CARD_DILIGENZA:
case CARD_WELLSFARGO:
case CARD_INDIANS:
case CARD_GATLING:
case CARD_GENERALSTORE:
case CARD_DYNAMITE:
case CARD_BARREL:
mp_playerCtrl->playCard(card);
return;
case CARD_BEER:
if (mp_playerCtrl->privatePlayerView().lifePoints() !=
mp_playerCtrl->privatePlayerView().maxLifePoints()) {
mp_playerCtrl->playCard(card);
return;
}
default:
break;
}
} catch (GameException& e) {
qDebug() << "VoidAI: (checkpoint #1)";
e.debug();
}
}
foreach (PlayingCard* card, hand) {
try {
switch(card->type()) {
case CARD_BANG:
case CARD_DUEL:
case CARD_JAIL:
case CARD_PANIC:
case CARD_CATBALOU:
{
QList<PublicPlayerView*> players = mp_playerCtrl->publicGameView().publicPlayerList();
shuffleList(players);
foreach(const PublicPlayerView* p, players) {
if (mp_playerCtrl->privatePlayerView().id() == p->id()) {
continue;
}
try {
mp_playerCtrl->playCard(card, p);
return;
} catch (BadTargetPlayerException e) {
qDebug() << "VoidAI: BadTargetPlayerException!";
} catch (OneBangPerTurnException e) {
qDebug() << "VoidAI: One bang per turn!";
} catch(GameException& e) {
qDebug() << "VoidAI: GameException";
}
}
break;
}
default:
break;
}
} catch (GameException& e) {
qDebug() << "VoidAI: (checkpoint #2)";
e.debug();
}
}
// Finish turn or discard random card
try {
mp_playerCtrl->finishTurn();
return;
} catch (TooManyCardsInHandException e) {
qDebug() << QString("VoidAI (%1): discarding card").arg(m_id);
PlayingCard* card = mp_playerCtrl->privatePlayerView().hand().first();
mp_playerCtrl->discardCard(card);
return;
}
break;
}
case REQUEST_RESPOND: {
if (mp_playerCtrl->publicGameView().selection().size() > 0) {
QList<PlayingCard*> cards = mp_playerCtrl->publicGameView().selection();
int index = rand() % cards.size();
try {
mp_playerCtrl->playCard(cards[index]);
return;
} catch(GameException& e) {
qDebug() << QString("VoidAI (%1): Respond - selection: GameException").arg(m_id);
e.debug();
}
}
qDebug() << QString("VoidAI (%1): REQUEST_RESPOND").arg(m_id);;
QList<PlayingCard*> cards = mp_playerCtrl->privatePlayerView().hand();
foreach (PlayingCard* c, cards) {
try {
qDebug() << "Trying to play: " << playingCardTypeToString(c->type());
mp_playerCtrl->playCard(c);
return;
} catch (BadCardException e) {
qDebug() << QString("VoidAI (%1): Respond: BadCardException").arg(m_id);
} catch (BadPlayerException e) {
qDebug() << QString("VoidAI (%1): Respond: BadPlayerException").arg(m_id);
} catch (GameException& e) {
qDebug("VoidAI");
e.debug();
}
}
qDebug() << QString("VoidAI (%1): Trying to pass").arg(m_id);
try {
mp_playerCtrl->pass();
} catch (GameException& e) {
qDebug("Pass exception:");
e.debug();
}
return;
}
case REQUEST_DISCARD:
try {
qDebug() << QString("VoidAI (%1): discarding card").arg(m_id);
PlayingCard* card = mp_playerCtrl->privatePlayerView().hand().first();
qDebug() << QString("VoidAI (%1): cards in hand: %2").arg(m_id).arg(
mp_playerCtrl->privatePlayerView().hand().size());
mp_playerCtrl->discardCard(card);
} catch (BadGameStateException e) {
qDebug() << QString("VoidAI (%1): BadGameStateException").arg(m_id);
}
break;
}
}
