wordgame.cpp

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.10平台上编译为嵌入式图形界面操作系统。

	    return FALSE;
	}

	for (int b=0; b<bl; b++) {
	    QString v = le[b]->text();
	    blankvalues[b]=Tile(v,0);
	    if ( v.length() != 1 )
		goto retry;
	}
    }

    QStringList words;
    unshowTurn();
    turn_score = score(at,tiles,n,blankvalues,d,FALSE,&words);
    showTurn();
    QStringList to_add;
    for (QStringList::Iterator it=words.begin(); it!=words.end(); ++it) {
	if ( (*it).length() > 1 && !Global::fixedDawg().contains(*it)
		&& !Global::dawg("WordGame").contains(*it) ) {
	    switch (QMessageBox::warning(this, tr("Unknown word"),
		tr("<p>The word \"%1\" is not in the dictionary.").arg(*it),
		tr("Add"), tr("Ignore"), tr("Cancel")))
	    {
	    case 0:
		// ####### add to wordgame dictionary
		to_add.append(*it);
		break;
	    case 1:
		break;
	    case -1:	// falthrough
	    case 2:
		unshowTurn();
		canvas()->update();
		return FALSE;
	    }
	}
    }
    if ( to_add.count() )
	Global::addWords("WordGame",to_add);
    return TRUE;
}

void Board::scoreTurn(const QPoint& at, int n, const QPoint& d)
{
    unshowTurn();
    shown_at = at;
    shown_n = n;
    shown_step = d;
    const Tile* tiles[99];
    if ( n > current_rack->count() )
	n = current_rack->count();
    for (int i=0; i<n; i++)
	tiles[i] = current_rack->tileRef(i);
    turn_score = score(at,tiles,n,0,d,FALSE,0);
    emit temporaryScore(turn_score);
}

int Board::score(QPoint at, const Tile** tiles, int n, const Tile* blankvalue, const QPoint& d, bool checkdict, QStringList* words) const
{
    int total=0;
    int totalsidetotal=0;

    // words gets filled with words made

    // mainword==0 ->
    // Checks side words, but not main word

    // -1 means words not in dict, or illegally positioned (eg. not connected)

    // text is assumed to fit on board.

    if ( words ) *words=QStringList();

    QPoint otherd(d.y(), d.x());

    int all_mult = 1;
    int bl=0;

    bool connected = FALSE;

    QString mainword="";

    if ( contains(at-d) && tile(at-d) ) {
	return -1; // preceeding tiles
    }

    if ( !n )
	return -1;

    int mainlen=0;
    const Tile* t;
    for (int i=0; contains(at) && ((t=tile(at)) || i<n); ) {
	if ( t ) {
	    if ( checkdict || words ) mainword += t->text();
	    total += t->value();
	    connected = TRUE;
	} else {
	    QString sideword;
	    QString tt;
	    if ( tiles[i]->isBlank() ) {
		if ( blankvalue )
		    tt = blankvalue[bl++].text();
	    } else {
		tt = tiles[i]->text();
	    }
	    sideword=tt;
	    if ( checkdict || words ) mainword += tt;
	    int side_mult = 1;
	    int tilevalue = bonussedValue(at,tiles[i]->value(),side_mult);
	    all_mult *= side_mult;
	    if ( !connected && isStart(at) )
		connected = TRUE;
	    total += tilevalue;
	    int sidetotal = tilevalue;
	    {
		QPoint side = at-otherd;
		
		while ( contains(side) && (t=tile(side)) ) {
		    sidetotal += t->value();
		    sideword.prepend(t->text());
		    side -= otherd;
		}
	    }
	    {
		QPoint side = at+otherd;
		while ( contains(side) && (t=tile(side)) ) {
		    sidetotal += t->value();
		    sideword.append(t->text());
		    side += otherd;
		}
	    }
	    if ( sideword.length() > 1 ) {
		if ( words )
		    words->append(sideword);
		if ( checkdict && !Global::fixedDawg().contains(sideword)
		               && !Global::dawg("WordGame").contains(sideword) )
		    return -1;
		totalsidetotal += sidetotal * side_mult;
		connected = TRUE;
	    }
	    i++;
	}
	at += d;
	mainlen++;
    }

    if ( mainlen < 2 )
	total = 0;

    if ( words )
	words->append(mainword);
    if ( checkdict && !Global::fixedDawg().contains(mainword)
		   && !Global::dawg("WordGame").contains(mainword) )
	return -1;

    if ( n == rack_tiles )
	totalsidetotal += rack_tiles_bonus;

    return connected ? totalsidetotal + total * all_mult : -1;
}

QPoint Board::boardPos(const QPoint& p) const
{
    return QPoint(p.x()/canvas()->tileWidth(), p.y()/canvas()->tileHeight());
}

void Board::contentsMouseReleaseEvent(QMouseEvent*)
{
    if ( current_rack ) {
    }
}


void Board::setRules(const QString& shapes, const int* effects)
{
    rule_shape=shapes; rule_effect=effects;
    int i=0;
    int maxre=0;
    for (int y=0; y<yTiles(); y++) {
	for (int x=0; x<xTiles(); x++) {
	    int re = shapes[i++]-'0';
	    if ( re > maxre ) maxre = re;
	    canvas()->setTile(x,y,re);
	}
    }
    rack_tiles_bonus=effects[maxre+1];
}

void Board::unsetTile(const QPoint& p)
{
    delete item(p);
    grid[idx(p)] = 0;
}

void Board::setTile(const QPoint& p, const Tile& t)
{
    TileItem* it=item(p);
    if ( !it ) {
	it = grid[idx(p)] = new TileItem(t,FALSE,canvas());
	it->move(p.x()*canvas()->tileWidth(), p.y()*canvas()->tileHeight());
	it->show();
    } else {
	it->setTile(t);
    }
}

Rack::Rack(int ntiles, QWidget* parent) : QCanvasView(
	new QCanvas(ntiles*TileItem::bigWidth(),TileItem::bigHeight()),
	    parent),
	item(ntiles)
{
    setLineWidth(1);
    setFixedHeight(sizeHint().height());
    n = 0;
    for (int i=0; i<ntiles; i++)
	item[i]=0;
    setHScrollBarMode(AlwaysOff);
    setVScrollBarMode(AlwaysOff);
    canvas()->setBackgroundColor(gray);
    dragging = 0;
}

Rack::~Rack()
{
    clear();
    delete canvas();
}

QSize Rack::sizeHint() const
{
    return QSize(-1,TileItem::bigHeight()+2);
}

void Rack::clear()
{
    for (int i=0; i<n; i++)
	delete item[i];
    n=0;
}

void Rack::writeConfig(Config& cfg)
{
    QStringList l;
    for (int i=0; i<n; i++)
	l.append(tile(i).key());
    cfg.writeEntry("Tiles",l,';');
}

void Rack::readConfig(Config& cfg)
{
    clear();
    int x=0;
    QStringList l = cfg.readListEntry("Tiles",';');
    for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
	TileItem *i = new TileItem(Tile(*it),TRUE,canvas());
	i->move(x++,0);
	i->show();
	item[n++] = i;
    }
    layoutTiles();
}

static int cmp_tileitem(const void *a, const void *b)
{
    const TileItem* ia = *(TileItem**)a;
    const TileItem* ib = *(TileItem**)b;
    return int(ia->x() - ib->x());
}

void Rack::layoutTiles()
{
    int w = TileItem::bigWidth()+2;

    if ( dragging ) dragging->moveBy(dragging_adj,0);
    qsort(item.data(), n, sizeof(TileItem*), cmp_tileitem);
    if ( dragging ) dragging->moveBy(-dragging_adj,0);

    for (int i=0; i<n ;i++)
	if ( item[i] == dragging ) {
	    item[i]->setZ(1);
	} else {
	    item[i]->move(i*w, 0);
	    item[i]->setZ(0);
	}
    canvas()->update();
}

void Rack::setBlanks(const Tile* bv)
{
    for (int j=0; j<n; j++) {
	Tile tt = item[j]->tile();
	if ( tt.isBlank() ) {
	    tt.setText(bv->text());
	    item[j]->setTile(tt);
	    bv++;
	}
    }
}

bool Rack::arrangeTiles(const Tile** s, int sn)
{
    bool could = TRUE;
    for (int j=0; j<n; j++) {
	Tile tt = item[j]->tile();
	int f=-1;
	for (int i=0; i<sn && f<0; i++) {
	    if (s[i] && *s[i] == tt ) {
		s[i]=0;
		f=i;
	    }
	}
	if ( f >= 0 ) {
	    item[j]->move(f-999,0);
	} else {
	    could = FALSE;
	}
    }
    layoutTiles();
    return could;
}

void Rack::addTile(const Tile& t)
{
    TileItem *i = new TileItem(t,TRUE,canvas());
    i->show();
    item[n++] = i;
    layoutTiles();
}

void Rack::remove(Tile t)
{
    for (int i=0; i<n ;i++)
	if ( item[i]->tile() == t ) {
	    remove(i);
	    return;
	}
}

void Rack::remove(int i)
{
    delete item[i];
    n--;
    for (;i<n;i++)
	item[i]=item[i+1];
    layoutTiles();
}

void Rack::resizeEvent(QResizeEvent* e)
{
    canvas()->resize(width()-frameWidth()*2,height()-frameWidth()*2);
    QCanvasView::resizeEvent(e);
}

void Rack::contentsMousePressEvent(QMouseEvent* e)
{
    if ( computerized() )
	return;
    QCanvasItemList list = canvas()->collisions(e->pos());
    if (list.count()) {
	dragging = list.first();
	dragstart = e->pos()-QPoint(int(dragging->x()),int(dragging->y()));
    } else {
	dragging = 0;
    }
}

void Rack::contentsMouseMoveEvent(QMouseEvent* e)
{
    if ( computerized() )
	return;
    //int w = TileItem::bigWidth()+2;
    if ( dragging ) {
	dragging_adj = TileItem::bigWidth()/2;
	if ( dragging->x() > e->x()-dragstart.x() )
	    dragging_adj = -dragging_adj;
	dragging->move(e->x()-dragstart.x(),0);
	layoutTiles();
    }
}

void Rack::contentsMouseReleaseEvent(QMouseEvent*)
{
    if ( computerized() )
	return;
    if ( dragging ) {
	dragging=0;
	layoutTiles();
    }
}

Tile::Tile(const QString& key)
{
    int a=key.find('@');
    txt = key.left(a);
    val = key.mid(a+1).toInt();
    blank = txt.isEmpty();
}

QString Tile::key() const
{
    return txt+"@"+QString::number(val);
}

Bag::Bag()
{
    tiles.setAutoDelete(TRUE);
}

void Bag::writeConfig(Config& cfg)
{
    QStringList t;
    for (QListIterator<Tile> it(tiles); it; ++it)
	t.append((*it)->key());
    cfg.writeEntry("Tiles",t,';');
}

void Bag::readConfig(Config& cfg)
{
    tiles.clear();
    QStringList t = cfg.readListEntry("Tiles",';');
    for (QStringList::ConstIterator it=t.begin(); it!=t.end(); ++it )
	add(Tile(*it));
}

void Bag::add(const Tile& t)
{
    tiles.append(new Tile(t));
}

Tile Bag::takeRandom()
{
#ifndef Q_OS_WIN32
    Tile* rp = tiles.take(random()%tiles.count());
#else
    Tile* rp = tiles.take(rand()%tiles.count());
#endif
    Tile r=*rp;
    return r;
}

ScoreInfo::ScoreInfo( QWidget* parent, const char* name, WFlags fl ) :
    QLabel("<P>",parent,name,fl)
{
    score=0;
    msgtimer = new QTimer(this);
    connect(msgtimer, SIGNAL(timeout()), this, SLOT(showScores()));
}

ScoreInfo::~ScoreInfo()
{
    if ( score ) delete [] score;
}

void ScoreInfo::writeConfig(Config& cfg)
{
    QStringList l;
    for (int i=0; i<(int)names.count(); i++)
	l.append(QString::number(score[i]));
    cfg.writeEntry("Scores",l,';');
}

void ScoreInfo::readConfig(Config& cfg)
{
    QStringList l = cfg.readListEntry("Scores",';');
    int i=0;
    for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it )
	score[i++]=(*it).toInt();
    showScores();
}


QSize ScoreInfo::sizeHint() const
{
    return QSize(QLabel::sizeHint().width(),fontMetrics().height());
}

void ScoreInfo::init(const QStringList& namelist)
{
    names = namelist;
    if ( score ) delete [] score;
    score = new int[names.count()];
    memset(score,0,sizeof(int)*names.count());
    boldone = -1;
    showScores();
}

void ScoreInfo::addScore(int player, int change)
{
    score[player] += change;
    showScores();
}

void ScoreInfo::setBoldOne(int b)
{
    boldone=b;
    showScores();
}

void ScoreInfo::showScores()
{
    QString r="<p>";
    int i=0;
    //int spl=(names.count()+1)/2; // 2 lines
    for (QStringList::ConstIterator it=names.begin(); it!=names.end(); ) {
	if ( i==boldone ) r += "<b>";
	QString n = *it;
	n.replace(QRegExp(":.*"),"");
	r += n;
	r += ":";
	r += QString::number(score[i]);
	if ( i==boldone ) r += "</b>";

	++i;
	++it;
	if ( it != names.end() )
	    r += " ";
    }
    setText(r);
}

void ScoreInfo::showTemporaryScore(int amount)
{
    if ( amount < 0 )
	setText(tr("<P>Invalid move"));
    else
	setText(tr("<P>Score: ")+QString::number(amount));
    msgtimer->start(3000,TRUE);
}