diff options
Diffstat (limited to 'kenolaba')
63 files changed, 8735 insertions, 0 deletions
diff --git a/kenolaba/AbTop.cpp b/kenolaba/AbTop.cpp new file mode 100644 index 00000000..a2283f16 --- /dev/null +++ b/kenolaba/AbTop.cpp @@ -0,0 +1,988 @@ +/* Class AbTop */ + +#include <qpopupmenu.h> +#include <qtimer.h> +#include <qclipboard.h> + +#include <kaction.h> +#include <kapplication.h> +#include <kconfig.h> +#include <kdialogbase.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kmenubar.h> +#include <kstdaccel.h> +#include <kglobal.h> +#include <kstatusbar.h> +#include <kstdaction.h> +#include <kstdgameaction.h> +#include <kdebug.h> + +#include "AbTop.h" +#include "Board.h" +#include "BoardWidget.h" +#include "EvalDlgImpl.h" +#include "EvalScheme.h" +#include "Network.h" +#include "Spy.h" +#include "version.h" + +#include <stdio.h> +#include <stdlib.h> + +// #define MYTRACE 1 + +const AbTop::Data AbTop::LEVEL[Nb_Levels] = { + { "Easy", I18N_NOOP("&Easy") }, + { "Normal", I18N_NOOP("&Normal") }, + { "Hard", I18N_NOOP("&Hard") }, + { "Challange", I18N_NOOP("&Challenge") } +}; + +const AbTop::Data AbTop::IPLAY[Nb_IPlays] = { + { "Red", I18N_NOOP("&Red") }, + { "Yellow", I18N_NOOP("&Yellow") }, + { "Both", I18N_NOOP("&Both") }, + { "None", I18N_NOOP("&None") } +}; + +AbTop::AbTop() + :KMainWindow(0) +{ + timerState = noGame; + + myPort = Network::defaultPort; + currentEvalScheme = 0; + net = 0; + + actValue = 0; + stop = false; + editMode = false; + spyLevel = 0; + pastePossible = true; + + + timer = new QTimer; + connect( timer, SIGNAL(timeout()), this, SLOT(timerDone()) ); + + board = new Board(); + setMoveNo(0); + + connect( board, SIGNAL(searchBreak()), this, SLOT(searchBreak()) ); + Q_CHECK_PTR(board); + boardWidget = new BoardWidget(*board,this); + +#ifdef SPION + spy = new Spy(*board); +#endif + + connect( boardWidget, SIGNAL(updateSpy(QString)), + this, SLOT(updateSpy(QString)) ); + + setCentralWidget(boardWidget); + boardWidget->show(); + + // this creates the GUI + setupActions(); + setupStatusBar(); + setMinimumSize(200,300); + + // RMB context menu + connect( boardWidget, SIGNAL(rightButtonPressed(int,const QPoint&)), + this, SLOT(rightButtonPressed(int,const QPoint&)) ); + + connect( boardWidget, SIGNAL(edited(int)), + this, SLOT(edited(int)) ); + + connect( board, SIGNAL(updateBestMove(Move&,int)), + this, SLOT(updateBestMove(Move&,int)) ); + + connect( boardWidget, SIGNAL(moveChoosen(Move&)), + this, SLOT(moveChoosen(Move&)) ); + + /* default */ + setLevel(Easy); + setIPlay(Red); + showMoveLong = true; + showSpy = false; + renderBalls = true; + + updateStatus(); + updateActions(); + setupGUI(); +} + +AbTop::~AbTop() +{ + /* Unregister from other abalone processes */ + delete net; + delete timer; +#ifdef SPION + delete spy; +#endif +} + + +/** + * Create all the actions... + * + * The GUI will be built in createGUI using a XML file + * + */ + +void AbTop::setupActions() +{ + newAction = KStdGameAction::gameNew( this, SLOT(newGame()), actionCollection() ); + KStdGameAction::quit( this, SLOT(close()), actionCollection() ); + + stopAction = new KAction( i18n("&Stop Search"), "stop", Key_S, this, + SLOT(stopSearch()), actionCollection(), "move_stop"); + + backAction = new KAction( i18n("Take &Back"), "back", + KStdAccel::shortcut(KStdAccel::Prior), this, + SLOT(back()), actionCollection(), "move_back"); + + forwardAction = new KAction( i18n("&Forward"), "forward", + KStdAccel::shortcut(KStdAccel::Next), this, + SLOT(forward()), actionCollection(), "move_forward"); + + hintAction = KStdGameAction::hint(this, SLOT(suggestion()), actionCollection()); + + KStdAction::copy( this, SLOT(copy()), actionCollection()); + pasteAction = KStdAction::paste( this, SLOT(paste()), actionCollection()); + + (void) new KAction( i18n("&Restore Position"), + KStdAccel::shortcut(KStdAccel::Open), + this, SLOT(restorePosition()), + actionCollection(), "edit_restore" ); + + (void) new KAction( i18n("&Save Position"), + KStdAccel::shortcut(KStdAccel::Save), + this, SLOT(savePosition()), + actionCollection(), "edit_save" ); + + KToggleAction *ta; + + ta = new KToggleAction( i18n("&Network Play"), "network", Key_N, + actionCollection(), "game_net"); + connect(ta, SIGNAL(toggled(bool)), this, SLOT(gameNetwork(bool))); + + editAction = new KToggleAction( i18n("&Modify"), "edit", + CTRL+Key_Insert, actionCollection(), "edit_modify"); + connect(editAction, SIGNAL(toggled(bool)), this, SLOT( editModify(bool))); + + showMenubar = KStdAction::showMenubar(this, SLOT(toggleMenubar()), actionCollection()); + KStdAction::saveOptions( this, SLOT(writeConfig()), actionCollection()); + + KStdAction::preferences( this, SLOT(configure()), actionCollection()); + + moveSlowAction = new KToggleAction( i18n("&Move Slow"), 0, + actionCollection(), "options_moveSlow"); + connect(moveSlowAction, SIGNAL(toggled(bool)), this, SLOT(optionMoveSlow(bool))); + + renderBallsAction = new KToggleAction( i18n("&Render Balls"), 0, + actionCollection(), "options_renderBalls"); + connect(renderBallsAction, SIGNAL(toggled(bool)), this, SLOT(optionRenderBalls(bool))); + + showSpyAction = new KToggleAction( i18n("&Spy"), 0, + actionCollection(), "options_showSpy"); + connect(showSpyAction, SIGNAL(toggled(bool)), this, SLOT(optionShowSpy(bool))); + + + levelAction = KStdGameAction::chooseGameType(0, 0, actionCollection()); + QStringList list; + for (uint i=0; i<Nb_Levels; i++) + list.append( i18n(LEVEL[i].label) ); + levelAction->setItems(list); + connect(levelAction, SIGNAL(activated(int)), SLOT(setLevel(int))); + + iplayAction = new KSelectAction(i18n("&Computer Play"), 0, actionCollection(), "options_iplay"); + list.clear(); + for (uint i=0; i<Nb_IPlays; i++) + list.append( i18n(IPLAY[i].label) ); + iplayAction->setItems(list); + connect(iplayAction, SIGNAL(activated(int)), SLOT(setIPlay(int))); +} + +void AbTop::toggleMenubar() +{ + if (menuBar()->isVisible()) + menuBar()->hide(); + else + menuBar()->show(); +} + +void AbTop::configure() +{ + KDialogBase *dlg = new KDialogBase( 0, "ConfigureEvaluation", true, + i18n("Configure Evaluation"), + KDialogBase::Ok | KDialogBase::Cancel, + KDialogBase::Ok, true); + + EvalDlgImpl *edlg = new EvalDlgImpl(dlg,board); + dlg->setMainWidget(edlg); + if (dlg->exec()) { + *currentEvalScheme = *(edlg->evalScheme()); + board->setEvalScheme(currentEvalScheme); + } + delete edlg; +} + +/* Right Mouse button pressed in BoardWidget area */ +void AbTop::rightButtonPressed(int /* field */, const QPoint& pos) +{ + QPopupMenu* rmbMenu = static_cast<QPopupMenu*> (factory()->container("rmbPopup",this)); + if (rmbMenu) + rmbMenu->popup( pos ); +} + +/* Read config options + * + * menu must already be created! + */ +void AbTop::readConfig() +{ + kdDebug(12011) << "Reading config..." << endl; + + KConfig* config = kapp->config(); + config->setGroup("Options"); + + readOptions(config); + + applyMainWindowSettings( config, "Appearance" ); + + showMenubar->setChecked( !menuBar()->isHidden() ); + + currentEvalScheme = new EvalScheme("Current"); + currentEvalScheme->read(config); + board->setEvalScheme( currentEvalScheme ); +} + +void AbTop::readOptions(KConfig* config) +{ + QString entry = config->readEntry("Level"); + for (uint i=0; i<Nb_Levels; i++) + if ( entry==LEVEL[i].key ) setLevel(i); + + entry = config->readEntry("Computer"); + for (uint i=0; i<Nb_IPlays; i++) + if ( entry==IPLAY[i].key ) setIPlay(i); + + showMoveLong = config->readBoolEntry("MoveSlow", false); + moveSlowAction->setChecked( showMoveLong ); + + renderBalls = config->readBoolEntry("RenderBalls", true); + boardWidget->renderBalls(renderBalls); + renderBallsAction->setChecked( renderBalls ); + + showSpy = config->readBoolEntry("ShowSpy", true); + board->updateSpy(showSpy); + showSpyAction->setChecked( showSpy ); +} + +void AbTop::readProperties(KConfig *config) +{ + QString entry; + + readOptions(config); + + currentEvalScheme = new EvalScheme("Current"); + currentEvalScheme->read(config); + board->setEvalScheme( currentEvalScheme ); + + + if (!(entry = config->readEntry("TimerState")).isNull()) + timerState = entry.toInt(); + if (timerState == noGame) return; + + stop = config->readBoolEntry("GameStopped", false); + + int mNo = 0; + if (!(entry = config->readEntry("Position")).isNull()) { + mNo = board->setState(entry); + boardWidget->updatePosition(true); + } + setMoveNo(mNo, true); + + show(); + playGame(); +} + +void AbTop::writeConfig() +{ + kdDebug(12011) << "Writing config..." << endl; + + KConfig* config = kapp->config(); + config->setGroup("Options"); + + writeOptions(config); + + saveMainWindowSettings( config, "Appearance" ); + + if (currentEvalScheme) + currentEvalScheme->save(config); + config->sync(); +} + + +void AbTop::writeOptions(KConfig *config) +{ + config->writeEntry("Level", LEVEL[levelAction->currentItem()].key); + config->writeEntry("Computer", IPLAY[iplayAction->currentItem()].key); + + config->writeEntry("MoveSlow", showMoveLong); + config->writeEntry("RenderBalls", renderBalls); + config->writeEntry("ShowSpy", showSpy); +} + +void AbTop::saveProperties(KConfig *config) +{ + writeOptions(config); + if (currentEvalScheme) + currentEvalScheme->save(config); + + config->writeEntry("TimerState", timerState); + + if (timerState == noGame) return; + + config->writeEntry("GameStopped", stop); + config->writeEntry("Position", board->getState(moveNo)); + config->sync(); +} + +void AbTop::savePosition() +{ + KConfig* config = kapp->config(); + config->setGroup("SavedPosition"); + config->writeEntry("Position", board->getState(moveNo)); +} + +void AbTop::restorePosition() +{ + KConfig* config = kapp->config(); + config->setGroup("SavedPosition"); + QString entry = config->readEntry("Position"); + + timerState = notStarted; + timer->stop(); + board->begin(Board::color1); + stop = false; + setMoveNo( board->setState(entry), true ); + + if (net) + net->broadcast( board->getASCIIState( moveNo ).ascii() ); + + boardWidget->updatePosition(true); + + playGame(); +} + +void AbTop::setupStatusBar() +{ + QString tmp; + + QString t = i18n("Press %1 for a new game").arg( newAction->shortcut().toString()); + statusLabel = new QLabel( t, statusBar(), "statusLabel" ); + statusBar()->addWidget(statusLabel,1,false); + + // PERMANENT: Moving side + move No. + + // validPixmap, only visible in Modify mode: is position valid ? + warningPix = BarIcon( "warning" ); + okPix = BarIcon( "ok" ); + validLabel = new QLabel( "", statusBar(), "validLabel" ); + validLabel->setFixedSize( 18, statusLabel->sizeHint().height() ); + validLabel->setAlignment( AlignCenter ); + validLabel->hide(); + validShown = false; + + redBall = BarIcon( "redball" ); + yellowBall = BarIcon( "yellowball" ); + noBall = BarIcon( "noball" ); + ballLabel = new QLabel( "", statusBar(), "ballLabel" ); + ballLabel->setPixmap(noBall); + ballLabel->setFixedSize( 18, statusLabel->sizeHint().height() ); + ballLabel->setAlignment( AlignCenter ); + statusBar()->addWidget(ballLabel, 0, true); + + moveLabel = new QLabel( i18n("Move %1").arg("--"), statusBar(), "moveLabel" ); + statusBar()->addWidget(moveLabel, 0, true); + +#ifdef MYTRACE + /* Create a toolbar menu for debugging output level */ + KToolBar *tb = toolBar("mainToolBar"); + if (tb) { + QPopupMenu* spyPopup = new QPopupMenu; + spy0 = BarIcon( "spy0" ); + spy1 = BarIcon( "spy1" ); + spy2 = BarIcon( "spy2" ); + spy3 = BarIcon( "spy3" ); + spyPopup->insertItem(spy0, 0); + spyPopup->insertItem(spy1, 1); + spyPopup->insertItem(spy2, 2); + spyPopup->insertItem(spy3, 3); + connect( spyPopup, SIGNAL(activated(int)), + this, SLOT(setSpy(int)) ); + tb->insertButton(spy0, 30, spyPopup, + TRUE, i18n("Spy")); + } +#endif + +} + + + +void AbTop::updateSpy(QString s) +{ + if (showSpy) { + if (s.isEmpty()) { + updateStatus(); + // statusBar()->clear(); + } + else + statusLabel->setText(s); + } +} + +void AbTop::updateBestMove(Move& m, int value) +{ + if (showSpy) { + boardWidget->showMove(m,3); + boardWidget->showMove(m,0,false); + + QString tmp; + tmp.sprintf("%s : %+d", (const char*) m.name().utf8(), value-actValue); + updateSpy(tmp); + kapp->processEvents(); + } +} + + +void AbTop::updateStatus() +{ + QString tmp; + bool showValid = false; + + if (!editMode && timerState == noGame) { + tmp = i18n("Move %1").arg("--"); + ballLabel->setPixmap(noBall); + } + else { + tmp = i18n("Move %1").arg(moveNo/2 + 1); + ballLabel->setPixmap( (board->actColor() == Board::color1) + ? redBall : yellowBall); + } + moveLabel->setText(tmp); + + if (editMode) { + tmp = QString("%1: %2 %3 - %4 %5") + .arg( i18n("Edit") ) + .arg( i18n("Red") ).arg(boardWidget->getColor1Count()) + .arg( i18n("Yellow") ).arg(boardWidget->getColor2Count()); + validLabel->setPixmap( (board->validState() == Board::invalid) + ? warningPix:okPix ); + showValid = true; + } + else if (timerState == noGame) { + tmp = i18n("Press %1 for a new game").arg( newAction->shortcut().toString()); + } + else { + if (timerState == gameOver) { + tmp = (board->actColor() == Board::color2) ? + i18n("Red won"):i18n("Yellow won"); + validLabel->setPixmap( warningPix ); + showValid = true; + } + else { + tmp = QString("%1 - %2") + .arg( (board->actColor() == Board::color1) ? + i18n("Red"):i18n("Yellow") ) + .arg( iPlayNow() ? + i18n("I am thinking...") : i18n("It is your turn!") ); + } + } + statusLabel->setText(tmp); + if (validShown != showValid) { + if (showValid) { + statusBar()->addWidget(validLabel); + validLabel->show(); + } + else { + statusBar()->removeWidget(validLabel); + validLabel->hide(); + } + validShown = showValid; + } + statusBar()->clear(); + statusBar()->repaint(); +} + +void AbTop::edited(int vState) +{ + if (vState == Board::empty) + timerState = noGame; + + updateStatus(); +} + +/* only <stop search>, <hint>, <take back> have to be updated */ +void AbTop::updateActions() +{ + bool iPlay = iPlayNow(); + + /* New && Copy always on */ + + /* Paste */ + pastePossible = !iPlay; + pasteAction->setEnabled(!iPlay); + + /* Edit */ + editAction->setEnabled(!iPlay); + + /* Stop search */ + stopAction->setEnabled(iPlay); + + /* Back */ + bool bBack = (editMode && moveNo>0) || + (board->movesStored() >=1 && !iPlay); + backAction->setEnabled(bBack); + + /* Forward */ + bool bForward = editMode && moveNo<999; + forwardAction->setEnabled(bForward); + + /* Hint */ + bool bHint = !editMode && !iPlay && (haveHint().type != Move::none); + hintAction->setEnabled(bHint); +} + +/* let the program be responsive even in a long search... */ +void AbTop::searchBreak() +{ + kapp->processEvents(); +} + + +void AbTop::setSpy(int id ) +{ + toolBar("mainToolBar")->setButtonPixmap(30, (id==0)?spy0:(id==1)?spy1:(id==2)?spy2:spy3 ); + spyLevel = id; + board->setSpyLevel(spyLevel); +} + +void AbTop::timerDone() +{ + int interval = 400; + + switch(timerState) { + case noGame: + case notStarted: + return; + case showMove: + case showMove+2: + case showSugg: + case showSugg+2: + case showSugg+4: + boardWidget->showMove(actMove, 2); + interval = 200; + break; + case showMove+1: + case showMove+3: + case showSugg+1: + case showSugg+3: + boardWidget->showMove(actMove, 3); + break; + case showSugg+5: + interval = 800; + case showMove+4: + boardWidget->showMove(actMove, 4); + break; + case showMove+5: + boardWidget->showMove(actMove, 0); + timerState = moveShown; + playGame(); + return; + case showSugg+6: + boardWidget->showMove(actMove, 0); + timerState = notStarted; + return; + } + timerState++; + timer->start(interval,TRUE); +} + +void AbTop::userMove() +{ + /* User has to move */ + static MoveList list; + + list.clear(); + board->generateMoves(list); + + if (list.getLength() == 0) { + stop = true; + timerState = gameOver; + playGame(); + } + else + boardWidget->choseMove(&list); +} + +bool AbTop::iPlayNow() +{ + if (editMode || + (board->validState() != Board::valid) || + timerState == gameOver) + return false; + + int c = board->actColor(); + + /* color1 is red */ + return ((iplay == Both) || + ((c == Board::color1) && (iplay == Red) ) || + ((c == Board::color2) && (iplay == Yellow) )); +} + +void AbTop::playGame() +{ + if (timerState == moveShown) { + if (actMove.type != Move::none) { + board->playMove(actMove); + moveNo++; // actColor in board is changed in playMove + + if (net) + net->broadcast( board->getASCIIState( moveNo ).ascii() ); + } + actValue = - board->calcEvaluation(); + boardWidget->updatePosition(true); + timerState = notStarted; + } + if (!board->isValid()) { + stop = true; + timerState = gameOver; + } + + updateStatus(); + updateActions(); + boardWidget->setCursor(crossCursor); + if (stop) return; + + + if (!iPlayNow()) { + userMove(); + return; + } + boardWidget->setCursor(waitCursor); + kapp->processEvents(); + + if (moveNo <4) { + /* Chose a random move making the position better for actual color */ + + /* If comparing ratings among color1/2 on move, we have to negate one */ + int v = -board->calcEvaluation(), vv; + do { + actMove = board->randomMove(); + board->playMove(actMove); + vv = board->calcEvaluation(); + board->takeBack(); + } while( (board->actColor() == Board::color1) ? (vv<v) : (vv>v) ); + } + else { + actMove = (board->bestMove()); + + if (actMove.type == Move::none) { + stop = true; + timerState = gameOver; + playGame(); + return; + } + } + + timerState = showMoveLong ? showMove : showMove+3; + timerDone(); +} + +void AbTop::moveChoosen(Move& m) +{ + actMove = m; + timerState = moveShown; + playGame(); +} + +void AbTop::newGame() +{ + /* stop a running animation */ + timerState = notStarted; + timer->stop(); + + /* reset board */ + board->begin(Board::color1); + boardWidget->updatePosition(true); + setMoveNo(0, true); + + if (net) + net->broadcast( board->getASCIIState( moveNo ).ascii() ); + + /* if not in EditMode, start Game immediately */ + if (!editMode) { + stop = false; + playGame(); + } +} + +/* Copy ASCII representation into Clipboard */ +void AbTop::copy() +{ + QClipboard *cb = QApplication::clipboard(); + cb->setText( board->getASCIIState( moveNo ).ascii() ); +} + +void AbTop::paste() +{ + if (!pastePossible) return; + + QClipboard *cb = QApplication::clipboard(); + pastePosition( cb->text().ascii() ); + /* don't do this in pastePosition: RECURSION !! */ + + if (net) + net->broadcast( board->getASCIIState( moveNo ).ascii() ); +} + +void AbTop::pastePosition(const char * text) +{ + if (!pastePossible) return; + if ( text ) { + timerState = notStarted; + timer->stop(); + board->begin(Board::color1); + stop = false; + + int mNo = board->setASCIIState(text); + if (mNo<0) mNo=0; + setMoveNo( mNo, true); + + boardWidget->updatePosition(true); + + if ( (board->validState()==Board::invalid) && !editMode) { + editAction->setChecked(true); + return; + } + + playGame(); + } +} + + +void AbTop::gameNetwork(bool on) +{ + if (!on) { + if (net != 0) { + delete net; + net = 0; + } + return; + } + + if (myPort == 0) myPort = Network::defaultPort; + net = new Network(myPort); + char *h, h2[100]; + int p, i; + for(h = hosts.first(); h!=0; h=hosts.next()) { + for(i=0;h[i]!=0 && h[i]!=':';i++); + if (h[i]==':') + p = atoi(h+i+1); + else + p = 0; + + if (p == 0) p = Network::defaultPort; + strncpy(h2,h,i); + h2[i]=0; + net->addListener(h2, p); + } + QObject::connect(net, SIGNAL(gotPosition(const char *)), + this, SLOT(pastePosition(const char *)) ); +} + + +void AbTop::editModify(bool on) +{ + int vState = board->validState(); + + editMode = boardWidget->setEditMode( on ); + if (vState != Board::valid) + timerState = noGame; + + updateActions(); + updateStatus(); + if (!editMode && vState == Board::valid) { + actMove.type = Move::none; + timerState = moveShown; + playGame(); + } +} + +void AbTop::stopGame() +{ + stop = true; + board->stopSearch(); +} + +void AbTop::stopSearch() +{ + // When computer plays both, switch back to human for next color + if (iplay == Both) { + if (board->actColor() == Board::color1) setIPlay(Red); + else setIPlay(Yellow); + } + board->stopSearch(); +} + +bool AbTop::queryClose() +{ + board->stopSearch(); + return true; +} + +void AbTop::continueGame() +{ + if (timerState != noGame && timerState != gameOver) { + stop = false; + if (timerState == notStarted) + playGame(); + } +} + +/** + * Reset the Move number of the actual game to <m> + * If <update> is true, update GUI actions and redraw statusbar + */ +void AbTop::setMoveNo(int m, bool updateGUI) +{ + moveNo = m; + + board->setActColor( ((moveNo%2)==0) ? Board::color1 : Board::color2 ); + + if (updateGUI) { + updateStatus(); + updateActions(); + } +} + + +/* "Back" action activated + * + * If in edit mode, simple go 1 back + * If in a game, go back 2 if possible + */ +void AbTop::back() +{ + if (editMode) { + if (moveNo > 0) + setMoveNo(moveNo-1, true); + return; + } + + if (moveNo < 1) return; + + if (timerState == gameOver) + timerState = notStarted; + if (timerState != notStarted) return; + + /* If possible, go 2 steps back */ + if (moveNo>0 && board->takeBack()) moveNo--; + if (moveNo>0 && board->takeBack()) moveNo--; + setMoveNo( moveNo, true ); + + boardWidget->updatePosition(true); + + userMove(); +} + +/* Only for edit Mode */ +void AbTop::forward() +{ + if (editMode) { + if (moveNo < 999) + setMoveNo(moveNo+1, true); + return; + } +} + +Move AbTop::haveHint() +{ + static Move m; + static int oldMoveNo = 0; + + if (timerState != notStarted) { + m.type = Move::none; + } + else if (moveNo != oldMoveNo) { + MoveList list; + + oldMoveNo = moveNo; + m = board->nextMove(); + board->generateMoves(list); + if (!list.isElement(m,0)) + m.type = Move::none; + } + return m; +} + + +void AbTop::suggestion() +{ + if (timerState != notStarted) return; + Move m = haveHint(); + if (m.type == Move::none) return; + + actMove = m; + + timerState = showSugg; + timerDone(); +} + +void AbTop::setLevel(int l) +{ + levelAction->setCurrentItem(l); + depth = l+2; + board->setDepth(depth); + // kdDebug(12011) << "Level set to " << d << endl; +} + +void AbTop::setIPlay(int i) +{ + iplayAction->setCurrentItem(i); + iplay = (IPlay)i; + continueGame(); +} + +void AbTop::optionMoveSlow(bool on) +{ + showMoveLong = on; +} + +void AbTop::optionRenderBalls(bool on) +{ + renderBalls = on; + boardWidget->renderBalls(renderBalls); +} + +void AbTop::optionShowSpy(bool on) +{ + showSpy = on; + board->updateSpy(showSpy); + +#ifdef SPION + if (showSpy) + spy->show(); + else { + spy->nextStep(); + spy->hide(); + } +#endif + +} + + +#include "AbTop.moc" diff --git a/kenolaba/AbTop.h b/kenolaba/AbTop.h new file mode 100644 index 00000000..35357452 --- /dev/null +++ b/kenolaba/AbTop.h @@ -0,0 +1,152 @@ +/* Class AbTop: the toplevel widget of Kenolaba + * + * Josef Weidendorfer, 9/97 +*/ + +#ifndef _ABTOP_H_ +#define _ABTOP_H_ + +#include <kmainwindow.h> + +#include "Move.h" + + +class QTimer; +class QPopupMenu; +class QLabel; + +class KAction; +class KToggleAction; +class KSelectAction; + +class Network; +class Board; +class BoardWidget; +class Move; +class EvalScheme; + +#ifdef SPION +class Spy; +#endif + + + +class AbTop: public KMainWindow +{ + Q_OBJECT + +public: + AbTop(); + ~AbTop(); + + /* timer states */ + enum { noGame, gameOver, notStarted, moveShown, + showMove = 100, showSugg=200 + }; + + void netPort(int p) { myPort = p; } + void netHost(char* h) { hosts.append(h); } + +protected: + virtual void saveProperties( KConfig * ); + virtual void readProperties( KConfig * ); + + +public slots: + void timerDone(); + void newGame(); + void copy(); + void paste(); + void pastePosition(const char *); + void stopGame(); + void continueGame(); + bool queryClose(); + void back(); + void forward(); + void suggestion(); + void stopSearch(); + void searchBreak(); + void moveChoosen(Move&); + void savePosition(); + void restorePosition(); + void setSpy(int); + void updateSpy(QString); + void edited(int); + void updateBestMove(Move&,int); + void readConfig(); + void writeConfig(); + void rightButtonPressed(int,const QPoint&); + + void gameNetwork(bool); + void editModify(bool); + void optionMoveSlow(bool); + void optionRenderBalls(bool); + void optionShowSpy(bool); + void toggleMenubar(); + void configure(); + void setLevel(int); + void setIPlay(int); + +private: + void setupActions(); + void updateStatus(); + void userMove(); + void playGame(); + void loadPixmaps(); + void setupStatusBar(); + void updateActions(); + void setMoveNo(int, bool updateGUI = false); + bool iPlayNow(); + Move haveHint(); + void readOptions(KConfig *); + void writeOptions(KConfig *); + + Move actMove; + Board* board; + int actValue; + BoardWidget *boardWidget; + EvalScheme* currentEvalScheme; + QTimer *timer; + int timerState; + int depth, moveNo; + bool showMoveLong, stop, showSpy; + bool editMode, renderBalls; + int spyLevel; + bool pastePossible, validShown; + + enum IPlay { Red = 0, Yellow, Both, None, Nb_IPlays }; + IPlay iplay; + + int stop_id, back_id, hint_id; + int easy_id, normal_id, hard_id, challange_id, slow_id, level_id; + int render_id; + int yellow_id, red_id, both_id, none_id, iplay_id; + int spy_id, paste_id, edit_id, forward_id, net_id; + + QLabel *validLabel, *ballLabel, *moveLabel, *statusLabel; + QPixmap warningPix, okPix, redBall, yellowBall, noBall, netPix; + QPixmap spy0, spy1, spy2, spy3; + + Network *net; + int myPort; + QStrList hosts; + + KAction *newAction, *stopAction, *backAction, *forwardAction, *hintAction, *pasteAction; + KToggleAction *showMenubar, *renderBallsAction, *moveSlowAction, + *showSpyAction, *editAction; + KSelectAction *levelAction, *iplayAction; + + struct Data { + const char *key, *label; + }; + enum Level { Easy = 0, Normal, Hard, Challenge, Nb_Levels }; + static const Data LEVEL[Nb_Levels]; + static const Data IPLAY[AbTop::Nb_IPlays]; + +#ifdef SPION + Spy* spy; +#endif + +}; + +#endif /* _ABTOP_H_ */ diff --git a/kenolaba/Ball.cpp b/kenolaba/Ball.cpp new file mode 100644 index 00000000..565ef296 --- /dev/null +++ b/kenolaba/Ball.cpp @@ -0,0 +1,492 @@ +/* Ball animation classes */ + +#include "Ball.h" +#include <qtimer.h> +#include <qbitmap.h> +#include <qimage.h> +#include <qpixmap.h> +#include <math.h> +#include <stdio.h> + +Ball* Ball::first = 0; +//QImage Ball::back; +int Ball::sizeX, Ball::sizeY; +double Ball::lightX, Ball::lightY, Ball::lightZ; +QColor Ball::lightColor; +double Ball::rippleCount, Ball::rippleDepth; + +/* set global Ball parameter */ +void Ball::setSize(int x, int y) +{ + sizeX = x; + sizeY = y; + + invalidate(); +} + +void Ball::invalidate() +{ + Ball *b; + + /* invalidate all Balls... */ + for(b=first;b!=0;b=b->next) + b->pm.resize(0,0); +} + +void Ball::setLight(int x, int y, int z, const QColor& c) +{ + double len = sqrt(double(x*x + y*y + z*z)); + + lightX = x/len; + lightY = y/len; + lightZ = z/len; + + lightColor = c; + + invalidate(); +} + + +void Ball::setTexture(double c, double d) +{ + rippleCount = c; + rippleDepth = d; + + invalidate(); +} + + + +Ball::Ball(const QColor& c, double a, int t) +{ + if (first ==0) { + sizeX = sizeY = -1; + setLight(); + setTexture(7,.3); + } + + bColor = c; + an = a; + sina = sin(a), cosa = cos(a); + + zoom= 1.05, flip = 2.0, limit = 0; + tex = t; + + next = first; + first = this; +} + +Ball::~Ball() +{ + Ball* b; + + if (first == this) + first = next; + else { + for(b = first; b!=0; b=b->next) + if (b->next == this) break; + if (b!=0) + b->next = next; + } +} + +QPixmap* Ball::pixmap() +{ + if (pm.isNull() && sizeX>0 && sizeY>0) + render(); + return ± +} + +void Ball::render() +{ + int x,y; + double xx,yy,zz, ll,lll, red,green,blue; + + if (sizeX==0 || sizeY==0) + return; + + QImage image(sizeX,sizeY,32); + image.fill(0); + + double vv=2./(sizeX+sizeY); + + /* Go through all pixels, mapping x/y to (-1..1,-1..1) */ + for(y=0;y<sizeY;y++) { + yy = (2.*y-sizeY)/(sizeY-2) *zoom; + for(x=0;x<sizeX;x++) { + xx = (2.*x-sizeX)/(sizeX-2) *zoom; + + /* Change only if inside the ball */ + zz = 1 - (xx*xx + yy*yy); + + if (zz>flip) zz=2*flip-zz; + else { + zz -= limit; + } + + if (zz>-vv) { + zz = (zz<0) ? 0 : sqrt(zz); + + /* ll: light intensity at this point */ + ll = xx*lightX + yy*lightY + zz*lightZ; + + /* some face modification */ + double mapx = xx*(2-zz); + double mapy = yy*(2-zz); + double rmapx = cosa*mapx + sina*mapy; /* rotate */ + double rmapy = -sina*mapx + cosa*mapy; + + if (tex>0) + ll += rippleDepth* cos(rippleCount*rmapx)*cos(rippleCount*rmapy); + + ll = (ll<0.01) ? 0.0 : (ll>.99) ? 1.0 : ll; + lll = ll*ll; + + // printf("x %f, y %f, z %f : ll %f lll %f\n", xx,yy,zz,ll,lll); + + + /* mix ball+light */ + red = lll * lightColor.red() + (1-lll) * bColor.red(); + green = lll * lightColor.green() + (1-lll) * bColor.green(); + blue = lll * lightColor.blue() + (1-lll) * bColor.blue(); + + /* lightness */ + red = .2 * bColor.red() + .8 * ll * red; + green = .2 * bColor.green() + .8 * ll * green; + blue = .2 * bColor.blue() + .8 * ll * blue; + + image.setPixel(x,y, qRgb( (int)red, (int)green, (int)blue )); + } + } + } + const QImage iMask = image.createHeuristicMask(); + QBitmap bMask; + bMask = iMask; + pm.convertFromImage( image, 0 ); + pm.setMask(bMask); +} + + +/* Class BallAnimation */ + +BallAnimation::BallAnimation(int s, Ball* ball1, Ball* ball2) +{ + QColor c1 = ball1->ballColor(); + double a1 = ball1->angle(); + int r1 = c1.red(), g1 = c1.green(), b1 = c1.blue(); + + QColor c2 = ball2->ballColor(); + double a2 = ball2->angle(); + int r2 = c2.red(), g2 = c2.green(), b2 = c2.blue(); + + QColor c; + double a; + int i; + + steps = s; + s--; + + balls.append( new Ball( c1,a1 ) ); + + for(i=1; i< s; i++) { + c.setRgb( r1+(r2-r1)*i/s, g1+(g2-g1)*i/s, b1+(b2-b1)*i/s ); + a = a1+(a2-a1)*i/s; + + balls.append( new Ball( c,a ) ); + } + + balls.append( new Ball( c2,a2 ) ); +} + + +/* Class BallPosition */ +BallPosition::BallPosition(int xp,int yp, Ball* d) +{ + x=xp; + y=yp; + def=d; + actStep = -1; + actType = ANIMATION_STOPPED; + actAnimation=0; +} + + +/* Class BallWidget */ + +BallWidget::BallWidget( int _freq, int bFr, QWidget *parent, const char *name ) + : QWidget(parent,name), positions(MAX_POSITION), animations(MAX_ANIMATION) +{ + int i; + + for(i=0;i<MAX_POSITION;i++) + positions[i] = 0; + + for(i=0;i<MAX_ANIMATION;i++) + animations[i] = 0; + + freq = _freq; + isRunning = false; + ballFraction = bFr; + realSize = -1; + timer = new QTimer(this); + connect( timer, SIGNAL(timeout()), SLOT(animate()) ); +} + +BallWidget::~BallWidget() +{ + if (timer !=0) + delete timer; +} + +void BallWidget::createBlending(int no, int s, Ball* b1, Ball* b2) +{ + if (no<0 || no>= MAX_ANIMATION) return; + + if (animations[no] !=0) + delete animations[no]; + + animations[no] = new BallAnimation(s,b1,b2); +} + + +/* X, Y are coordinates in a virtual 1000x1000 area */ +void BallWidget::createBallPosition(int no, int x, int y, Ball* def) +{ + if (no<0 || no>= MAX_POSITION) return; + + if (positions[no] !=0) + delete positions[no]; + + positions[no] = new BallPosition(x,y, def); +} + +void BallWidget::startAnimation(int pos, int anim, int type) +{ + BallPosition *p; + + if (pos<0 || pos>=MAX_POSITION || positions[pos]==0) return; + if (anim<0 || anim>=MAX_ANIMATION || animations[anim]==0) return; + + p = positions.at(pos); + p->actAnimation = animations.at(anim); + + /* One step *BEFORE* start */ + p->actStep = -1; + p->actDir = 1; + p->actType = type; + + if (!isRunning) { + isRunning = true; + timer->start( 0, true ); + } +} + +/* If LOOP: Set to ONESHOT, otherwise set to last frame */ +void BallWidget::stopAnimation(int pos) +{ + BallPosition *p; + + if (pos<0 || pos>=MAX_POSITION || positions[pos]==0) return; + + p = positions.at(pos); + if (p->actType == ANIMATION_STOPPED || + p->actAnimation == 0) return; + + if (p->actType == ANIMATION_LOOP || + p->actType == ANIMATION_CYCLE) { + p->actType = ANIMATION_FORWARD; + // return; + } + /* Set last step: animate() does the rest */ + p->actDir = 1; + p->actStep = p->actAnimation->steps; +} + +void BallWidget::resizeEvent(QResizeEvent *) +{ + int w = width() *10/12, h = height(); + + realSize = (w>h) ? h:w; + + Ball::setSize( realSize/ballFraction, realSize/ballFraction ); + repaint(); +} + +void BallWidget::paintEvent(QPaintEvent *) +{ + paint(this); +} + + +void BallWidget::paint(QPaintDevice *pd) +{ + int i; + BallPosition *p; + int xReal, yReal; + + int w = width(), h = height(); + + if (realSize<0) return; + + for(i=0;i<MAX_POSITION;i++) { + p = positions.at(i); + if (p==0) continue; + + xReal = (w + p->x * realSize / 500 - Ball::w() )/2; + yReal = (h + p->y * realSize / 500 - Ball::h() )/2; + + if (p->actAnimation==0 || p->actStep==-1) { + if (p->def !=0 ) + bitBlt( pd, xReal, yReal, p->def->pixmap() ); + } + else { + int s = p->actStep; + if (s>= p->actAnimation->steps) + s = p->actAnimation->steps-1; + Ball* b = p->actAnimation->balls.at(s); + bitBlt( pd, xReal, yReal, b->pixmap() ); + } + } +} + +void BallWidget::animate() +{ + bool doAnimation = false; + + int i; + BallPosition *p; + int xReal, yReal; + int w = width(), h = height(); + + for(i=0;i<MAX_POSITION;i++) { + p = positions.at(i); + if (p==0) continue; + + if (p->actType == ANIMATION_STOPPED || + p->actAnimation ==0) continue; + + p->actStep += p->actDir; + if (p->actStep <= -1) { + p->actDir = 1; + p->actStep = 1; + doAnimation = true; + } + else if (p->actStep >= p->actAnimation->steps) { + if (p->actType == ANIMATION_CYCLE) { + p->actDir = -1; + p->actStep = p->actAnimation->steps -2; + doAnimation = true; + } + else if (p->actType == ANIMATION_LOOP) { + p->actStep = 1; /*skip first frame for smooth animation */ + doAnimation = true; + } + else { + p->actType = ANIMATION_STOPPED; + p->actAnimation = 0; + emit animationFinished(i); + } + } + else { + doAnimation = true; + } + + /* Update Pixmap */ + xReal = (w + p->x * realSize / 500 - Ball::w() )/2; + yReal = (h + p->y * realSize / 500 - Ball::h() )/2; + if (p->actAnimation==0 || p->actStep==-1) { + if (p->def !=0 ) + bitBlt( this, xReal, yReal, p->def->pixmap() ); + } + else { + int s = p->actStep; + if (s>= p->actAnimation->steps) + s = p->actAnimation->steps-1; + Ball* b = p->actAnimation->balls.at(s); + bitBlt( this, xReal, yReal, b->pixmap() ); + } + } + if (!doAnimation) { + isRunning = false; + emit animationsFinished(); + } + else { + timer->start(1000/freq,true); + } + + // repaint( false ); +} + + +/* Ball Test */ + + +BallTest::BallTest( QWidget *parent, const char *name ) + : BallWidget(10,2,parent,name) +{ + int w,h; + + w = h = 150; + resize(w,h); + // Ball::setSize( w/2, h/2, this ); + + Ball *b1 = new Ball( green ); + Ball *b2 = new Ball( yellow ); + Ball *b3 = new Ball( red ); + Ball *b4 = new Ball( red, 3.14/2 ); + + createBlending(0,5,b1,b2); + createBallPosition( 0,250, 250, b1); + + createBlending(1,10,b1,b3); + createBallPosition(1, 250, 750, b1); + + createBlending(2,15,b3,b2); + createBallPosition( 2, 750, 250, b3); + + createBlending(3,20,b3,b4); + createBallPosition(3, 750, 750, b3); +} + +/* +void BallTest::paintEvent( QPaintEvent * ) +{ + bitBlt(this,0,0, b.pixmap()); +} +*/ + +void BallTest::mousePressEvent( QMouseEvent * ) +{ + startAnimation(0,0, ANIMATION_CYCLE); + startAnimation(1,1); + startAnimation(2,2); + startAnimation(3,3, ANIMATION_LOOP); +} + +void BallTest::mouseReleaseEvent( QMouseEvent * ) +{ + stopAnimation(0); + stopAnimation(1); + stopAnimation(3); +} + +/* Test... + +#include <kapplication.h> + +int main(int argc, char *argv[]) +{ + zoom=.52; + flip=.85; + limit=.75; + + KApplication app(argc, argv, "BallTest"); + BallTest top; + + app.setMainWidget( &top ); + top.show(); + return app.exec(); +} + +*/ +#include "Ball.moc" diff --git a/kenolaba/Ball.h b/kenolaba/Ball.h new file mode 100644 index 00000000..1a3e0d28 --- /dev/null +++ b/kenolaba/Ball.h @@ -0,0 +1,155 @@ +/* Class Ball, BallWidget + * + * Online rendered balls with caching + animation widget + * + * Supported static effects + * - ball color + * - ripple texture + * + * Supported animation sequences for now: + * - Color Blending + * - Texture rotate + * + * April 1999, Josef Weidendorfer + */ + +#ifndef _BALL_H_ +#define _BALL_H_ + +#include <qpixmap.h> +#include <qimage.h> +#include <qcolor.h> +#include <qwidget.h> +#include <qptrlist.h> + +/* textures for balls */ +#define TEX_FLAT 0 +#define TEX_RIPPLE 1 + +class Ball { + + public: + Ball(const QColor& c, double a = 0.0, int t=TEX_RIPPLE ); + ~Ball(); + + QPixmap* pixmap(); + + double angle() { return an; } + QColor ballColor() { return bColor; } + void setSpecials(double z, double f, double l) + { zoom = z, flip=f, limit=l; } + + static int w() { return sizeX; } + static int h() { return sizeY; } + static void setSize(int x,int y); + static void setLight(int x=5, int y=3, int z=10, + const QColor& c = QColor(200,230,255) ); + static void setTexture(double c=13., double d=.2); + + private: + + void render(); + static void invalidate(); + + //static QImage back; + static int sizeX, sizeY; + static double lightX, lightY, lightZ; + static QColor lightColor; + static double rippleCount, rippleDepth; + + QPixmap pm; + QColor bColor; + double an, sina, cosa; + double zoom, flip, limit; + int tex; + + Ball *next; + static Ball* first; +}; + + +class BallAnimation { + public: + BallAnimation(int s, Ball*, Ball*); + + int steps; + QPtrList<Ball> balls; +}; + +#define ANIMATION_STOPPED 0 +#define ANIMATION_FORWARD 1 +#define ANIMATION_BACK 2 +#define ANIMATION_LOOP 3 +#define ANIMATION_CYCLE 4 + +class BallPosition { + public: + BallPosition(int xp,int yp, Ball* d); + + int x, y, actStep, actDir, actType; + Ball* def; + BallAnimation* actAnimation; +}; + +#define MAX_POSITION 130 +#define MAX_ANIMATION 20 + +class BallWidget : public QWidget +{ + Q_OBJECT + + public: + BallWidget(int _freq, int bFr, QWidget *parent = 0, const char *name = 0); + ~BallWidget(); + + void createBlending(int, int, Ball* , Ball* ); + void createBallPosition(int, int x, int y, Ball*); + + void startAnimation(int pos, int anim, int type=ANIMATION_FORWARD); + void stopAnimation(int pos); + + void paint(QPaintDevice *); + + virtual void resizeEvent(QResizeEvent *); + virtual void paintEvent(QPaintEvent *); + + signals: + void animationFinished(int); + void animationsFinished(void); + + protected: + void drawBackground(); + + private slots: + void animate(); + + protected: + QMemArray<BallPosition*> positions; + QMemArray<BallAnimation*> animations; + + private: + int freq; + int xStart, yStart, realSize, ballFraction; + bool isRunning; + QTimer *timer; +}; + + +/* Ball Test */ + +class BallTest: public BallWidget +{ + Q_OBJECT +public: + BallTest(QWidget *parent=0, const char *name=0 ); +protected: + void mousePressEvent( QMouseEvent * ); + void mouseReleaseEvent( QMouseEvent * ); + + +}; + + + + +#endif // _BALL_H_ diff --git a/kenolaba/Board.cpp b/kenolaba/Board.cpp new file mode 100644 index 00000000..b8546fbc --- /dev/null +++ b/kenolaba/Board.cpp @@ -0,0 +1,1493 @@ +/* Class Board + * + * with methods for + * - play/take back moves + * - generate allowed moves + * - calculate rating for position + * - search for best move + * + * Josef Weidendorfer, 28.8.97 +*/ + +#include <stdio.h> + +#include <qdatetime.h> +#include <qstrlist.h> + +#include <kconfig.h> +#include <krandomsequence.h> + +#include "Board.h" +#include "EvalScheme.h" + +// #define MYTRACE 1 + +#if 0 +#define CHECK(b) Q_ASSERT(b) +#else +#define CHECK(b) +#endif + + +static int ratedPositions, wonPositions, searchCalled, moveCount; +static int normalCount, pushCount, outCount, cutoffCount; + +/*********************** Class PrincipalVariation *************************/ + +void PrincipalVariation::clear(int d) +{ + int i,j; + + for(i=0;i<maxDepth;i++) + for(j=0;j<maxDepth;j++) { + move[i][j].type = Move::none; + } + actMaxDepth = (d<maxDepth) ? d:maxDepth-1; +} + +void PrincipalVariation::update(int d, Move& m) +{ + int i; + + if (d>actMaxDepth) return; + for(i=d+1;i<=actMaxDepth;i++) { + move[d][i]=move[d+1][i]; + move[d+1][i].type = Move::none; + } + move[d][d]=m; +} + + + +/****************************** Class Board ****************************/ + + +/* Board for start of a game */ +int Board::startBoard[]={ + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 1, 1, 1, 1, 1, 10, 10, 10, 10, 10, + 10, 1, 1, 1, 1, 1, 1, 10, 10, 10, 10, + 10, 0, 0, 1, 1, 1, 0, 0, 10, 10, 10, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 10, 10, 10, 0, 0, 2, 2, 2, 0, 0, 10, + 10, 10, 10, 10, 2, 2, 2, 2, 2, 2, 10, + 10, 10, 10, 10, 10, 2, 2, 2, 2, 2, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 }; + + +/* first centrum of board, then rings around (numbers are indexes) */ +int Board::order[]={ + 60, + 61,72,71,59,48,49, + 62,73,84,83,82,70,58,47,36,37,38,50, + 63,74,85,96,95,94,93,81,69,57,46,35,24,25,26,27,39,51, + 64,75,86,97,108,107,106,105,104,92,80,68,56,45,34,23,12, + 13,14,15,16,28,40,52 }; + +/* See EvalScheme.{h|cpp} + * + // Ratings for fields are calculated out of these values + // (see setFieldValues) + int Board::ringValue[] = { 45, 35, 25, 10, 0 }; + int Board::ringDiff[] = { 0, 10, 10, 8, 5 }; + + // Value added to board rating according to the difference of + // stones in game of player1 and player2 + int Board::stoneValue[]= { 0,-800,-1800,-3000,-4400,-6000 }; + + // Default Values for moves values (see Move.h) + int Board::moveValue[]= { 40,30,30, 15,14,13, 5,5,5, 2,2,2, 1 }; + + // Default Values for inARow values (see Move.h) + int Board::inARowValue[]= { 2, 5, 4, 3 }; +*/ + +int Board::fieldValue[61]; +int Board::direction[]= { -11,1,12,11,-1,-12,-11,1 }; + + +Board::Board() +{ + clear(); + breakOut = bUpdateSpy = false; + spyLevel = 1; + spyDepth = 0; + debug = 0; + realMaxDepth = 1; + _evalScheme = 0; +} + +void Board::setEvalScheme(EvalScheme* scheme) +{ + if (!scheme) + scheme = new EvalScheme( QString("Default") ); + + _evalScheme = scheme; + setFieldValues(); +} + +void Board::setFieldValues() +{ + if (!_evalScheme) return; + + int i, j = 0, k = 59; + int ringValue[5], ringDiff[5]; + + for(i=0;i<5;i++) { + ringDiff[i] = _evalScheme->ringDiff(i); + ringValue[i] = _evalScheme->ringValue(i); + if (ringDiff[i]<1) ringDiff[i]=1; + } + + fieldValue[0] = ringValue[0]; + for(i=1;i<7;i++) + fieldValue[i] = ringValue[1] + ((j+=k) % ringDiff[1]); + for(i=7;i<19;i++) + fieldValue[i] = ringValue[2] + ((j+=k) % ringDiff[2]); + for(i=19;i<37;i++) + fieldValue[i] = ringValue[3] + ((j+=k) % ringDiff[3]); + for(i=37;i<61;i++) + fieldValue[i] = ringValue[4] + ((j+=k) % ringDiff[4]); +} + + + +void Board::begin(int startColor) +{ + int i; + + for(i=0;i<AllFields;i++) + field[i] = startBoard[i]; + storedFirst = storedLast = 0; + color = startColor; + color1Count = color2Count = 14; + random.setSeed(0); // Initialize random sequence +} + +void Board::clear() +{ + int i; + + for(i=0;i<AllFields;i++) + field[i] = (startBoard[i] == out) ? out: free; + storedFirst = storedLast = 0; + color1Count = color2Count = 0; +} + +/* generate moves starting at field <startField> */ +void Board::generateFieldMoves(int startField, MoveList& list) +{ + int d, dir, c, actField; + bool left, right; + int opponent = (color == color1) ? color2 : color1; + + Q_ASSERT( field[startField] == color ); + + /* 6 directions */ + for(d=1;d<7;d++) { + dir = direction[d]; + + /* 2nd field */ + c = field[actField = startField+dir]; + if (c == free) { + /* (c .) */ + list.insert(startField, d, Move::move1); + continue; + } + if (c != color) + continue; + + /* 2nd == color */ + + left = (field[startField+direction[d-1]] == free); + if (left) { + left = (field[actField+direction[d-1]] == free); + if (left) + /* 2 left */ + list.insert(startField, d, Move::left2); + } + + right = (field[startField+direction[d+1]] == free); + if (right) { + right = (field[actField+direction[d+1]] == free); + if (right) + /* 2 right */ + list.insert(startField, d, Move::right2); + } + + /* 3rd field */ + c = field[actField += dir]; + if (c == free) { + /* (c c .) */ + list.insert(startField, d, Move::move2); + continue; + } + else if (c == opponent) { + + /* 4th field */ + c = field[actField += dir]; + if (c == free) { + /* (c c o .) */ + list.insert(startField, d, Move::push1with2); + } + else if (c == out) { + /* (c c o |) */ + list.insert(startField, d, Move::out1with2); + } + continue; + } + if (c != color) + continue; + + /* 3nd == color */ + + if (left) { + if (field[actField+direction[d-1]] == free) + /* 3 left */ + list.insert(startField, d, Move::left3); + } + + if (right) { + if (field[actField+direction[d+1]] == free) + /* 3 right */ + list.insert(startField, d, Move::right3); + } + + /* 4th field */ + c = field[actField += dir]; + if (c == free) { + /* (c c c .) */ + list.insert(startField, d, Move::move3); + continue; + } + if (c != opponent) + continue; + + /* 4nd == opponent */ + + /* 5. field */ + c = field[actField += dir]; + if (c == free) { + /* (c c c o .) */ + list.insert(startField, d, Move::push1with3); + continue; + } + else if (c == out) { + /* (c c c o |) */ + list.insert(startField, d, Move::out1with3); + continue; + } + if (c != opponent) + continue; + + /* 5nd == opponent */ + + /* 6. field */ + c = field[actField += dir]; + if (c == free) { + /* (c c c o o .) */ + list.insert(startField, d, Move::push2); + } + else if (c == out) { + /* (c c c o o |) */ + list.insert(startField, d, Move::out2); + } + } +} + + +void Board::generateMoves(MoveList& list) +{ + int actField, f; + + for(f=0;f<RealFields;f++) { + actField = order[f]; + if ( field[actField] == color) + generateFieldMoves(actField, list); + } +} + + + +void Board::playMove(const Move& m) +{ + int f, dir, dir2; + int opponent = (color == color1) ? color2:color1; + + CHECK( isConsistent() ); + + if (++storedLast == MvsStored) storedLast = 0; + + /* Buffer full -> delete oldest entry */ + if (storedLast == storedFirst) + if (++storedFirst == MvsStored) storedFirst = 0; + + storedMove[storedLast] = m; + + f = m.field; + CHECK( (m.type >= 0) && (m.type < Move::none)); + CHECK( field[f] == color ); + field[f] = free; + dir = direction[m.direction]; + + switch(m.type) { + case Move::out2: /* (c c c o o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == opponent ); + CHECK( field[f + 4*dir] == opponent ); + CHECK( field[f + 5*dir] == out ); + field[f + 3*dir] = color; + break; + case Move::out1with3: /* (c c c o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == opponent ); + CHECK( field[f + 4*dir] == out ); + field[f + 3*dir] = color; + break; + case Move::move3: /* (c c c .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == free ); + field[f + 3*dir] = color; + break; + case Move::out1with2: /* (c c o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == opponent ); + CHECK( field[f + 3*dir] == out ); + field[f + 2*dir] = color; + break; + case Move::move2: /* (c c .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == free ); + field[f + 2*dir] = color; + break; + case Move::push2: /* (c c c o o .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == opponent ); + CHECK( field[f + 4*dir] == opponent ); + CHECK( field[f + 5*dir] == free ); + field[f + 3*dir] = color; + field[f + 5*dir] = opponent; + break; + case Move::left3: + dir2 = direction[m.direction-1]; + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + dir2] == free ); + CHECK( field[f + dir+dir2] == free ); + CHECK( field[f + 2*dir+dir2] == free ); + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + break; + case Move::right3: + dir2 = direction[m.direction+1]; + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + dir2] == free ); + CHECK( field[f + dir+dir2] == free ); + CHECK( field[f + 2*dir+dir2] == free ); + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + break; + case Move::push1with3: /* (c c c o .) => (. c c c o) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == opponent ); + CHECK( field[f + 4*dir] == free ); + field[f + 3*dir] = color; + field[f + 4*dir] = opponent; + break; + case Move::push1with2: /* (c c o .) => (. c c o) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == opponent ); + CHECK( field[f + 3*dir] == free ); + field[f + 2*dir] = color; + field[f + 3*dir] = opponent; + break; + case Move::left2: + dir2 = direction[m.direction-1]; + CHECK( field[f + dir] == color ); + CHECK( field[f + dir2] == free ); + CHECK( field[f + dir+dir2] == free ); + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + break; + case Move::right2: + dir2 = direction[m.direction+1]; + CHECK( field[f + dir] == color ); + CHECK( field[f + dir2] == free ); + CHECK( field[f + dir+dir2] == free ); + field[f+dir2] = color; + field[f+=dir] = free; + field[f+dir2] = color; + break; + case Move::move1: /* (c .) => (. c) */ + CHECK( field[f + dir] == free ); + field[f + dir] = color; + break; + default: + break; + } + + if (m.isOutMove()) { + if (color == color1) + color2Count--; + else + color1Count--; + } + + /* change actual color */ + color = opponent; + + CHECK( isConsistent() ); + +} + +bool Board::takeBack() +{ + int f, dir, dir2; + int opponent = color; + Move& m = storedMove[storedLast]; + + CHECK( isConsistent() ); + + if (storedFirst == storedLast) return false; + + /* change actual color */ + color = (color == color1) ? color2:color1; + + if (m.isOutMove()) { + if (color == color1) + color2Count++; + else + color1Count++; + } + + f = m.field; + CHECK( field[f] == free ); + field[f] = color; + dir = direction[m.direction]; + + switch(m.type) { + case Move::out2: /* (. c c c o |) => (c c c o o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == color ); + CHECK( field[f + 4*dir] == opponent ); + CHECK( field[f + 5*dir] == out ); + field[f + 3*dir] = opponent; + break; + case Move::out1with3: /* (. c c c |) => (c c c o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == color ); + CHECK( field[f + 4*dir] == out ); + field[f + 3*dir] = opponent; + break; + case Move::move3: /* (. c c c) => (c c c .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == color ); + field[f + 3*dir] = free; + break; + case Move::out1with2: /* (. c c | ) => (c c o |) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == out ); + field[f + 2*dir] = opponent; + break; + case Move::move2: /* (. c c) => (c c .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + field[f + 2*dir] = free; + break; + case Move::push2: /* (. c c c o o) => (c c c o o .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == color ); + CHECK( field[f + 4*dir] == opponent ); + CHECK( field[f + 5*dir] == opponent ); + field[f + 3*dir] = opponent; + field[f + 5*dir] = free; + break; + case Move::left3: + dir2 = direction[m.direction-1]; + CHECK( field[f + dir] == free ); + CHECK( field[f + 2*dir] == free ); + CHECK( field[f + dir2] == color ); + CHECK( field[f + dir+dir2] == color ); + CHECK( field[f + 2*dir+dir2] == color ); + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + break; + case Move::right3: + dir2 = direction[m.direction+1]; + CHECK( field[f + dir] == free ); + CHECK( field[f + 2*dir] == free ); + CHECK( field[f + dir2] == color ); + CHECK( field[f + dir+dir2] == color ); + CHECK( field[f + 2*dir+dir2] == color ); + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + break; + case Move::push1with3: /* (. c c c o) => (c c c o .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == color ); + CHECK( field[f + 4*dir] == opponent ); + field[f + 3*dir] = opponent; + field[f + 4*dir] = free; + break; + case Move::push1with2: /* (. c c o) => (c c o .) */ + CHECK( field[f + dir] == color ); + CHECK( field[f + 2*dir] == color ); + CHECK( field[f + 3*dir] == opponent ); + field[f + 2*dir] = opponent; + field[f + 3*dir] = free; + break; + case Move::left2: + dir2 = direction[m.direction-1]; + CHECK( field[f + dir] == free ); + CHECK( field[f + dir2] == color ); + CHECK( field[f + dir+dir2] == color ); + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + break; + case Move::right2: + dir2 = direction[m.direction+1]; + CHECK( field[f + dir] == free ); + CHECK( field[f + dir2] == color ); + CHECK( field[f + dir+dir2] == color ); + field[f+dir2] = free; + field[f+=dir] = color; + field[f+dir2] = free; + break; + case Move::move1: /* (. c) => (c .) */ + CHECK( field[f + dir] == color ); + field[f + dir] = free; + break; + default: + break; + } + + if (--storedLast < 0) storedLast = MvsStored-1; + + CHECK( isConsistent() ); + + return true; +} + +int Board::movesStored() +{ + int c = storedLast - storedFirst; + if (c<0) c+= MvsStored; + return c; +} + + +/** countFrom + * + * Used for board evaluation to count allowed move types and + * connectiveness. VERY similar to move generation. + * + * Returns number of found moves + */ +void Board::countFrom(int startField, int color, + MoveTypeCounter& TCounter, + InARowCounter& CCounter) +{ + int d, dir, c, actField, c2; + bool left, right; + + /* 6 directions */ + for(d=1;d<7;d++) { + dir = direction[d]; + + /* 2nd field */ + c = field[actField = startField+dir]; + if (c == free) { + TCounter.incr( Move::move1 ); + continue; + } + + if (c != color) + continue; + + /* 2nd == color */ + + CCounter.incr( InARowCounter::inARow2 ); + + /* left side move 2 */ + left = (field[startField+direction[d-1]] == free); + if (left) { + left = (field[actField+direction[d-1]] == free); + if (left) + TCounter.incr( Move::left2 ); + } + + /* right side move 2 */ + right = (field[startField+direction[d+1]] == free); + if (right) { + right = (field[actField+direction[d+1]] == free); + if (right) + TCounter.incr( Move::right2 ); + } + + /* 3rd field */ + c = field[actField += dir]; + if (c == free) { + /* (c c .) */ + TCounter.incr( Move::move2 ); + continue; + } + else if (c == out) { + continue; + } + else if (c != color) { + + /* 4th field */ + c = field[actField += dir]; + if (c == free) { + /* (c c o .) */ + TCounter.incr( Move::push1with2 ); + } + else if (c == out) { + /* (c c o |) */ + TCounter.incr( Move::out1with2 ); + } + continue; + } + + /* 3nd == color */ + + CCounter.incr( InARowCounter::inARow3 ); + + /* left side move 3 */ + if (left) { + left = (field[actField+direction[d-1]] == free); + if (left) + TCounter.incr( Move::left3 ); + } + + /* right side move 3 */ + if (right) { + right = (field[actField+direction[d+1]] == free); + if (right) + TCounter.incr( Move::right3 ); + } + + /* 4th field */ + c = field[actField += dir]; + if (c == free) { + /* (c c c .) */ + TCounter.incr( Move::move3 ); + continue; + } + else if (c == out) { + continue; + } + else if (c != color) { + + /* 4nd == opponent */ + + /* 5. field */ + c2 = field[actField += dir]; + if (c2 == free) { + /* (c c c o .) */ + TCounter.incr( Move::push1with3 ); + continue; + } + else if (c2 == out) { + /* (c c c o |) */ + TCounter.incr( Move::out1with3 ); + continue; + } + if (c2 != c) + continue; + + /* 5nd == opponent */ + + /* 6. field */ + c2 = field[actField += dir]; + if (c2 == free) { + /* (c c c o o .) */ + TCounter.incr( Move::push2 ); + } + else if (c2 == out) { + /* (c c c o o |) */ + TCounter.incr( Move::out2 ); + } + + continue; + } + + /* 4nd == color */ + + CCounter.incr( InARowCounter::inARow4 ); + + /* 5th field */ + c = field[actField += dir]; + if (c != color) + continue; + + /* 4nd == color */ + + CCounter.incr( InARowCounter::inARow5 ); + } +} + +/** indent + * + * Internal: for debugging output only + */ +void indent(int d) +{ + char tmp[]=" "; + tmp[d*3] = 0; + printf("> %s",tmp); +} + + + +/** validState + * + * Check for a valid board position to play from: + * (1) Number of balls for each color has to be between 9 and 14 + * (2) There must be a move possible for actual color + */ +int Board::validState() +{ + MoveTypeCounter tc; + InARowCounter cc; + + int c1 = 0, c2 = 0; + int i,j, moveCount, res; + + for(i=0;i<AllFields;i++) { + j=field[i]; + if (j == color1) c1++; + if (j == color2) c2++; + if (j == color) + countFrom( i, color, tc, cc); + } + + color1Count = c1; + color2Count = c2; + moveCount = tc.sum(); + + if (c1==0 && c2==0) + res = empty; + else if (c1>8 && c1<15 && c2>8 && c2<15 && moveCount>0 ) + res = valid; + else + res = invalid; + +#ifdef MYTRACE + if (spyLevel>2) { + indent(spyDepth); + printf("Valid: %s (Color1 %d, Color2 %d, moveCount of %d: %d)\n", + (res == empty) ? "empty" : (res==valid) ? "valid":"invalid", + c1,c2,color,moveCount); + } +#endif + + return res; +} + + + +/* Calculate a evaluation for actual position + * + * A higher value means a better position for opponent + * NB: This means a higher value for better position of + * 'color before last move' + */ +int Board::calcEvaluation() +{ + MoveTypeCounter tcColor, tcOpponent; + InARowCounter ccColor, ccOpponent; + + int f,i,j; + + /* different evaluation types */ + int fieldValueSum=0, stoneValueSum=0; + int moveValueSum=0, inARowValueSum=0; + int valueSum; + + /* First check simple winner condition */ + if (color1Count <9) + valueSum = (color==color1) ? 16000 : -16000; + else if (color2Count <9) + valueSum = (color==color2) ? 16000 : -16000; + else { + + /* Calculate fieldValueSum and count move types and connectivity */ + for(i=0;i<RealFields;i++) { + j=field[f=order[i]]; + if (j == free) continue; + if (j == color) { + countFrom( f, j, tcColor, ccColor ); + fieldValueSum -= fieldValue[i]; + } + else { + countFrom( f, j, tcOpponent, ccOpponent ); + fieldValueSum += fieldValue[i]; + } + } + + /* If color can't do any moves, opponent wins... */ + if (tcColor.sum() == 0) + valueSum = 16000; + else { + + for(int t=0;t < Move::typeCount;t++) + moveValueSum += _evalScheme->moveValue(t) * + (tcOpponent.get(t) - tcColor.get(t)); + + for(int i=0;i < InARowCounter::inARowCount;i++) + inARowValueSum += _evalScheme->inARowValue(i) * + (ccOpponent.get(i) - ccColor.get(i)); + + if (color == color2) + stoneValueSum = _evalScheme->stoneValue(14 - color1Count) - + _evalScheme->stoneValue(14 - color2Count); + else + stoneValueSum = _evalScheme->stoneValue(14 - color2Count) - + _evalScheme->stoneValue(14 - color1Count); + + valueSum = fieldValueSum + moveValueSum + + inARowValueSum + stoneValueSum; + } + } + +#ifdef MYTRACE + if (spyLevel>2) { + indent(spyDepth); + printf("Eval %d (field %d, move %d, inARow %d, stone %d)\n", + valueSum, fieldValueSum, moveValueSum, + inARowValueSum, stoneValueSum ); + } +#endif + + return valueSum; +} + +bool Board::isConsistent() +{ + int c1 = 0, c2 = 0; + int i,j; + + for(i=0;i<RealFields;i++) { + j=field[order[i]]; + if (j == color1) c1++; + if (j == color2) c2++; + } + return (color1Count == c1 && color2Count == c2); +} + +void Board::changeEvaluation() +{ + int i,tmp; + + /* innermost ring */ + tmp=fieldValue[1]; + for(i=1;i<6;i++) + fieldValue[i] = fieldValue[i+1]; + fieldValue[6] = tmp; + + tmp=fieldValue[7]; + for(i=7;i<18;i++) + fieldValue[i] = fieldValue[i+1]; + fieldValue[18] = tmp; + + tmp=fieldValue[19]; + for(i=19;i<36;i++) + fieldValue[i] = fieldValue[i+1]; + fieldValue[36] = tmp; + + /* the outermost ring */ + tmp=fieldValue[37]; + for(i=37;i<60;i++) + fieldValue[i] = fieldValue[i+1]; + fieldValue[60] = tmp; +} + +/* +void Board::showHist() +{ + Move m1, m2; + + printf("After playing "); + (m1=lastMove()).print(); + print(); + printf("TakeBack "); m1.print(); + takeBack(); print(); + printf("TakeBack "); + (m2=lastMove()).print(); + takeBack(); print(); + printf("Play "); m2.print(); + playMove(m2); print(); + printf("Play "); m1.print(); + playMove(m1); print(); + getchar(); +} +*/ + + + +/* + * We always try the maximize the board value + */ +int Board::search(int depth, int alpha, int beta) +{ + int actValue= -14999+depth, value; + Move m; + MoveList list; + bool depthPhase, doDepthSearch; + + searchCalled++; + + /* We make a depth search for the following move types... */ + int maxType = (depth < maxDepth-1) ? Move::maxMoveType() : + (depth < maxDepth) ? Move::maxPushType() : + Move::maxOutType(); + + generateMoves(list); + +#ifdef MYTRACE + + int oldRatedPositions; + int oldWonPositions; + int oldSearchCalled; + int oldMoveCount; + int oldNormalCount; + int oldPushCount; + int oldOutCount; + int oldCutoffCount; + + spyDepth = depth; + + moveCount += list.getLength(); + + /* + if (spyLevel>1) { + indent(depth); + printf("%s (%6d .. %6d) MaxType %s\n", depth, + (color==color1)?"O":"X", alpha,beta, + (depth < maxDepth-1) ? "Moving" : + (depth < maxDepth)? "Pushing" : "PushOUT" ); + } + */ +#endif + + /* check for a old best move in main combination */ + if (inPrincipalVariation) { + m = pv[depth]; + + if ((m.type != Move::none) && + (!list.isElement(m, 0, true))) + m.type = Move::none; + + if (m.type == Move::none) + inPrincipalVariation = false; + +#ifdef MYTRACE + else { + if (spyLevel>1) { + indent(spyDepth); + printf("Got from pv !\n" ); + } + } +#endif + } + + // first, play all moves with depth search + depthPhase = true; + + while (1) { + + // get next move + if (m.type == Move::none) { + if (depthPhase) + depthPhase = list.getNext(m, maxType); + if (!depthPhase) + if (!list.getNext(m, Move::none)) break; + } + // we could start with a non-depth move from principal variation + doDepthSearch = depthPhase && (m.type <= maxType); + +#ifdef MYTRACE + + if (m.isOutMove()) outCount++; + else if (m.isPushMove()) pushCount++; + else normalCount++; + + if (doDepthSearch) { + oldRatedPositions = ratedPositions; + oldWonPositions = wonPositions; + oldSearchCalled = searchCalled; + oldMoveCount = moveCount; + oldNormalCount = normalCount; + oldPushCount = pushCount; + oldOutCount = outCount; + oldCutoffCount = cutoffCount; + + if (spyLevel>1) { + indent(spyDepth); + printf("%s [%6d .. %6d] ", + (color==color1)?"O":"X", alpha,beta); + m.print(); + printf("\n"); + } + +#ifdef SPION + if (bUpdateSpy) emit update(depth, 0, m, false); +#endif + } +#endif + + playMove(m); + if (!isValid()) { + /* Possibility (1) to win: Ball Count <9 */ + value = 14999-depth; + // value = ((depth < maxDepth) ? 15999:14999) - depth; +#ifdef MYTRACE + wonPositions++; +#endif + } + else { + + if (doDepthSearch) { + /* opponent searches for his maximum; but we want the + * minimum: so change sign (for alpha/beta window too!) + */ + value = - search(depth+1,-beta,-alpha); + } + else { + ratedPositions++; + + value = calcEvaluation(); + } + } + takeBack(); + + /* For GUI response */ + if (doDepthSearch && (maxDepth - depth >2)) + emit searchBreak(); + +#ifdef MYTRACE + + if (doDepthSearch) { + spyDepth = depth; + + if (spyLevel>1) { + + indent(spyDepth); + if (oldSearchCalled < searchCalled) { + printf(" %d Calls", searchCalled-oldSearchCalled); + if (cutoffCount>oldCutoffCount) + printf(" (%d Cutoffs)", cutoffCount-oldCutoffCount); + printf(", GenMoves %d (%d/%d/%d played)", + moveCount - oldMoveCount, + normalCount - oldNormalCount, + pushCount-oldPushCount, + outCount-oldOutCount); + printf(", Rate# %d", + ratedPositions+wonPositions + - oldRatedPositions - oldWonPositions); + if (wonPositions > oldWonPositions) + printf(" (%d Won)", wonPositions- oldWonPositions); + printf("\n"); + indent(spyDepth); + } + + printf(" => Rated %d%s\n", + value, + (value>14900) ? ", WON !": + (value>=beta) ? ", CUTOFF !": + (value>actValue) ? ", Best !": ""); + } + } + else { + if (spyLevel>2) { + indent(spyDepth); + printf("%s (%6d .. %6d) %-25s => Rating %6d%s\n", + (color==color1)?"O":"X", alpha,beta, + m.name().latin1(), + value, + (value>14900) ? ", WON !": + (value>=beta) ? ", CUTOFF !": + (value>actValue) ? ", Best !": ""); + } + } + + if (value>=beta) cutoffCount++; +#endif + +#ifdef SPION + if (bUpdateSpy) { + if (value > actValue) + emit updateBest(depth, value, m, value >= beta); + emit update(depth, value, m, true); + } +#endif + if (value > actValue) { + actValue = value; + pv.update(depth, m); + + // Only update best move if not stopping search + if (!breakOut && (depth == 0)) { + _bestMove = m; + + if (bUpdateSpy) { + emit updateBestMove(m, actValue); +#ifdef MYTRACE + if (spyLevel>0) { + int i; + printf("> New pv (Rating %d):", actValue); + for(i=0;i<=maxDepth;i++) { + printf("\n> D %d: %s", + i, pv[i].name().latin1() ); + } + printf("\n>\n"); + } +#endif + } + } + + if (actValue>14900 || actValue >= beta) + return actValue; + + /* maximize alpha */ + if (actValue > alpha) alpha = actValue; + } + + if (breakOut) depthPhase=false; + m.type = Move::none; + } + + return actValue; +} + + +Move& Board::bestMove() +{ + int alpha=-15000,beta=15000; + int nalpha,nbeta, actValue; + + if (!_evalScheme) { + // Use default values if not set + setEvalScheme(); + } + + pv.clear(realMaxDepth); + _bestMove.type = Move::none; + + maxDepth=1; + show = false; + breakOut = false; + spyDepth = 0; + + if (spyLevel>0) + printf("\n> New Search\n>\n"); + + /* iterative deepening loop */ + do { + if (spyLevel>0) + printf("> MaxDepth: %d\n>\n", maxDepth); + + /* searches on same level with different alpha/beta windows */ + while(1) { + if (spyLevel>0) + printf("> AB-Window: (%d ... %d)\n>\n", alpha, beta); + + nalpha=alpha, nbeta=beta; + inPrincipalVariation = (pv[0].type != Move::none); + + /* Statistics */ + searchCalled = 0; + moveCount = 0; + ratedPositions = 0; + wonPositions = 0; + normalCount = 0; + pushCount = 0; + outCount = 0; + cutoffCount = 0; + + actValue = search(0,alpha,beta); + + if (spyLevel>0) + { + int i; + if (spyLevel>1) + printf(">\n"); + printf("> Got PV with Rating %d:",actValue); + for(i=0;i<=maxDepth;i++) { + printf("\n> D %d: ", i); + pv[i].print(); + } + printf("\n>\n"); + + printf("> Search called : %6d / %d Cutoffs\n", + searchCalled, cutoffCount); + printf("> Moves generated : %6d / %d Played\n", + moveCount, normalCount+pushCount+outCount); + printf("> Nrml/Push/Out : %6d / %d / %d\n", + normalCount,pushCount,outCount); + printf("> Positions rated : %6d / %d Won\n>\n", + ratedPositions+wonPositions, wonPositions); + + } + + if (actValue > 14900 || actValue < -14900) + breakOut=true; + + /* Don't break out if we haven't found a move */ + if (_bestMove.type == Move::none) + breakOut=false; + + if (breakOut) break; + + // widen alpha-beta window if needed + if (actValue <= nalpha) { + alpha = -15000; + if (beta<15000) beta=actValue+1; + continue; + } + if (actValue >= nbeta) { + if (alpha > -15000) alpha = actValue-1; + beta=15000; + continue; + } + break; + } + + /* Window in both directions cause of deepening */ + alpha=actValue-200, beta=actValue+200; + + if (breakOut) break; + + maxDepth++; + } + while(maxDepth <= realMaxDepth); + + /* If Spy is On, we want replayable search: don't change rating! */ + if (spyLevel==0) + changeEvaluation(); + else { + printf(">>> Got Move : "); + pv[0].print(); + printf("\n\n"); + } + + spyDepth = 0; + + return _bestMove; +} + +Move Board::randomMove() +{ + Move m; + MoveList list; + + generateMoves(list); + int l = list.getLength(); + + int j = random.getLong(l) +1; + + while(j != 0) { + list.getNext(m, Move::none); + j--; + } + + return m; +} + + +void Board::print(int ) +{ + int row,i; + char spaces[]=" "; + const char *z[]={". ","O ","X ", "o ", "x "}; + + printf("\n -----------\n"); + for(row=0;row<4;row++) { + printf("%s/ ",spaces+row); + for(i=0;i<5+row;i++) printf("%s",z[field[row*11+12+i]]); + printf("\\\n"); + } + printf(" | "); + for(i=0;i<9;i++) printf("%s",z[field[56+i]]); + printf("|\n"); + for(row=0;row<4;row++) { + printf("%s\\ ",spaces+3-row); + for(i=0;i<8-row;i++) printf("%s",z[field[68+row*12+i]]); + printf("/\n"); + } + printf(" ----------- O: %d X: %d\n", + color1Count, color2Count); +} + +QString Board::getASCIIState(int moveNo) +{ + QString state, tmp; + + int row,i; + char spaces[]=" "; + const char *z[]={". ","O ","X ", "o ", "x "}; + + state += tmp.sprintf("\n #%-3d ----------- O: %d X: %d\n", + moveNo, color1Count, color2Count); + for(row=0;row<4;row++) { + state += tmp.sprintf("%s/ ",spaces+row); + for(i=0;i<5+row;i++) + state += tmp.sprintf("%s",z[field[row*11+12+i]]); + state += "\\\n"; + } + state += " | "; + for(i=0;i<9;i++) + state += tmp.sprintf("%s",z[field[56+i]]); + state += "|\n"; + for(row=0;row<4;row++) { + state += tmp.sprintf("%s\\ ",spaces+3-row); + for(i=0;i<8-row;i++) + state += tmp.sprintf("%s",z[field[68+row*12+i]]); + state += "/\n"; + } + state += " -----------\n\n"; + + return state; +} + +int Board::setASCIIState(const QString& state) +{ + int moveNo=-1, index; + int len = state.length(); + int color1Count = 0; + int color2Count = 0; + + /* get moveNo if supplied */ + if ((index = state.find("#"))>=0) + moveNo = state.mid(index+1,3).toInt(); + + int f=12, row=0, rowEnd = 17; + char c = ' '; + + index=state.find("/"); + + while(index>=0) { + + while(++index<len) { + c = state[index].latin1(); + if (c !=' ') break; + } + + if (c=='.') field[f++] = 0; + else if (c=='o' || c=='O') { + // printf(".. F %d: O\n", f); + field[f++] = 1; + color1Count++; + } + else if (c=='x' || c=='X') { + // printf(".. F %d: X\n", f); + field[f++] = 2; + color2Count++; + } + else { + if (index >= len) index=-1; + continue; + } + + if (f == rowEnd) { + row++; + if (row <4) { + index = state.find("/",index); + f = 12 + row*11; + rowEnd = row*12+17; + } + else if (row==4) { + index = state.find("|",index); + f = 56; + rowEnd = 65; + } + else if (row <9) { + index = state.find("\\",index); + f = 8 + row*12; + rowEnd = 21 + row*11; + } + else + break; + // printf("Row %d: %d - %d, Idx %d\n", row, f, rowEnd, index); + } + } + return moveNo; +} + + +QString Board::getState(int moveNo) +{ + QString state; + QString entry, tmp; + int i; + + /* Color + Counts */ + state += (char) ('A' + moveNo /25 ); + state += (char) ('A' + moveNo %25 ); + state += (char) ('A' + color1Count); + state += (char) ('A' + color2Count); + state += (char) ('A' + 4*color + field[order[0]]); + + /* Board (field values can be 0-3; 2 fields coded in one char */ + for(i=1;i<61;i+=2) + state+= (char) ('A' + 4*field[order[i]] + field[order[i+1]] ); + + /* -> 35 chars */ + return state; +} + +int Board::setState(QString& _state) +{ + int moveNo; + const char *state = _state.ascii(); + + if (_state.length() != 35) return 0; + + moveNo = 25*(state[0] - 'A') + (state[1] - 'A'); + color1Count = state[2] - 'A'; + color2Count = state[3] - 'A'; + color = (state[4] - 'A') / 4; + field[order[0]] = (state[4] - 'A') %4; + + int i = 1; + for(int j = 5; j<35; j++) { + int w = state[j] - 'A'; + field[order[i++]] = w/4; + field[order[i++]] = w % 4; + } + return moveNo; +} + +void Board::setSpyLevel(int level) +{ + spyLevel = level; +} +#include "Board.moc" diff --git a/kenolaba/Board.h b/kenolaba/Board.h new file mode 100644 index 00000000..61871d1f --- /dev/null +++ b/kenolaba/Board.h @@ -0,0 +1,198 @@ +/* Class Board - represents a game state + * + * Josef Weidendorfer, 28.8.97 +*/ + +#ifndef _BOARD_H_ +#define _BOARD_H_ + +#include <qobject.h> +#include <krandomsequence.h> +#include "Move.h" + +class KConfig; +class EvalScheme; + +/* Class for best moves so far */ +class PrincipalVariation +{ +public: + PrincipalVariation() + { clear(1); } + + enum { maxDepth = 10 }; + + bool hasMove(int d) + { return (d>actMaxDepth) ? + false : (move[0][d].type != Move::none); } + + Move& operator[](int i) + { return (i<0 || i>=maxDepth) ? move[0][0] : move[0][i]; } + + void update(int d, Move& m); + void clear(int d); + void setMaxDepth(int d) + { actMaxDepth = (d>maxDepth) ? maxDepth-1 : d; } + +private: + Move move[maxDepth][maxDepth]; + int actMaxDepth; + +}; + + +class Board : public QObject +{ + Q_OBJECT + + public: + Board(); + ~Board() {} + + /* different states of one field */ + enum { + out = 10, free = 0, + color1, color2, color1bright, color2bright + }; + enum { AllFields = 121, /* visible + ring of unvisible around */ + RealFields = 61, /* number of visible fields */ + MvsStored = 100 }; + + int debug; + + /* fill Board with defined values */ + void begin(int startColor); /* start of a game */ + void clear(); /* empty board */ + + /* fields can't be changed ! */ + int operator[](int no) const; + + int actColor() const + { return color; } + + /* Generate list of allowed moves for player with <color> + * Returns a calculated value for actual position */ + void generateMoves(MoveList& list); + + /* Functions handling moves + * played moves can be taken back (<MvsStored> moves are remembered) */ + void playMove(const Move& m); + bool takeBack(); /* if not remembered, do nothing */ + int movesStored(); /* return how many moves are remembered */ + + Move& lastMove() + { return storedMove[storedLast]; } + + void showHist(); + + /* Evaluation Scheme to use */ + void setEvalScheme( EvalScheme* scheme = 0); + EvalScheme* evalScheme() { return _evalScheme; } + + /* Calculate a value for actual position + * (greater if better for color1) */ + int calcEvaluation(); + + /* Evalution is based on values which can be changed + * a little (so computer's moves aren't always the same) */ + void changeEvaluation(); + + void setActColor(int c) { color=c; } + void setColor1Count(int c) { color1Count = c; } + void setColor2Count(int c) { color2Count = c; } + void setField(int i, int v) { field[i] = v; } + + void setSpyLevel(int); + + int getColor1Count() { return color1Count; } + int getColor2Count() { return color2Count; } + + enum { empty=0, valid, invalid }; + int validState(); + bool isValid() { return (color1Count>8 && color2Count>8); } + + /* Check that color1Count & color2Count is consisten with board */ + bool isConsistent(); + + /* Searching best move: alpha/beta search */ + void setDepth(int d) + { realMaxDepth = d+1; } + Move& bestMove(); + + /* next move in main combination */ + Move& nextMove() { return pv[1]; } + + Move randomMove(); + void stopSearch() { breakOut = true; } + + /* Compressed ASCII representation */ + QString getState(int); + int setState(QString&); + + /* Readable ASCII representation */ + QString getASCIIState(int); + int setASCIIState(const QString&); + + void updateSpy(bool b) { bUpdateSpy = b; } + + /* simple terminal view of position */ + void print(int); + + static int fieldDiffOfDir(int d) { return direction[d]; } + + signals: + void searchBreak(); + void updateBestMove(Move&,int); + + void update(int,int,Move&,bool); + void updateBest(int,int,Move&,bool); + + private: + void setFieldValues(); + + /* helper function for generateMoves */ + void generateFieldMoves(int, MoveList&); + /* helper function for calcValue */ + void countFrom(int,int, MoveTypeCounter&, InARowCounter&); + /* helper functions for bestMove (recursive search!) */ + int search(int, int, int); + int search2(int, int, int); + + KRandomSequence random; /* random generator */ + + int field[AllFields]; /* actual board */ + int color1Count, color2Count; + int color; /* actual color */ + Move storedMove[MvsStored]; /* stored moves */ + int storedFirst, storedLast; /* stored in ring puffer manner */ + + /* for search */ + PrincipalVariation pv; + Move _bestMove; + bool breakOut, inPrincipalVariation, show, bUpdateSpy; + int maxDepth, realMaxDepth; + + int spyLevel, spyDepth; + EvalScheme* _evalScheme; + + /* ratings; semi constant - are rotated by changeRating() */ + static int fieldValue[RealFields]; + + /* constant arrays */ + static int startBoard[AllFields]; + static int order[RealFields]; + static int direction[8]; + + // static int stoneValue[6]; + // static int moveValue[Move::typeCount]; + // static int connectValue[ConnectCounter::connectCount]; + // static int ringValue[5], ringDiff[5]; +}; + + +inline int Board::operator[](int no) const +{ + return (no<12 || no>120) ? out : field[no]; +} + +#endif diff --git a/kenolaba/BoardWidget.cpp b/kenolaba/BoardWidget.cpp new file mode 100644 index 00000000..9d420cc3 --- /dev/null +++ b/kenolaba/BoardWidget.cpp @@ -0,0 +1,1027 @@ +/* Implementation of class BoardWidget + * + * This class handles rendering of a Board to a KDE/QT widget, + * shows moves (with a timer) and manages input of moves + * + * Josef Weidendorfer, 9/97 + */ + +#include <qbitmap.h> +#include <qpainter.h> +#include <qcursor.h> + +#include <klocale.h> +#include <kdebug.h> + +#ifdef HAVE_KIR +#include <kimgrender.h> +#endif + +#include "Board.h" +#include "BoardWidget.h" + +/* Cursors */ +#include "bitmaps/Arrow1" +#include "bitmaps/Arrow1Mask" +#include "bitmaps/Arrow2" +#include "bitmaps/Arrow2Mask" +#include "bitmaps/Arrow3" +#include "bitmaps/Arrow3Mask" +#include "bitmaps/Arrow4" +#include "bitmaps/Arrow4Mask" +#include "bitmaps/Arrow5" +#include "bitmaps/Arrow5Mask" +#include "bitmaps/Arrow6" +#include "bitmaps/Arrow6Mask" + +BoardWidget::BoardWidget(Board& b, QWidget *parent, const char *name) + : BallWidget(10,9,parent, name), board(b) +{ + pList =0; + gettingMove = false; + editMode = false; + renderMode = false; + +#ifdef HAVE_KIR + m_backRenderer = KIRManager::attach( this, "Background" ); + connect( m_backRenderer, SIGNAL(rendered()), + this, SLOT(drawBoard()) ); +#endif + + /* setup cursors */ + +#define createCursor(bitmap,name) \ + static QBitmap bitmap(bitmap##_width, bitmap##_height, \ + (unsigned char *) bitmap##_bits, TRUE); \ + static QBitmap bitmap##Mask(bitmap##Mask_width, bitmap##Mask_height, \ + (unsigned char *) bitmap##Mask_bits, TRUE); \ + name = new QCursor(bitmap, bitmap##Mask, bitmap##_x_hot, bitmap##_y_hot); + + createCursor(Arrow1, arrow[1]); + createCursor(Arrow2, arrow[2]); + createCursor(Arrow3, arrow[3]); + createCursor(Arrow4, arrow[4]); + createCursor(Arrow5, arrow[5]); + createCursor(Arrow6, arrow[6]); + + setCursor(crossCursor); + + // boardColor = new QColor("lightblue"); + boardColor = new QColor(backgroundColor()); + redColor = new QColor("red2"); + yellowColor = new QColor("yellow2"); + redHColor = new QColor("orange"); + yellowHColor = new QColor("green"); + + initBalls(); + + updatePosition(); +} + +BoardWidget::~BoardWidget() +{ + for(int i=1; i<7; i++) + if (arrow[i] != 0) + delete arrow[i]; + +#ifdef HAVE_KIR + if (m_backRenderer != 0) + delete m_backRenderer; +#endif + delete boardColor; + delete redColor; + delete yellowColor; + delete redHColor; + delete yellowHColor; + +} + +void BoardWidget::configure() +{ +#ifdef HAVE_KIR + if (m_backRenderer != 0) { + m_backRenderer->setup(); + m_backRenderer->manager()->saveModules(); + } +#endif +} + + +void BoardWidget::createPos(int pos, int i, int j, Ball* b) +{ + int x=(465*(2*(i)-(j))/9); + int y=(500*19*(j)/100); + createBallPosition(pos, x,y, b); +} + +void BoardWidget::initBalls() +{ + n2 = new Ball( *yellowColor ); + h2 = new Ball( *yellowHColor ); + d2 = new Ball( *yellowHColor, 3.14/2 ); + + n1 = new Ball( *redColor ); + h1 = new Ball( *redHColor ); + d1 = new Ball( *redHColor, 3.14/2 ); + + // e = new Ball( white,0,0 ); + // e->setSpecials(.6,.85,.75); + + createBlending(1,10,h1,n1); + createBlending(2,10,h1,d1); + createBlending(3,10,h2,n2); + createBlending(4,10,h2,d2); + + int i,j,pos; + for(j=-4;j<5;j++) + for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) { + pos=60+j*11+i; + createPos(pos, i,j, 0); + } + + pos = 0; + /* the outer marks of color1 */ + for(i=0;i<3;i++) createPos(pos++, -6, i-4, 0 ); + for(i=0;i<3;i++) createPos(pos++, 2+i, i-4, 0 ); + + /* the outer marks of color2 */ + for(i=0;i<3;i++) createPos(pos++, 6, 4-i, 0 ); + for(i=0;i<3;i++) createPos(pos++, -2-i, 4-i, 0 ); +} + +void BoardWidget::resizeEvent(QResizeEvent *e) +{ + drawBoard(); + BallWidget::resizeEvent(e); +} + +void BoardWidget::moveEvent(QMoveEvent*) +{ + drawBoard(); +} + +void BoardWidget::paintEvent(QPaintEvent *) +{ + if (renderMode) { + pm = boardPM; + BallWidget::paint(&pm); + } + else + draw(); + bitBlt(this, 0, 0, &pm); +} + + +void drawShadedHexagon(QPainter *p, int x, int y, int r, int lineWidth, + const QColorGroup& g, bool sunken) +{ + int dx=r/2, dy=(r*87)/100; + int y1=y-dy, y2=y+dy; + int i; + + QPen oldPen = p->pen(); + + p->setPen(sunken ? g.midlight() : g.dark()); + + for(i=0; i<lineWidth; i++) { + p->drawLine( x-i+dx, y-dy, x+2*dx-i, y); + p->drawLine( x+2*dx-i, y, x-i+dx, y+dy); + p->drawLine( x-i+dx, y1+i, x+i-dx, y1+i); + } + + p->setPen(sunken ? g.dark() : g.midlight()); + + for(i=0; i<lineWidth; i++) { + p->drawLine( x+i-dx, y-dy, x+i-2*dx, y); + p->drawLine( x+i-2*dx, y, x+i-dx, y+dy); + p->drawLine( x-i+dx, y2-i, x+i-dx, y2-i); + } + + p->setPen(oldPen); +} + + +void drawColor(QPainter *p, int x, int y, int r, QColor* c) +{ + QColor w("white"); + QPalette pal(*c); + + QPen oldPen = p->pen(); + QBrush oldBrush = p->brush(); + + p->setBrush(pal.active().dark()); + p->setPen(pal.active().dark()); + p->drawEllipse( x-r - 10,y-r +5, 2*r,2*r); + + p->setBrush(pal.active().mid()); + p->setPen(pal.active().mid()); + p->drawEllipse( x-r,y-r, 2*r,2*r); + + p->setBrush(pal.active().light()); + p->setPen(pal.active().light()); + p->drawEllipse( x-r/3, y-r/3, 4*r/3,4*r/3); + + p->setBrush(w); + p->setPen(w); + p->drawEllipse( x+r/3, y+r/3, r/3,r/3); + + p->setPen(oldPen); + p->setBrush(oldBrush); +} + + +void BoardWidget::drawBoard() +{ + boardPM.resize(width(), height()); + boardPM.fill(this, 0,0); + +#ifndef HAVE_KIR + QColorGroup g = QPalette( *boardColor ).active(); + QColorGroup g2 = QWidget::colorGroup(); + + int boardSize = width() *10/12; + if (boardSize > height()) boardSize = height(); + + QPainter p; + p.begin(&boardPM); + p.setBrush(g2.brush(QColorGroup::Mid)); + + QWMatrix m; + QPoint cp = rect().center(); + m.translate(cp.x(), cp.y()); + m.scale(boardSize/1100.0, boardSize/1000.0); + + m.rotate(0); + + p.setWorldMatrix(m); + + /* draw field */ + + int i,j; + + QPointArray a; + int dx=520 /2, dy=(520 *87)/100; + a.setPoints(6, -dx,-dy, dx,-dy, 2*dx,0, dx,dy, -dx,dy, -2*dx,0 ); + p.drawPolygon(a); + + drawShadedHexagon(&p, 0,0, 505, 1, g, false); + drawShadedHexagon(&p, 0,0, 512, 3, g, true); + drawShadedHexagon(&p, 0,0, 525, 5, g2, true); + +#define xpos(i,j) (495*(2*(i)-(j))/9) +#define ypos(j) (500*19*(j)/100) + + for(j=-4;j<5;j++) + for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) { + int x=xpos(i,j); + int y=ypos(j); + + drawShadedHexagon(&p, x,y, 50, 2, g, true); + drawShadedHexagon(&p, x,y, 30, 1, g, false); + } + p.end(); +#endif + draw(); +} + +void BoardWidget::renderBalls(bool r) +{ + renderMode=r; + draw(); +} + +void BoardWidget::updateBalls() +{ + int i,j; + + for(j=-4;j<5;j++) + for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) { + int pos = 60+j*11+i; + int w=field[60+j*11+i]; + + if (w==Board::color1) { + if (positions[pos]->def != n1) { + positions[pos]->def= n1; + startAnimation(pos,1, ANIMATION_FORWARD); + } + else { + stopAnimation(pos); + } + } + else if (w==Board::color1bright) + startAnimation(pos,2,ANIMATION_LOOP); + else if (w==Board::color2) { + if (positions[pos]->def != n2) { + positions[pos]->def= n2; + startAnimation(pos,3,ANIMATION_FORWARD); + } + else { + stopAnimation(pos); + } + } + else if (w==Board::color2bright) + startAnimation(pos,4,ANIMATION_LOOP); + else if (w==Board::free) { + positions[pos]->def= 0; + positions[pos]->actAnimation = 0; + // stopAnimation(pos); + } + } + + for(i=0;i<6;i++) + positions[i]->def= ((14-color1Count)>i && color1Count>0) ? n1:0; + + for(i=6;i<12;i++) + positions[i]->def= ((14-color2Count)>i-6 && color2Count>0) ? n2:0; + +} + +void BoardWidget::draw() +{ + if (boardPM.isNull()) + return; + + pm = boardPM; + + if (renderMode) { + updateBalls(); + repaint(false); + return; + } + + int boardSize = width() *10/12; + if (boardSize > height()) boardSize = height(); + + QPainter p; + p.begin(&pm); + p.setBrush(foregroundColor()); + + QWMatrix m; + QPoint cp = rect().center(); + m.translate(cp.x(), cp.y()); + m.scale(boardSize/1100.0, boardSize/1000.0); + + m.rotate(0); + + p.setWorldMatrix(m); + + /* draw fields */ + + int i,j; + + for(j=-4;j<5;j++) + for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) { + int x=xpos(i,j); + int y=ypos(j); + int w=field[60+j*11+i]; + + if (w==Board::color1) + drawColor(&p, x,y, 35, redColor ); + else if (w==Board::color1bright) + drawColor(&p, x,y, 35, redHColor ); + else if (w==Board::color2) + drawColor(&p, x,y, 35, yellowColor ); + else if (w==Board::color2bright) + drawColor(&p, x,y, 35, yellowHColor ); + } + + if (color1Count >0) { + /* the outer marks of color1 */ + if (color1Count <12) { + for(i=11; i>8 && i>color1Count ;i--) + drawColor(&p, xpos(12-i,7-i)+55, ypos(7-i), 35, redColor ); + } + for(i=14; i>11 && i>color1Count ;i--) + drawColor(&p, xpos(-6,10-i)+55, ypos(10-i), 35, redColor ); + + /* the outer marks of color2 */ + if (color2Count <12) { + for(i=11; i>8 && i>color2Count ;i--) + drawColor(&p, xpos(i-12,i-7)-55, ypos(i-7), 35, yellowColor); + } + for(i=14; i>11 && i>color2Count ;i--) + drawColor(&p, xpos(6,i-10)-55, ypos(i-10), 35, yellowColor); + } + p.end(); + bitBlt(this, 0, 0, &pm); +} + +/** updatePosition + * + * Update my position with that of the <board> member. + * If <updateGUI> is true, draw widget + */ +void BoardWidget::updatePosition(bool updateGUI) +{ + for(int i=0; i<Board::AllFields;i++) + field[i] = board[i]; + color1Count = board.getColor1Count(); + color2Count = board.getColor2Count(); + color = board.actColor(); + boardOK = true; + + if (updateGUI) draw(); +} + + +bool BoardWidget::setEditMode(bool mode) +{ + if (editMode == false && mode==true) { + editMode = true; + } + else if (editMode == true && mode == false) { + editMode = false; + + for(int i=0; i<Board::AllFields;i++) + board.setField( i, field[i]); + board.setColor1Count(color1Count); + board.setColor2Count(color2Count); + + } + return editMode; +} + + +void BoardWidget::clearPosition() +{ + for(int i=0; i<Board::AllFields;i++) + field[i] = 0; + color1Count = color2Count = 0; +} + +void BoardWidget::showMove(const Move& mm, int step, bool updateGUI) +{ + int f, dir, dir2; + int opponentNew, colorNew; + bool afterMove; + static Move lastMove; + Move m; + + if (boardOK) { + /* board ok means: board has the normal state + * (e.g. no highlighting) + */ + if (step == 0) + return; /* nothing to be done */ + } + boardOK = (step == 0) ? true:false; + + if (step == 0) + m = lastMove; + else { + m = lastMove = mm; + } + + if (color == Board::color1) { + colorNew = (step<2) ? Board::color1 : + (step>2) ? Board::color1bright:Board::free; + opponentNew = (step<2) ? Board::color2 : Board::color2bright; + } + else { + colorNew = (step<2) ? Board::color2 : + (step>2) ? Board::color2bright:Board::free; + opponentNew = (step<2) ? Board::color1 : Board::color1bright; + } + + afterMove = (step == 1) || (step == 4); + + f = m.field; + dir = Board::fieldDiffOfDir(m.direction); + + /* first field */ + field[f] = afterMove ? Board::free : colorNew; + + switch(m.type) { + case Move::out2: /* (c c c o o |) */ + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + field[f + 3*dir] = afterMove ? colorNew : opponentNew; + field[f + 4*dir] = opponentNew; + break; + case Move::out1with3: /* (c c c o |) */ + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + field[f + 3*dir] = afterMove ? colorNew : opponentNew; + break; + case Move::move3: /* (c c c .) */ + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + field[f + 3*dir] = afterMove ? colorNew : Board::free; + break; + case Move::out1with2: /* (c c o |) */ + field[f + dir] = colorNew; + field[f + 2*dir] = afterMove ? colorNew : opponentNew; + break; + case Move::move2: /* (c c .) */ + field[f + dir] = colorNew; + field[f + 2*dir] = afterMove ? colorNew : Board::free; + break; + case Move::push2: /* (c c c o o .) */ + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + field[f + 3*dir] = afterMove ? colorNew : opponentNew; + field[f + 4*dir] = opponentNew; + field[f + 5*dir] = afterMove ? opponentNew : Board::free; + break; + case Move::left3: + dir2 = Board::fieldDiffOfDir(m.direction-1); + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + break; + case Move::right3: + dir2 = Board::fieldDiffOfDir(m.direction+1); + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + break; + case Move::push1with3: /* (c c c o .) => (. c c c o) */ + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + field[f + 3*dir] = afterMove ? colorNew : opponentNew; + field[f + 4*dir] = afterMove ? opponentNew : Board::free; + break; + case Move::push1with2: /* (c c o .) => (. c c o) */ + field[f + dir] = colorNew; + field[f + 2*dir] = afterMove ? colorNew : opponentNew; + field[f + 3*dir] = afterMove ? opponentNew : Board::free; + break; + case Move::left2: + dir2 = Board::fieldDiffOfDir(m.direction-1); + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + break; + case Move::right2: + dir2 = Board::fieldDiffOfDir(m.direction+1); + field[f+dir2] = afterMove ? colorNew : Board::free; + field[f+=dir] = afterMove ? Board::free : colorNew; + field[f+dir2] = afterMove ? colorNew : Board::free; + break; + case Move::move1: /* (c .) => (. c) */ + field[f + dir] = afterMove ? colorNew : Board::free; + break; + default: + break; + } + + if (updateGUI) + draw(); +} + +void BoardWidget::showStart(const Move& m, int step, bool updateGUI) +{ + int f, dir; + int colorNew; + + if (boardOK) { + /* board ok means: board has the normal state before move */ + if (step == 0) + return; /* nothing to be done */ + } + boardOK = (step == 0) ? true:false; + + if (color == Board::color1) + colorNew = (step==0) ? Board::color1 : Board::color1bright; + else + colorNew = (step==0) ? Board::color2 : Board::color2bright; + + f = m.field; + + /* first field */ + field[f] = colorNew; + + switch(m.type) { + case Move::left3: + case Move::right3: + dir = Board::fieldDiffOfDir(m.direction); + field[f + dir] = colorNew; + field[f + 2*dir] = colorNew; + break; + case Move::left2: + case Move::right2: + dir = Board::fieldDiffOfDir(m.direction); + field[f + dir] = colorNew; + default: + break; + } + + if (updateGUI) + draw(); +} + + +void BoardWidget::choseMove(MoveList *pl) +{ + if (!gettingMove && pl != 0) { + pList = pl; + gettingMove = true; + mbDown = false; + actValue = - board.calcEvaluation(); + kdDebug(12011) << "Chose Move..." << endl; + } +} + + +/* returns position of point (xx,yy) + */ +int BoardWidget::positionOf(int xx, int yy) +{ + int boardSize = QMIN( width()*10/12, height() ); + int x = (1000 * (xx- (width()-boardSize)/2)) / boardSize; + int y = (1000 * (yy- (height()-boardSize)/2)) / boardSize; + + /* + kdDebug(12011) << "(" << xx << "," << yy << ") -> (" + << x << "," << y << ")" << endl; + */ + + y = (y-2)/47; + if (y < 2 || y > 18) return 0; + x= ((x+25)/25+ (y-10) )/2; + if (y < 10 && ((x < 2) || (x > 8+y) )) return 0; + if (y >= 10 && ((x < y-8) || (x > 18) )) return 0; + + return 22*y + x; +} + + +bool isBetweenFields(int pos) +{ + bool res = ( ((pos%2) == 1) || ( ((pos/22)%2) == 1) ); + // kdDebug(12011) << "Pos " << pos << " is between fields: " << res << endl; + return res; +} + +int fieldOf(int pos) +{ + int f = 11*(pos/44) + (pos%22)/2; + // kdDebug(12011) << "Field1 of pos " << pos << " is " << f << endl; + return f; +} + +int field2Of(int pos) +{ + int y = pos/22, x = pos%22; + int f2 = 0, f1 = 11*(y/2) + (x/2); + + if ( (y%2) == 0) { + /* exact on row */ + if ( (x%2) != 0) { + /* horizontial between fields */ + f2 = f1+1; + } + } + else { + /* vertical between fields */ + f2 = f1 + ( ((x%2)==0) ? 11:12 ); + } + + // kdDebug(12011) << "Field2 of pos " << pos << " is " << f2 << endl; + return f2; +} + + +/* get direction depending on difference of positions */ +int directionOfPosDiff(int d) +{ + if (d>0) { + return ((d<21) ? Move::Right : + ((d%22) == 0) ? Move::LeftDown : + ((d%23) == 0) ? Move::RightDown : 0); + } + else if (d<0) { + return ((d>-21) ? Move::Left : + ((d%23) == 0) ? Move::LeftUp : + ((d%22) == 0) ? Move::RightUp : 0); + } + return 0; +} + +int directionOfFieldDiff(int d) +{ + if (d>0) { + return ((d<10) ? Move::Right : + ((d%11) == 0) ? Move::LeftDown : + ((d%12) == 0) ? Move::RightDown : 0); + } + else if (d<0) { + return ((d>-10) ? Move::Left : + ((d%12) == 0) ? Move::LeftUp : + ((d%11) == 0) ? Move::RightUp : 0); + } + return 0; +} + +/* Check if <pos> is a valid start position for a allowed move + * If yes, set + * <startField>, <actMove> and <startType> + */ +bool BoardWidget::isValidStart(int pos, bool midPressed) +{ + bool res = false; + int f1 = fieldOf(pos); + + startField = f1; + + if (isBetweenFields(pos)) { + int f2 = field2Of(pos); + + actMove = Move(f1, directionOfFieldDiff( f2-f1 ), Move::none); + res = pList->isElement(actMove, MoveList::start2); + if (!res) { + startField = f2; + actMove = Move(f2, directionOfFieldDiff( f1-f2 ), Move::none); + res = pList->isElement(actMove, MoveList::start2); + } + startType = MoveList::start2; + return res; + } + + if (midPressed) { + startType = MoveList::start3; + + /* Check all 6 directions */ + for(int dir=1;dir<7;dir++) { + actMove = Move(f1 - Board::fieldDiffOfDir(dir), dir, Move::none ); + if (pList->isElement(actMove, startType)) + return true; + } + /* if we don't find a side move3 fall trough to normal moves... */ + } + + startType = MoveList::start1; + actMove = Move(f1, 0, Move::none); + res = pList->isElement(actMove, startType); + + return res; +} + + +/* Check if <pos> is a valid end position for a move + * regarding <startPos> + * If yes, set <actMove> + */ +bool BoardWidget::isValidEnd(int pos) +{ + int dir = directionOfPosDiff(pos - startPos); + Move m; + + if (dir == 0) return false; + + switch(startType) { + case MoveList::start1: + m = Move(startField, dir, Move::none); + if (!pList->isElement(m, startType)) + return false; + break; + + case MoveList::start2: + { + int f1 = fieldOf(startPos); + int f2 = field2Of(startPos); + int dir2 = directionOfFieldDiff( f2-f1 ); + int dir3 = directionOfFieldDiff( f1-f2 ); + + switch((dir2-dir+6)%6) { + case 1: + m = Move(f1, dir2, Move::left2); + break; + case 2: + m = Move(f2, dir3, Move::right2); + break; + case 4: + m = Move(f2, dir3, Move::left2); + break; + case 5: + m = Move(f1, dir2, Move::right2); + break; + default: + return false; + } + if (!pList->isElement(m, startType)) + return false; + + break; + } + case MoveList::start3: + { + int rightDir = (dir%6)+1; + m = Move( startField - Board::fieldDiffOfDir(rightDir), rightDir, Move::left3 ); + if (!pList->isElement(m, startType)) { + int leftDir = ((dir-2)%6)+1; + m = Move( startField - Board::fieldDiffOfDir(leftDir), leftDir, Move::right3 ); + if (!pList->isElement(m, startType)) + return false; + } + } + break; + } + + actMove = m; + shownDirection = dir; + return true; +} + + + +void BoardWidget::mousePressEvent( QMouseEvent* pEvent ) +{ + int pos = positionOf( pEvent->x(), pEvent->y() ); + int f = fieldOf(pos); + + if (pEvent->button() == RightButton) { + emit rightButtonPressed(f, pEvent->globalPos()); + return; + } + + if (!gettingMove && !editMode) { + return; + } + mbDown = true; + + + if (editMode) { + editColor = (pEvent->button() == MidButton) ? + Board::color2 : Board::color1; + int newColor = (pEvent->button() == MidButton) ? + Board::color2bright : Board::color1bright; + + if (field[f] == Board::free) { + field[f] = newColor; + } + else if (field[f] == Board::color1) { + if (editColor == Board::color1) { + editColor = Board::free; + newColor = Board::color1bright; + } + field[f] = newColor; + } + else if (field[f] == Board::color2) { + if (editColor == Board::color2) { + editColor = Board::free; + newColor = Board::color2bright; + } + field[f] = newColor; + } + else { + editColor = Board::out; + } + + oldPos = pos; + draw(); + return; + } + + startValid = isValidStart(pos, (pEvent->button() == MidButton)); + kdDebug(12011) << "Start pos " << pos << " is valid: " << startValid << endl; + // actMove.print(); + + if (!startValid) return; + startPos = oldPos = pos; + + showStart(actMove,1); + startShown = true; + + QString tmp; + actValue = - board.calcEvaluation(); + tmp = i18n("Board value: %1").arg(actValue); + emit updateSpy(tmp); +} + + +void BoardWidget::mouseMoveEvent( QMouseEvent* pEvent ) +{ + if ((!gettingMove && !editMode) || !mbDown) return; + + int pos = positionOf( pEvent->x(), pEvent->y() ); + if (pos == oldPos) return; + oldPos = pos; + + if (editMode) { + int f = fieldOf(pos); + if (field[f] != Board::out && field[f] != editColor) { + int newColor = (editColor == Board::color1) ? Board::color1bright : + (editColor == Board::color2) ? Board::color2bright : + (field[f] == Board::color1) ? Board::color1bright : + (field[f] == Board::color2) ? Board::color2bright : field[f]; + field[f] = newColor; + draw(); + } + return; + } + + if (!startValid) { + /* We haven't a valid move yet. Check if we are over a valid start */ + + startValid = isValidStart(pos, (pEvent->button() == MidButton)); + kdDebug(12011) << "Start pos " << pos << " is valid: " << startValid << endl; + // actMove.print(); + + if (!startValid) return; + startPos = oldPos = pos; + + showStart(actMove,1); + startShown = true; + + QString tmp; + actValue = - board.calcEvaluation(); + tmp = i18n("Board value: %1").arg(actValue); + emit updateSpy(tmp); + return; + } + + /* restore board */ + updatePosition(); + startShown = false; + + if (isValidEnd(pos)) { + // actMove.print(); + + board.playMove(actMove); + int v = board.calcEvaluation(); + board.takeBack(); + + QString tmp; + tmp.sprintf("%+d", v-actValue); + QString str = QString("%1 : %2").arg(actMove.name()).arg(tmp); + emit updateSpy(str); + + showMove(actMove,3); + setCursor(*arrow[shownDirection]); + } + else { + QString tmp; + + setCursor(crossCursor); + if (pos == startPos) { + showStart(actMove,1); + startShown = true; + tmp = i18n("Board value: %1").arg(actValue); + } + else + draw(); + emit updateSpy(tmp); + } +} + + +void BoardWidget::mouseReleaseEvent( QMouseEvent* pEvent ) +{ + if (!gettingMove && !editMode) return; + mbDown = false; + + if (editMode) { + int i; + + // printf("Releasing..."); + for(i=0; i<Board::AllFields;i++) + if (field[i] == Board::color1bright || + field[i] == Board::color2bright) { + //printf(" Found %d\n",i); + field[i] = editColor; + } + + for(i=0; i<Board::AllFields;i++) + board.setField( i, field[i]); + + int vState = board.validState(); // set color1/2Count + color1Count = board.getColor1Count(); + color2Count = board.getColor2Count(); + + draw(); + + emit edited(vState); + return; + } + + if (!startValid) return; + + int pos = positionOf( pEvent->x(), pEvent->y() ); + if (isValidEnd(pos)) { + // actMove.print(); + startValid = false; + setCursor(crossCursor); + gettingMove = false; + emit moveChoosen(actMove); + return; + } + + updatePosition(true); + startValid = false; + setCursor(crossCursor); + + QString tmp; + emit updateSpy(tmp); +} + +QSize BoardWidget::sizeHint() const +{ + return QSize(400, 350); +} + +#include "BoardWidget.moc" diff --git a/kenolaba/BoardWidget.h b/kenolaba/BoardWidget.h new file mode 100644 index 00000000..8fc0a317 --- /dev/null +++ b/kenolaba/BoardWidget.h @@ -0,0 +1,116 @@ +#ifndef _BOARDWIDGET_H_ +#define _BOARDWIDGET_H_ + +#include <qwidget.h> +#include <qpixmap.h> + +#include "Ball.h" +#include "Move.h" +#include "Board.h" + +#ifdef HAVE_KIR +class KIRenderer; +#endif + +class BoardWidget : public BallWidget +{ + Q_OBJECT + + public: + BoardWidget(Board&, QWidget *parent = 0, const char *name = 0); + ~BoardWidget(); + + void createPos(int , int , int , Ball*); + void initBalls(); + void updateBalls(); + + virtual void resizeEvent(QResizeEvent *); + virtual void moveEvent(QMoveEvent *); + virtual void paintEvent(QPaintEvent *); + virtual void mousePressEvent( QMouseEvent* pEvent ); + virtual void mouseReleaseEvent( QMouseEvent* pEvent ); + virtual void mouseMoveEvent( QMouseEvent* pEvent ); + + void renderBalls(bool r); + + void draw(); + + void choseMove(MoveList*); + + /* Show a move with highlighting + * step 0: state before move + * 1: state after move + * 2: remove all marks (for blinking) + * 3: highlight marks (before move) + * 4: highlight marks (after move) + * Always call with step 0 before actual playing the move !! */ + void showMove(const Move& m, int step, bool updateGUI = true); + + /* Only highlight start + * Step 0: original state + * 1: highlight start + * Always call with step 0 before actual playing the move !! */ + void showStart(const Move& m, int step, bool updateGUI = true); + + + /* enable/disable Edit Mode: + * On disabling & valid position it's actually copied to Board + */ + bool setEditMode(bool); + // int validState() { return board->validState(); } + // bool isValid() { return validState()==Board::valid; } + + /* copy actual board position */ + void updatePosition(bool updateGUI = false); + void clearPosition(); + + int getColor1Count() { return color1Count; } + int getColor2Count() { return color2Count; } + + public slots: + void configure(); + void drawBoard(); + + signals: + void moveChoosen(Move&); + void rightButtonPressed(int,const QPoint&); + void updateSpy(QString); + void edited(int); + protected: + virtual QSize sizeHint() const; + + private: + int positionOf(int x, int y); + bool isValidStart(int pos, bool); + bool isValidEnd(int pos); + + QPixmap pm, boardPM; + Board& board; + int actValue; + + bool editMode, renderMode; + int editColor; + + /* copied position */ + int field[Board::AllFields]; + int color1Count, color2Count, color; + bool boardOK; + + /* for getting user Move */ + MoveList *pList; + Move actMove; + bool gettingMove, mbDown, startValid, startShown; + int startPos, actPos, oldPos, shownDirection; + int startField, startField2, actField, oldField, startType; + QColor *boardColor, *redColor, *yellowColor, *redHColor, *yellowHColor; + QCursor *arrowAll, *arrow[7]; + + Ball *n1, *n2, *h1, *h2, *d1, *d2; //, *e; + +#ifdef HAVE_KIR + KIRenderer *m_backRenderer; +#endif +}; + +#endif /* _BOARDWIDGET_H_ */ + diff --git a/kenolaba/ChangeLog b/kenolaba/ChangeLog new file mode 100644 index 00000000..dc3947a5 --- /dev/null +++ b/kenolaba/ChangeLog @@ -0,0 +1,35 @@ +Version 1.01 (24.9.97) + - Internationalisation supported (locale DE supplied) + - Updated HTML documentation (german added !) + +Version 1.02 (16.10.97) + - Improved computers playing (a little slower but much stronger !) + - Toolbar + - Options saved in config file + Ratings too: Change the way computer rates a position + (see Board::calcRating / readRating) + - New option "Spy": See some of the internals of the computers thoughts ! + - Session management + - KStdAccel used for standard key bindings + - Icon/MiniIcon supplied + + +Version 1.03: + * [Robert Williams] Added version.h and ChangeLog + * [Robert Williams] Added -caption "%c" to kenolaba.kdelnk + * [Robert Williams] Added getHelpMenu() + +Version 1.04 (10.6.99) + - Fixed *BIG* bug in a/b search + - Edit mode + - Copy/Paste Positions in nice ASCII over clipboard + - Ball rendering + - Network Mode + +Version 1.05 (16.3.2000) + - Statusbar correction + - Action'ized (Menu + Toolbar), using XML GUI description + +Version 1.05b (24.7.2000) + - Bugfix release, Cleanup for KDE 2.0 +
\ No newline at end of file diff --git a/kenolaba/EvalDlg.ui b/kenolaba/EvalDlg.ui new file mode 100644 index 00000000..06931458 --- /dev/null +++ b/kenolaba/EvalDlg.ui @@ -0,0 +1,1760 @@ +<!DOCTYPE UI><UI version="3.0" stdsetdef="1"> +<class>EvalDlg</class> +<widget class="QWidget"> + <property name="name"> + <cstring>EvalDlg</cstring> + </property> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>350</width> + <height>388</height> + </rect> + </property> + <property name="caption"> + <string>Configure Evaluation</string> + </property> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QTabWidget"> + <property name="name"> + <cstring>TabWidget2</cstring> + </property> + <property name="layoutSpacing" stdset="0"> + </property> + <widget class="QWidget"> + <property name="name"> + <cstring>moves</cstring> + </property> + <attribute name="title"> + <string>Moves</string> + </attribute> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout17</cstring> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLayoutWidget" row="0" column="2"> + <property name="name"> + <cstring>Layout35</cstring> + </property> + <property name="layoutSpacing" stdset="0"> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>4</number> + </property> + <widget class="QLineEdit" row="0" column="5"> + <property name="name"> + <cstring>moveEval1</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="1" column="4"> + <property name="name"> + <cstring>PixmapLabel3_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLineEdit" row="1" column="5"> + <property name="name"> + <cstring>moveEval2</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="2"> + <property name="name"> + <cstring>PixmapLabel1_2_5</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLineEdit" row="2" column="5"> + <property name="name"> + <cstring>moveEval3</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="4"> + <property name="name"> + <cstring>PixmapLabel3_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="3"> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="3"> + <property name="name"> + <cstring>PixmapLabel1_2_6</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="3"> + <property name="name"> + <cstring>PixmapLabel1_2_4</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="4"> + <property name="name"> + <cstring>PixmapLabel3</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="2"> + <property name="name"> + <cstring>PixmapLabel1_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="1"> + <property name="name"> + <cstring>PixmapLabel1_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <spacer row="1" column="0"> + <property name="name"> + <cstring>Spacer2</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </grid> + </widget> + <widget class="QLabel" row="2" column="1"> + <property name="name"> + <cstring>TextLabel4_2_2</cstring> + </property> + <property name="text"> + <string>Push Out</string> + </property> + <property name="alignment"> + <set>AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + </widget> + <spacer row="1" column="0"> + <property name="name"> + <cstring>Spacer9_2</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLabel" row="1" column="1"> + <property name="name"> + <cstring>TextLabel4_2</cstring> + </property> + <property name="text"> + <string>Push</string> + </property> + <property name="alignment"> + <set>AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + </widget> + <widget class="QLayoutWidget" row="1" column="2"> + <property name="name"> + <cstring>Layout37</cstring> + </property> + <property name="layoutSpacing" stdset="0"> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>4</number> + </property> + <widget class="QLabel" row="2" column="3"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="6"> + <property name="name"> + <cstring>PixmapLabel3_3_2_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="6"> + <property name="name"> + <cstring>PixmapLabel3_3_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLineEdit" row="0" column="7"> + <property name="name"> + <cstring>moveEval4</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="1" column="7"> + <property name="name"> + <cstring>moveEval5</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="5"> + <property name="name"> + <cstring>PixmapLabel2_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="4"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="6"> + <property name="name"> + <cstring>PixmapLabel3_3_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image0</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="4"> + <property name="name"> + <cstring>PixmapLabel2_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="1"> + <property name="name"> + <cstring>PixmapLabel1_3_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <spacer row="1" column="0"> + <property name="name"> + <cstring>Spacer2_2</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLineEdit" row="2" column="7"> + <property name="name"> + <cstring>moveEval6</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="0" column="3"> + <property name="name"> + <cstring>PixmapLabel1_4</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="2"> + <property name="name"> + <cstring>PixmapLabel1_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="5"> + <property name="name"> + <cstring>PixmapLabel2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="2"> + <property name="name"> + <cstring>PixmapLabel1_4_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="4"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + </widget> + <widget class="QLabel" row="0" column="5"> + <property name="name"> + <cstring>PixmapLabel2</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="3"> + <property name="name"> + <cstring>PixmapLabel1_4_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + </grid> + </widget> + <spacer row="1" column="3"> + <property name="name"> + <cstring>Spacer9</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLayoutWidget" row="2" column="2"> + <property name="name"> + <cstring>Layout38</cstring> + </property> + <property name="layoutSpacing" stdset="0"> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>4</number> + </property> + <widget class="QLabel" row="0" column="5"> + <property name="name"> + <cstring>PixmapLabel2_4</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="1"> + <property name="name"> + <cstring>PixmapLabel1_3_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="4"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + </widget> + <spacer row="1" column="0"> + <property name="name"> + <cstring>Spacer2_2_2</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLineEdit" row="0" column="7"> + <property name="name"> + <cstring>moveEval7</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="1" column="2"> + <property name="name"> + <cstring>PixmapLabel1_2_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="4"> + <property name="name"> + <cstring>PixmapLabel2_2_2_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLineEdit" row="2" column="7"> + <property name="name"> + <cstring>moveEval9</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="1" column="3"> + <property name="name"> + <cstring>PixmapLabel1_4_2_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="3"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2_3_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLineEdit" row="1" column="7"> + <property name="name"> + <cstring>moveEval8</cstring> + </property> + <property name="sizePolicy"> + <sizepolicy> + <hsizetype>0</hsizetype> + <vsizetype>0</vsizetype> + <horstretch>0</horstretch> + <verstretch>0</verstretch> + </sizepolicy> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="2"> + <property name="name"> + <cstring>PixmapLabel1_4_3_2</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="3"> + <property name="name"> + <cstring>PixmapLabel1_4_4</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="0" column="4"> + <property name="name"> + <cstring>PixmapLabel1_2_5_2_4</cstring> + </property> + <property name="pixmap"> + <pixmap>image1</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="2" column="5"> + <property name="name"> + <cstring>PixmapLabel2_3_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + <widget class="QLabel" row="1" column="5"> + <property name="name"> + <cstring>PixmapLabel2_2_3</cstring> + </property> + <property name="pixmap"> + <pixmap>image2</pixmap> + </property> + <property name="scaledContents"> + <bool>false</bool> + </property> + </widget> + </grid> + </widget> + <widget class="QLabel" row="0" column="1"> + <property name="name"> + <cstring>TextLabel4</cstring> + </property> + <property name="text"> + <string>Normal</string> + </property> + <property name="alignment"> + <set>AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + </widget> + </grid> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel5</cstring> + </property> + <property name="minimumSize"> + <size> + <width>0</width> + <height>20</height> + </size> + </property> + <property name="text"> + <string>For every move possible the given points are added to the Evaluation.</string> + </property> + <property name="alignment"> + <set>WordBreak|AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + <property name="wordwrap" stdset="0"> + </property> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer5</cstring> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </vbox> + </widget> + <widget class="QWidget"> + <property name="name"> + <cstring>position</cstring> + </property> + <attribute name="title"> + <string>Position</string> + </attribute> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout63</cstring> + </property> + <hbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>0</number> + </property> + <spacer> + <property name="name"> + <cstring>Spacer12</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout62</cstring> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLabel" row="3" column="0"> + <property name="name"> + <cstring>TextLabel1_2_3_2</cstring> + </property> + <property name="text"> + <string>Inner ring 3:</string> + </property> + </widget> + <widget class="QLineEdit" row="2" column="1"> + <property name="name"> + <cstring>posEval3</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="4" column="1"> + <property name="name"> + <cstring>posEval5</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="1" column="1"> + <property name="name"> + <cstring>posEval2</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="4" column="0"> + <property name="name"> + <cstring>TextLabel1_2</cstring> + </property> + <property name="text"> + <string>Outermost ring:</string> + </property> + </widget> + <widget class="QLineEdit" row="1" column="3"> + <property name="name"> + <cstring>diffEval2</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="2" column="3"> + <property name="name"> + <cstring>diffEval3</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="3" column="1"> + <property name="name"> + <cstring>posEval4</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="0" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2</cstring> + </property> + <property name="text"> + <string>Middle position:</string> + </property> + </widget> + <widget class="QLineEdit" row="4" column="3"> + <property name="name"> + <cstring>diffEval5</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="0" column="1"> + <property name="name"> + <cstring>posEval1</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="0"> + <property name="name"> + <cstring>TextLabel1_2_3</cstring> + </property> + <property name="text"> + <string>Inner ring 2:</string> + </property> + </widget> + <widget class="QLabel" row="2" column="2"> + <property name="name"> + <cstring>TextLabel3_4</cstring> + </property> + <property name="text"> + <string>+/-</string> + </property> + </widget> + <widget class="QLabel" row="3" column="2"> + <property name="name"> + <cstring>TextLabel3_3</cstring> + </property> + <property name="text"> + <string>+/-</string> + </property> + </widget> + <widget class="QLineEdit" row="3" column="3"> + <property name="name"> + <cstring>diffEval4</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="4" column="2"> + <property name="name"> + <cstring>TextLabel3_2</cstring> + </property> + <property name="text"> + <string>+/-</string> + </property> + </widget> + <widget class="QLabel" row="1" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_2</cstring> + </property> + <property name="text"> + <string>Innermost ring:</string> + </property> + </widget> + <widget class="QLabel" row="1" column="2"> + <property name="name"> + <cstring>TextLabel3</cstring> + </property> + <property name="text"> + <string>+/-</string> + </property> + </widget> + </grid> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer11</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </hbox> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel6</cstring> + </property> + <property name="text"> + <string>For every ball, the given points are added to the evaluation depending on the balls position. The bonus for a given position is changed randomly in the +/- range.</string> + </property> + <property name="alignment"> + <set>WordBreak|AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + <property name="wordwrap" stdset="0"> + </property> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer4</cstring> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </vbox> + </widget> + <widget class="QWidget"> + <property name="name"> + <cstring>inarow</cstring> + </property> + <attribute name="title"> + <string>In-A-Row</string> + </attribute> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout64</cstring> + </property> + <hbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <spacer> + <property name="name"> + <cstring>Spacer14</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout42</cstring> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLineEdit" row="1" column="1"> + <property name="name"> + <cstring>rowEval3</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="0" column="1"> + <property name="name"> + <cstring>rowEval2</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="3" column="1"> + <property name="name"> + <cstring>rowEval5</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="2" column="1"> + <property name="name"> + <cstring>rowEval4</cstring> + </property> + <property name="maximumSize"> + <size> + <width>30</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="1" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_2</cstring> + </property> + <property name="text"> + <string>Three in-a-row:</string> + </property> + </widget> + <widget class="QLabel" row="0" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3</cstring> + </property> + <property name="text"> + <string>Two in-a-row:</string> + </property> + </widget> + <widget class="QLabel" row="2" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_3</cstring> + </property> + <property name="text"> + <string>Four in-a-row:</string> + </property> + </widget> + <widget class="QLabel" row="3" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_4</cstring> + </property> + <property name="text"> + <string>Five in-a-row:</string> + </property> + </widget> + </grid> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer13</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </hbox> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel6_2</cstring> + </property> + <property name="text"> + <string>For a number of balls In-a-Row, the given points are added to the evaluation</string> + </property> + <property name="alignment"> + <set>WordBreak|AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + <property name="wordwrap" stdset="0"> + </property> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer6</cstring> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </vbox> + </widget> + <widget class="QWidget"> + <property name="name"> + <cstring>count</cstring> + </property> + <attribute name="title"> + <string>Count</string> + </attribute> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout66</cstring> + </property> + <hbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <spacer> + <property name="name"> + <cstring>Spacer16</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout65</cstring> + </property> + <grid> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QLineEdit" row="1" column="1"> + <property name="name"> + <cstring>countEval2</cstring> + </property> + <property name="maximumSize"> + <size> + <width>40</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="3" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_4_2</cstring> + </property> + <property name="text"> + <string>4 Balls more:</string> + </property> + </widget> + <widget class="QLineEdit" row="4" column="1"> + <property name="name"> + <cstring>countEval5</cstring> + </property> + <property name="maximumSize"> + <size> + <width>40</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLineEdit" row="3" column="1"> + <property name="name"> + <cstring>countEval4</cstring> + </property> + <property name="maximumSize"> + <size> + <width>40</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="2" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_3_2</cstring> + </property> + <property name="text"> + <string>3 Balls more:</string> + </property> + </widget> + <widget class="QLabel" row="4" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_4_2_2</cstring> + </property> + <property name="text"> + <string>5 Balls more:</string> + </property> + </widget> + <widget class="QLineEdit" row="0" column="1"> + <property name="name"> + <cstring>countEval1</cstring> + </property> + <property name="maximumSize"> + <size> + <width>40</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="1" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_2_2</cstring> + </property> + <property name="text"> + <string>2 Balls more:</string> + </property> + </widget> + <widget class="QLineEdit" row="2" column="1"> + <property name="name"> + <cstring>countEval3</cstring> + </property> + <property name="maximumSize"> + <size> + <width>40</width> + <height>32767</height> + </size> + </property> + <property name="alignment"> + <set>AlignLeft</set> + </property> + <property name="hAlign" stdset="0"> + </property> + </widget> + <widget class="QLabel" row="0" column="0"> + <property name="name"> + <cstring>TextLabel1_2_2_3_5</cstring> + </property> + <property name="text"> + <string>1 Ball more:</string> + </property> + </widget> + </grid> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer15</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </hbox> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel6_2_2</cstring> + </property> + <property name="text"> + <string>For a difference in the number of balls, the given points are added to the evaluation. A difference of 6 only can be a lost/won game.</string> + </property> + <property name="alignment"> + <set>WordBreak|AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + <property name="wordwrap" stdset="0"> + </property> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer6_2</cstring> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </vbox> + </widget> + <widget class="QWidget"> + <property name="name"> + <cstring>tab</cstring> + </property> + <attribute name="title"> + <string>Evaluation Schemes</string> + </attribute> + <vbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>11</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QListBox"> + <property name="name"> + <cstring>evalList</cstring> + </property> + </widget> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout13</cstring> + </property> + <hbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <widget class="QPushButton"> + <property name="name"> + <cstring>evalSaveAs</cstring> + </property> + <property name="text"> + <string>Save As...</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>evalDelete</cstring> + </property> + <property name="text"> + <string>Delete</string> + </property> + </widget> + </hbox> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel1</cstring> + </property> + <property name="text"> + <string>Your evaluation scheme, defined in all other tabs of this dialog, can be stored here.</string> + </property> + <property name="alignment"> + <set>WordBreak|AlignTop|AlignLeft</set> + </property> + <property name="vAlign" stdset="0"> + </property> + <property name="wordwrap" stdset="0"> + </property> + </widget> + </vbox> + </widget> + </widget> + <widget class="QLayoutWidget"> + <property name="name"> + <cstring>Layout13</cstring> + </property> + <hbox> + <property name="name"> + <cstring>unnamed</cstring> + </property> + <property name="margin"> + <number>0</number> + </property> + <property name="spacing"> + <number>6</number> + </property> + <spacer> + <property name="name"> + <cstring>Spacer2_3</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + <widget class="QLabel"> + <property name="name"> + <cstring>TextLabel9</cstring> + </property> + <property name="text"> + <string>Evaluation of actual position:</string> + </property> + </widget> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>actualEval</cstring> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + </widget> + <spacer> + <property name="name"> + <cstring>Spacer1</cstring> + </property> + <property name="orientation"> + <enum>Horizontal</enum> + </property> + <property name="sizeType"> + <enum>Expanding</enum> + </property> + </spacer> + </hbox> + </widget> + </vbox> +</widget> +<images> + <image name="image0"> + <data format="XPM.GZ" length="409">789cd3d7528808f055d0d2e72a2e492cc94c5648ce482c52d04a29cdcdad8c8eb5ade6523234530022630543251d2e253d856405bffcbc54105b19c856b630b630b43006711341dc343000ab0401651000b3f4a062ca30801003721241002208160309817525825950318810d8108818921058901662d8ecd583fb4a0fe13eb820c4f1e8fe4d448401d8ab204f23850b483431116a9352ad351700a1cd4f38</data> + </image> + <image name="image1"> + <data format="XPM.GZ" length="454">789c6dd0410ac2301005d07d4e3124bb20ad4511413c82e2521017e9c4a28b56d0ba10f1ee66664cda6a3fa1cc7f9436496e61bfdb80cdd5bd75ed0501cfee06d63feafa7938ae5f4a170b082b3cf444e90c10b6d7e644b309b39972a83aaaf322d692ea72162b52adaa58bd540a7f9662283c655f33c65144c5884a0a235b2241b14401c5fa44d83744fc3544c6bea1e4cf7c32f92f91f76806fbe3f7d2fe3aecce317aded17b1944bf57ea03b18f6cb9</data> + </image> + <image name="image2"> + <data format="XPM.GZ" length="454">789c6dd04d0ac2301005e07d4e3124bb20ad452c05f1088a4b415c24138b2e5a41eb42c4bb9bc9246a208f52e67d94fcb4d6b0df6d40d7e23e99e98280677303ed1ec3f03c1cd72f219b16fce35f7226640508dbeb78a259f959cd43a81aaadda26bb85aaab8c4962b52ed7db8ba54fb3e2c4b51943055d194321456b648118331596b19d9220564fb1163329b921bfa940cffcd047398d68bfb7a72cea8fc7cf4ddf77ca57b14ef5bfc2f59e47b253ec60c6d67</data> + </image> +</images> +<tabstops> + <tabstop>TabWidget2</tabstop> + <tabstop>moveEval1</tabstop> + <tabstop>moveEval2</tabstop> + <tabstop>moveEval3</tabstop> + <tabstop>moveEval4</tabstop> + <tabstop>moveEval5</tabstop> + <tabstop>moveEval6</tabstop> + <tabstop>moveEval7</tabstop> + <tabstop>moveEval8</tabstop> + <tabstop>moveEval9</tabstop> + <tabstop>posEval1</tabstop> + <tabstop>posEval2</tabstop> + <tabstop>diffEval2</tabstop> + <tabstop>posEval3</tabstop> + <tabstop>diffEval3</tabstop> + <tabstop>posEval4</tabstop> + <tabstop>diffEval4</tabstop> + <tabstop>posEval5</tabstop> + <tabstop>diffEval5</tabstop> + <tabstop>rowEval2</tabstop> + <tabstop>rowEval3</tabstop> + <tabstop>rowEval4</tabstop> + <tabstop>rowEval5</tabstop> + <tabstop>countEval1</tabstop> + <tabstop>countEval2</tabstop> + <tabstop>countEval3</tabstop> + <tabstop>countEval4</tabstop> + <tabstop>countEval5</tabstop> + <tabstop>evalList</tabstop> + <tabstop>evalDelete</tabstop> + <tabstop>evalSaveAs</tabstop> +</tabstops> +<includes> + <include location="global" impldecl="in declaration">kseparator.h</include> +</includes> +<layoutdefaults spacing="6" margin="11"/> +</UI> diff --git a/kenolaba/EvalDlgImpl.cpp b/kenolaba/EvalDlgImpl.cpp new file mode 100644 index 00000000..a5903429 --- /dev/null +++ b/kenolaba/EvalDlgImpl.cpp @@ -0,0 +1,299 @@ +/** + * Some Implementation details for configEval Dialog + * + */ + +#include <qvalidator.h> +#include <qlineedit.h> +#include <qlcdnumber.h> +#include <klineeditdlg.h> +#include <qlistbox.h> +#include <qpushbutton.h> + +#include <kconfig.h> +#include <klocale.h> +#include <kdebug.h> +#include <kapplication.h> + +#include "EvalDlgImpl.h" +#include "Board.h" +#include "EvalScheme.h" + +EvalDlgImpl::EvalDlgImpl(QWidget* parent, Board* board) + :EvalDlg(parent) +{ + _board = board; + _origScheme = board->evalScheme(); + _scheme = new EvalScheme(*_origScheme); + + connect( evalDelete, SIGNAL( clicked() ), this, SLOT( deleteEntry() ) ); + connect( evalSaveAs, SIGNAL( clicked() ), this, SLOT( saveas() ) ); + connect( evalList, SIGNAL( highlighted(int) ), this, SLOT( select(int) ) ); + + KConfig* config = kapp->config(); + config->setGroup("General"); + QStringList list = config->readListEntry("EvalSchemes"); + evalList->insertItem( i18n("Current") ); + evalList->insertItem( i18n("Default") ); + for(int i=0;i<list.count();i++) + evalList->insertItem(list[i]); + + evalList->setSelected(0, TRUE); + + updateWidgets(); + connectEditLines(); +} + +EvalDlgImpl::~EvalDlgImpl() +{ + delete _scheme; +} + + +void EvalDlgImpl::connectEditLines() +{ + connect( moveEval1, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval2, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval3, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval4, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval5, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval6, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval7, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval8, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( moveEval9, SIGNAL(textChanged(const QString&)), this, SLOT(updateMove()) ); + connect( posEval1, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( posEval2, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( posEval3, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( posEval4, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( posEval5, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( diffEval2, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( diffEval3, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( diffEval4, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( diffEval5, SIGNAL(textChanged(const QString&)), this, SLOT(updateFields()) ); + connect( rowEval2, SIGNAL(textChanged(const QString&)), this, SLOT(updateInARow()) ); + connect( rowEval3, SIGNAL(textChanged(const QString&)), this, SLOT(updateInARow()) ); + connect( rowEval4, SIGNAL(textChanged(const QString&)), this, SLOT(updateInARow()) ); + connect( rowEval5, SIGNAL(textChanged(const QString&)), this, SLOT(updateInARow()) ); + connect( countEval1, SIGNAL(textChanged(const QString&)), this, SLOT(updateCount()) ); + connect( countEval2, SIGNAL(textChanged(const QString&)), this, SLOT(updateCount()) ); + connect( countEval3, SIGNAL(textChanged(const QString&)), this, SLOT(updateCount()) ); + connect( countEval4, SIGNAL(textChanged(const QString&)), this, SLOT(updateCount()) ); + connect( countEval5, SIGNAL(textChanged(const QString&)), this, SLOT(updateCount()) ); +} + +void EvalDlgImpl::disconnectEditLines() +{ + moveEval1->disconnect(); + moveEval2->disconnect(); + moveEval3->disconnect(); + moveEval4->disconnect(); + moveEval5->disconnect(); + moveEval6->disconnect(); + moveEval7->disconnect(); + moveEval8->disconnect(); + moveEval9->disconnect(); + posEval1->disconnect(); + posEval2->disconnect(); + posEval3->disconnect(); + posEval4->disconnect(); + posEval5->disconnect(); + diffEval2->disconnect(); + diffEval3->disconnect(); + diffEval4->disconnect(); + diffEval5->disconnect(); + rowEval2->disconnect(); + rowEval3->disconnect(); + rowEval4->disconnect(); + rowEval5->disconnect(); + countEval1->disconnect(); + countEval2->disconnect(); + countEval3->disconnect(); + countEval4->disconnect(); + countEval5->disconnect(); +} + +void EvalDlgImpl::updateWidgets() +{ + // Moves + moveEval1->setText( QString::number(_scheme->moveValue(Move::move1)) ); + moveEval2->setText( QString::number(_scheme->moveValue(Move::move2)) ); + moveEval3->setText( QString::number(_scheme->moveValue(Move::move3)) ); + moveEval4->setText( QString::number(_scheme->moveValue(Move::push1with2)) ); + moveEval5->setText( QString::number(_scheme->moveValue(Move::push1with3)) ); + moveEval6->setText( QString::number(_scheme->moveValue(Move::push2)) ); + moveEval7->setText( QString::number(_scheme->moveValue(Move::out1with2)) ); + moveEval8->setText( QString::number(_scheme->moveValue(Move::out1with3)) ); + moveEval9->setText( QString::number(_scheme->moveValue(Move::out2)) ); + + // Position + posEval1->setText( QString::number(_scheme->ringValue(0)) ); + posEval2->setText( QString::number(_scheme->ringValue(1)) ); + posEval3->setText( QString::number(_scheme->ringValue(2)) ); + posEval4->setText( QString::number(_scheme->ringValue(3)) ); + posEval5->setText( QString::number(_scheme->ringValue(4)) ); + + diffEval2->setText( QString::number(_scheme->ringDiff(1)) ); + diffEval3->setText( QString::number(_scheme->ringDiff(2)) ); + diffEval4->setText( QString::number(_scheme->ringDiff(3)) ); + diffEval5->setText( QString::number(_scheme->ringDiff(4)) ); + + // InARow + rowEval2->setText( QString::number(_scheme->inARowValue(0)) ); + rowEval3->setText( QString::number(_scheme->inARowValue(1)) ); + rowEval4->setText( QString::number(_scheme->inARowValue(2)) ); + rowEval5->setText( QString::number(_scheme->inARowValue(3)) ); + + // Count + countEval1->setText( QString::number(_scheme->stoneValue(1)) ); + countEval2->setText( QString::number(_scheme->stoneValue(2)) ); + countEval3->setText( QString::number(_scheme->stoneValue(3)) ); + countEval4->setText( QString::number(_scheme->stoneValue(4)) ); + countEval5->setText( QString::number(_scheme->stoneValue(5)) ); + + updateEval(); +} + +void EvalDlgImpl::updateEval() +{ + int value; + + // set temporary the new scheme + _board->setEvalScheme(_scheme); + value = - _board->calcEvaluation(); + _board->setEvalScheme(_origScheme); + + kdDebug(12011) << "Updated Eval: " << value << endl; + + if (value<-15999 || value>15999) value=0; + actualEval->display(value); +} + +void EvalDlgImpl::updateMove() +{ + _scheme->setMoveValue(Move::move1, moveEval1->text().toInt()); + _scheme->setMoveValue(Move::move2, moveEval2->text().toInt()); + _scheme->setMoveValue(Move::left2, moveEval2->text().toInt()); + _scheme->setMoveValue(Move::right2, moveEval2->text().toInt()); + _scheme->setMoveValue(Move::move3, moveEval3->text().toInt()); + _scheme->setMoveValue(Move::left3, moveEval3->text().toInt()); + _scheme->setMoveValue(Move::right3, moveEval3->text().toInt()); + + _scheme->setMoveValue(Move::push1with2, moveEval4->text().toInt()); + _scheme->setMoveValue(Move::push1with3, moveEval5->text().toInt()); + _scheme->setMoveValue(Move::push2, moveEval6->text().toInt()); + + _scheme->setMoveValue(Move::out1with2, moveEval7->text().toInt()); + _scheme->setMoveValue(Move::out1with3, moveEval8->text().toInt()); + _scheme->setMoveValue(Move::out2, moveEval9->text().toInt()); + + updateEval(); +} + +void EvalDlgImpl::updateCount() +{ + _scheme->setStoneValue(1, countEval1->text().toInt()); + _scheme->setStoneValue(2, countEval2->text().toInt()); + _scheme->setStoneValue(3, countEval3->text().toInt()); + _scheme->setStoneValue(4, countEval4->text().toInt()); + _scheme->setStoneValue(5, countEval5->text().toInt()); + + updateEval(); +} + +void EvalDlgImpl::updateFields() +{ + _scheme->setRingValue(0, posEval1->text().toInt()); + _scheme->setRingValue(1, posEval2->text().toInt()); + _scheme->setRingValue(2, posEval3->text().toInt()); + _scheme->setRingValue(3, posEval4->text().toInt()); + _scheme->setRingValue(4, posEval5->text().toInt()); + _scheme->setRingDiff(1, diffEval2->text().toInt()); + _scheme->setRingDiff(2, diffEval3->text().toInt()); + _scheme->setRingDiff(3, diffEval4->text().toInt()); + _scheme->setRingDiff(4, diffEval5->text().toInt()); + + updateEval(); +} + +void EvalDlgImpl::updateInARow() +{ + _scheme->setInARowValue(0, rowEval2->text().toInt()); + _scheme->setInARowValue(1, rowEval3->text().toInt()); + _scheme->setInARowValue(2, rowEval4->text().toInt()); + _scheme->setInARowValue(3, rowEval5->text().toInt()); + + updateEval(); +} + + +void EvalDlgImpl::deleteEntry() +{ + int i = evalList->currentItem(); + // You cannot delete Pseudo Items 0 (Current) and 1 (Default) + + if (i>1) { + QString name = evalList->text(i); + evalList->removeItem(i); + + KConfig* config = kapp->config(); + config->setGroup("General"); + QStringList list = config->readListEntry("EvalSchemes"); + list.remove(name); + config->writeEntry("EvalSchemes", list); + config->sync(); + } +} + +void EvalDlgImpl::saveas() +{ + KLineEditDlg dlg(i18n("Name for scheme:"), QString::null, this); + dlg.setCaption(i18n("Save Scheme")); + + if (dlg.exec()) { + QString name=dlg.text(); + KConfig* config = kapp->config(); + config->setGroup("General"); + QStringList list = config->readListEntry("EvalSchemes"); + QListBoxItem *it = evalList->findItem(name); + if (!it) { + evalList->insertItem(name); + it = evalList->findItem(name); + list << name; + config->writeEntry("EvalSchemes", list); + } + evalList->setSelected(it, TRUE); + + EvalScheme savedScheme(*_scheme); + savedScheme.setName(name); + savedScheme.save(config); + config->sync(); + } +} + +void EvalDlgImpl::select(int i) +{ + QString name = evalList->text(i); + + delete _scheme; + _scheme = 0; + + // 2 fixed entries: 0 is Current (origScheme), 1 is Default + + if (i == 0) _scheme = new EvalScheme(*_origScheme); + else if (i==1) { + _scheme = new EvalScheme(name); + } + else { + // read in the Scheme from the config file + _scheme = new EvalScheme(name); + KConfig* config = kapp->config(); + _scheme->read(config); + } + + kdDebug(12011) << "Selected " << name << ", Index " << i << endl; + + disconnectEditLines(); + updateWidgets(); + connectEditLines(); +} +#include "EvalDlgImpl.moc" diff --git a/kenolaba/EvalDlgImpl.h b/kenolaba/EvalDlgImpl.h new file mode 100644 index 00000000..70c903fb --- /dev/null +++ b/kenolaba/EvalDlgImpl.h @@ -0,0 +1,44 @@ +/** + * Some Implementation details for configEval Dialog + * + */ + +#ifndef _EVALDLGIMPL_H_ +#define _EVALDLGIMPL_H_ + +#include "EvalDlg.h" + +class EvalScheme; +class Board; + +class EvalDlgImpl: public EvalDlg +{ + Q_OBJECT + + public: + EvalDlgImpl(QWidget* parent, Board* board); + ~EvalDlgImpl(); + + EvalScheme* evalScheme() { return _scheme; } + + public slots: + void deleteEntry(); + void saveas(); + void select(int i); + void updateCount(); + void updateMove(); + void updateFields(); + void updateInARow(); + + private: + void updateEval(); + void updateWidgets(); + void connectEditLines(); + void disconnectEditLines(); + + EvalScheme *_origScheme, *_scheme; + Board* _board; +}; + +#endif // _EVALDLGIMPL_H_ + diff --git a/kenolaba/EvalScheme.cpp b/kenolaba/EvalScheme.cpp new file mode 100644 index 00000000..18ba5b43 --- /dev/null +++ b/kenolaba/EvalScheme.cpp @@ -0,0 +1,231 @@ +/** + * EvalScheme + * + * Configuration options for a Evaluation Scheme. + * Evaluation Schemes are used for evalution of a Abalone board position + * + * (C) JW, 2000 + */ + +#include <kapplication.h> +#include <kconfig.h> + +#include "EvalScheme.h" + +// Default Values +static int defaultRingValue[] = { 45, 35, 25, 10, 0 }; +static int defaultRingDiff[] = { 0, 10, 10, 8, 5 }; +static int defaultStoneValue[]= { 0,-800,-1800,-3000,-4400,-6000 }; +static int defaultMoveValue[Move::typeCount] = { 40,30,30, 15,14,13, + 5,5,5, 2,2,2, 1 }; +static int defaultInARowValue[InARowCounter::inARowCount]= { 2, 5, 4, 3 }; + + +/** + * Constructor: Set Default values + */ +EvalScheme::EvalScheme(QString n) +{ + _name = n; + setDefaults(); +} + + +/** + * Copy Constructor + */ +EvalScheme::EvalScheme(EvalScheme& s) +{ + _name = s._name; + + for(int i=0;i<6;i++) + _stoneValue[i] = s._stoneValue[i]; + + for(int i=0;i<Move::typeCount;i++) + _moveValue[i] = s._moveValue[i]; + + for(int i=0;i<InARowCounter::inARowCount;i++) + _inARowValue[i] = s._inARowValue[i]; + + for(int i=0;i<5;i++) + _ringValue[i] = s._ringValue[i]; + + for(int i=0;i<5;i++) + _ringDiff[i] = s._ringDiff[i]; +} + + +void EvalScheme::setDefaults() +{ + for(int i=0;i<6;i++) + _stoneValue[i] = defaultStoneValue[i]; + + for(int i=0;i<Move::typeCount;i++) + _moveValue[i] = defaultMoveValue[i]; + + for(int i=0;i<InARowCounter::inARowCount;i++) + _inARowValue[i] = defaultInARowValue[i]; + + for(int i=0;i<5;i++) + _ringValue[i] = defaultRingValue[i]; + + for(int i=0;i<5;i++) + _ringDiff[i] = defaultRingDiff[i]; +} + + +void EvalScheme::read(KConfig *config) +{ + QString confSection = QString("%1 Evaluation Scheme").arg(_name); + config->setGroup(confSection); + + QStringList list; + QString tmp; + + list = config->readListEntry("StoneValues"); + if (list.count()>0) { + _stoneValue[0] = 0; + for(int i=1;i<6;i++) + _stoneValue[i] = list[i-1].toInt(); + } + + list = config->readListEntry("MoveValues"); + if (list.count()>0) { + for(int i=0;i<Move::typeCount;i++) + _moveValue[i] = list[i].toInt(); + } + + list = config->readListEntry("InARowValues"); + if (list.count()>0) { + for(int i=0;i<InARowCounter::inARowCount;i++) + _inARowValue[i] = list[i].toInt(); + } + + list = config->readListEntry("RingValues"); + if (list.count()>0) { + for(int i=0;i<5;i++) + _ringValue[i] = list[i].toInt(); + } + + list = config->readListEntry("RingDiffs"); + if (list.count()>0) { + for(int i=0;i<5;i++) + _ringDiff[i] = list[i].toInt(); + } +} + + +void EvalScheme::save(KConfig* config) +{ + QString confSection = QString("%1 Evaluation Scheme").arg(_name); + config->setGroup(confSection); + + QString entry; + + entry.sprintf("%d,%d,%d,%d,%d", _stoneValue[1], _stoneValue[2], + _stoneValue[3], _stoneValue[4], _stoneValue[5]); + config->writeEntry("StoneValues", entry); + + entry.sprintf("%d", _moveValue[0]); + for(int i=1;i<Move::typeCount;i++) + entry += QString(", %1").arg( _moveValue[i] ); + config->writeEntry("MoveValues", entry); + + entry.sprintf("%d", _inARowValue[0]); + for(int i=1;i<InARowCounter::inARowCount;i++) + entry += QString(", %1").arg( _inARowValue[i] ); + config->writeEntry("InARowValues", entry); + + entry.sprintf("%d,%d,%d,%d,%d", _ringValue[0], _ringValue[1], + _ringValue[2], _ringValue[3], _ringValue[4]); + config->writeEntry("RingValues", entry); + + entry.sprintf("%d,%d,%d,%d,%d", _ringDiff[0], _ringDiff[1], + _ringDiff[2], _ringDiff[3], _ringDiff[4]); + config->writeEntry("RingDiffs", entry); +} + +void EvalScheme::setRingValue(int ring, int value) +{ + if (ring >=0 && ring <5) + _ringValue[ring] = value; +} + +void EvalScheme::setRingDiff(int ring, int value) +{ + if (ring >=1 && ring <5) + _ringDiff[ring] = value; +} + +void EvalScheme::setStoneValue(int stoneDiff, int value) +{ + if (stoneDiff>0 && stoneDiff<6) + _stoneValue[stoneDiff] = value; +} + +void EvalScheme::setMoveValue(int type, int value) +{ + if (type>=0 && type<Move::typeCount) + _moveValue[type] = value; +} + +void EvalScheme::setInARowValue(int stones, int value) +{ + if (stones>=0 && stones<InARowCounter::inARowCount) + _inARowValue[stones] = value; +} + +/** + * Create a EvalScheme out of a String of format + * + * <SchemeName>=<v1>,<v2>,<v3>,<v4>,... (34 values) + * + */ + +EvalScheme* EvalScheme::create(QString scheme) +{ + int pos = scheme.find('='); + if (pos<0) return 0; + + EvalScheme* evalScheme = new EvalScheme( scheme.left(pos) ); + evalScheme->setDefaults(); + + QStringList list = QStringList::split( QString(","), scheme.right(pos+1) ); + + int i=0; + while(i<list.count()) { + if (i<5) + evalScheme->_stoneValue[i+1] = list[i].toInt(); + else if (i<10) + evalScheme->_ringValue[i-5] = list[i].toInt(); + else if (i<15) + evalScheme->_ringDiff[i-10] = list[i].toInt(); + else if (i<15+Move::typeCount) + evalScheme->_moveValue[i-15] = list[i].toInt(); + else if (i<15+Move::typeCount+InARowCounter::inARowCount) + evalScheme->_inARowValue[i-15-Move::typeCount] = list[i].toInt(); + i++; + } + + return evalScheme; +} + +QString EvalScheme::ascii() +{ + QString res; + int i; + + res.sprintf("%s=%d", _name.ascii(), _stoneValue[1]); + for(i=1;i<6;i++) + res += QString(",%1").arg( _stoneValue[i] ); + for(i=0;i<Move::typeCount;i++) + res += QString(",%1").arg( _moveValue[i] ); + for(i=0;i<InARowCounter::inARowCount;i++) + res += QString(",%1").arg( _inARowValue[i] ); + for(i=0;i<5;i++) + res += QString(",%1").arg( _ringValue[i] ); + for(i=0;i<5;i++) + res += QString(",%1").arg( _ringDiff[i] ); + + return res; +} diff --git a/kenolaba/EvalScheme.h b/kenolaba/EvalScheme.h new file mode 100644 index 00000000..0efcafb8 --- /dev/null +++ b/kenolaba/EvalScheme.h @@ -0,0 +1,61 @@ +/** + * EvalScheme + * + * Configuration options for a Evaluation Scheme. + * Evaluation Schemes are used for evalution of a Abalone board position + * + * (C) JW, 2000 + */ + +#ifndef _EVALSCHEME_H_ +#define _EVALSCHEME_H_ + +#include <qstring.h> + +#include "Move.h" + +class KConfig; + +/* + * The constructor gets a name, and tries to read the scheme + * for the Kenolaba configuration file, if nothing found, use + * default values + */ + +class EvalScheme +{ + public: + EvalScheme(QString); + EvalScheme(EvalScheme&); + ~EvalScheme() {} + + void setDefaults(); + void read(KConfig*); + void save(KConfig*); + + static EvalScheme* create(QString); + QString ascii(); + + void setName(QString n) { _name = n; } + void setRingValue(int ring, int value); + void setRingDiff(int ring, int value); + void setStoneValue(int stoneDiff, int value); + void setMoveValue(int type, int value); + void setInARowValue(int stones, int value); + + QString name() { return _name; } + int ringValue(int r) { return (r>=0 && r<5) ? _ringValue[r] : 0; } + int ringDiff(int r) { return (r>0 && r<5) ? _ringDiff[r] : 0; } + int stoneValue(int s) { return (s>0 && s<6) ? _stoneValue[s] : 0; } + int moveValue(int t) { return (t>=0 && t<Move::typeCount) ? _moveValue[t] : 0;} + int inARowValue(int s) { return (s>=0 && s<InARowCounter::inARowCount) ? _inARowValue[s]:0; } + + private: + int _ringValue[5], _ringDiff[5]; + int _stoneValue[6], _moveValue[Move::none]; + int _inARowValue[InARowCounter::inARowCount]; + + QString _name; +}; + +#endif // _EVALSCHEME_H_ diff --git a/kenolaba/Makefile.am b/kenolaba/Makefile.am new file mode 100644 index 00000000..b35b1061 --- /dev/null +++ b/kenolaba/Makefile.am @@ -0,0 +1,21 @@ +SUBDIRS = toolbar bitmaps + +INCLUDES = -I$(top_srcdir)/libkdegames $(all_includes) +METASOURCES = AUTO +KDE_ICON = kenolaba + +bin_PROGRAMS = kenolaba +kenolaba_SOURCES = Board.cpp Move.cpp BoardWidget.cpp AbTop.cpp \ + kenolaba.cpp Spy.cpp Ball.cpp Network.cpp EvalDlg.ui \ + EvalDlgImpl.cpp EvalScheme.cpp +kenolaba_LDFLAGS = $(all_libraries) $(KDE_RPATH) +kenolaba_LDADD = $(LIB_KDEGAMES) +kenolaba_DEPENDENCIES = $(LIB_KDEGAMES_DEP) + +xdg_apps_DATA = kenolaba.desktop + +rcdir = $(kde_datadir)/kenolaba +rc_DATA = kenolabaui.rc + +messages: rc.cpp + $(XGETTEXT) *.cpp -o $(podir)/kenolaba.pot diff --git a/kenolaba/Move.cpp b/kenolaba/Move.cpp new file mode 100644 index 00000000..40bc3938 --- /dev/null +++ b/kenolaba/Move.cpp @@ -0,0 +1,261 @@ +/* Classes Move, MoveList + * - represents a move in the game of Abalone + * + * Josef Weidendorfer, 28.8.97 +*/ + +#include <assert.h> +#include <stdio.h> + +#include <qstring.h> + +#include <klocale.h> + +#include "Move.h" +#include "Board.h" + +const QString nameOfDir(int dir) +{ + dir = dir % 6; + return + (dir == 1) ? i18n("Right") : + (dir == 2) ? i18n("RightDown") : + (dir == 3) ? i18n("LeftDown") : + (dir == 4) ? i18n("Left") : + (dir == 5) ? i18n("LeftUp") : + (dir == 0) ? i18n("RightUp") : QString("??"); +} + +QString nameOfPos(int p) +{ + static char tmp[3]; + tmp[0] = 'A' + (p-12)/11; + tmp[1] = '1' + (p-12)%11; + tmp[2] = 0; + + return QString( tmp ); +} + +QString Move::name() const +{ + QString s,tmp; + + /* sideway moves... */ + if (type == left3 || type == right3) { + int f1, f2, df; + + f1 = f2 = field; + df = 2* Board::fieldDiffOfDir(direction); + if (df > 0) + f2 += df; + else + f1 += df; + + s = nameOfPos( f1 ); + s += '-'; + s += nameOfPos( f2 ); + s+= '/'; + s+= (type == left3) ? nameOfDir(direction-1): nameOfDir(direction+1); + } + else if ( type == left2 || type == right2) { + int f1, f2, df; + + f1 = f2 = field; + df = Board::fieldDiffOfDir(direction); + if (df > 0) + f2 += df; + else + f1 += df; + + s = nameOfPos( f1 ); + s += '-'; + s += nameOfPos( f2 ); + s+= '/'; + s+= (type == left2) ? nameOfDir(direction-1): nameOfDir(direction+1); + } + else if (type == none) { + s = QString("??"); + } + else { + s = nameOfPos( field ); + s += '/'; + s += nameOfDir(direction); + + tmp = (type <3 ) ? i18n("Out") : + (type <6 ) ? i18n("Push") : QString(""); + if (!tmp.isEmpty()) { + s += '/'; + s += tmp; + } + } + return s; +} + +void Move::print() const +{ + printf("%s", name().ascii() ); +} + +MoveTypeCounter::MoveTypeCounter() +{ + init(); +} + +void MoveTypeCounter::init() +{ + for(int i=0;i < Move::typeCount;i++) + count[i] = 0; +} + +int MoveTypeCounter::sum() +{ + int sum = count[0]; + + for(int i=1;i < Move::typeCount;i++) + sum += count[i]; + + return sum; +} + + +InARowCounter::InARowCounter() +{ + init(); +} + +void InARowCounter::init() +{ + for(int i=0;i < inARowCount;i++) + count[i] = 0; +} + +MoveList::MoveList() +{ + clear(); +} + +void MoveList::clear() +{ + int i; + + for(i=0;i<Move::typeCount;i++) + first[i] = actual[i] = -1; + + nextUnused = 0; + actualType = -1; +} + +void MoveList::insert(Move m) +{ + int t = m.type; + + /* valid and possible ? */ + if (t <0 || t >= Move::typeCount) return; + if (nextUnused == MaxMoves) return; + + assert( nextUnused < MaxMoves ); + + /* adjust queue */ + if (first[t] == -1) { + first[t] = last[t] = nextUnused; + } + else { + assert( last[t] < nextUnused ); + next[last[t]] = nextUnused; + last[t] = nextUnused; + } + + next[nextUnused] = -1; + move[nextUnused] = m; + nextUnused++; +} + +bool MoveList::isElement(int f) +{ + int i; + + for(i=0; i<nextUnused; i++) + if (move[i].field == f) + return true; + + return false; +} + + +bool MoveList::isElement(Move &m, int startType,bool del) +{ + int i; + + for(i=0; i<nextUnused; i++) { + Move& mm = move[i]; + if (mm.field != m.field) + continue; + + /* if direction is supplied it has to match */ + if ((m.direction > 0) && (mm.direction != m.direction)) + continue; + + /* if type is supplied it has to match */ + if ((m.type != Move::none) && (m.type != mm.type)) + continue; + + if (m.type == mm.type) { + /* exact match; eventually supply direction */ + m.direction = mm.direction; + if (del) mm.type = Move::none; + return true; + } + + switch(mm.type) { + case Move::left3: + case Move::right3: + if (startType == start3 || startType == all) { + m.type = mm.type; + m.direction = mm.direction; + if (del) mm.type = Move::none; + return true; + } + break; + case Move::left2: + case Move::right2: + if (startType == start2 || startType == all) { + m.type = mm.type; + m.direction = mm.direction; + if (del) mm.type = Move::none; + return true; + } + break; + default: + if (startType == start1 || startType == all) { + /* unexact match: supply type */ + m.type = mm.type; + m.direction = mm.direction; + if (del) mm.type = Move::none; + return true; + } + } + } + return false; +} + + +bool MoveList::getNext(Move& m, int maxType) +{ + if (actualType == Move::typeCount) return false; + + while(1) { + while(actualType < 0 || actual[actualType] == -1) { + actualType++; + if (actualType == Move::typeCount) return false; + actual[actualType] = first[actualType]; + if (actualType > maxType) return false; + } + m = move[actual[actualType]]; + actual[actualType] = next[actual[actualType]]; + if (m.type != Move::none) break; + } + + return true; +} + + diff --git a/kenolaba/Move.h b/kenolaba/Move.h new file mode 100644 index 00000000..1226d969 --- /dev/null +++ b/kenolaba/Move.h @@ -0,0 +1,132 @@ +/* Classes Move, MoveList + * - represents a move in the game of Abalone + * + * Josef Weidendorfer, 28.8.97 +*/ + +#ifndef _MOVE_H_ +#define _MOVE_H_ + +#include <qstring.h> + +class Move +{ + public: + + /* Type of move: Moves are searched in this order */ + enum MoveType { out2 = 0, out1with3, out1with2, push2, + push1with3, push1with2, move3, left3, right3, + left2, right2, move2, move1, none }; + enum { typeCount = none }; + + Move() { type = none; } + Move(short f, char d, MoveType t) + { field = f; direction = d, type = t; } + + + bool isOutMove() const + { return type <= out1with2; } + bool isPushMove() const + { return type <= push1with2; } + static int maxOutType() + { return out1with2; } + static int maxPushType() + { return push1with2; } + static int maxMoveType() + { return move1; } + + QString name() const; + + void print() const; + + /* Directions */ + enum { Right=1, RightDown, LeftDown, Left, LeftUp, RightUp }; + + short field; + unsigned char direction; + MoveType type; +}; + +/** + * Class MoveTypeCounter + * + * Used in Board evaluation to count types of board allowed + * in a position + */ +class MoveTypeCounter +{ + public: + MoveTypeCounter(); + ~MoveTypeCounter() {} + + void init(); + void incr(int t) { count[t]++; } + int get(int t) { return count[t]; } + int sum(); + + private: + int count[Move::typeCount]; +}; + +/** + * Class InARowCounter + * + * Used in Board evaluation to count connectiveness + * of some degrees in a position + */ +class InARowCounter +{ + public: + enum InARowType { inARow2 = 0, inARow3, inARow4, inARow5, inARowCount }; + + InARowCounter(); + ~InARowCounter() {} + + void init(); + void incr(int c) { count[c]++; } + int get(int c) { return count[c]; } + + private: + int count[inARowCount]; +}; + + +/* MoveList stores a fixed number of moves (for efficince) + * <getNext> returns reference of next move ordered according to type + * <insert> does nothing if there isn't enough free space + * + * Recommend usage (* means 0 or more times): + * [ clear() ; insert() * ; isElement() * ; getNext() * ] * + */ +class MoveList +{ + public: + MoveList(); + + enum { MaxMoves = 150 }; + + /* for isElement: search for moves starting with 1/2/3 fields */ + enum { all , start1, start2, start3 }; + + void clear(); + void insert(Move); + bool isElement(int f); + bool isElement(Move&, int startType, bool del=false); + void insert(short f, char d, Move::MoveType t) + { insert( Move(f,d,t) ); } + int getLength() + { return nextUnused; } + + bool getNext(Move&,int maxType); /* returns false if no more moves */ + + private: + Move move[MaxMoves]; + int next[MaxMoves]; + int first[Move::typeCount]; + int last[Move::typeCount]; + int actual[Move::typeCount]; + int nextUnused, actualType; +}; + +#endif /* _MOVE_H_ */ + diff --git a/kenolaba/Network.cpp b/kenolaba/Network.cpp new file mode 100644 index 00000000..e12f6b5e --- /dev/null +++ b/kenolaba/Network.cpp @@ -0,0 +1,193 @@ +#include <config.h> + +#include "Network.h" + +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> + +Listener::Listener(const char* h, int p, struct sockaddr_in s,bool r) +{ + if (h==0) + host[0]=0; + else { + int l = strlen(h); + if (l>99) l=99; + strncpy(host, h, l); + host[l] = 0; + } + port = p; + sin = s; + reachable = r; +} + +Network::Network(int port) +{ + struct sockaddr_in name; + int i,j; + + listeners.setAutoDelete(TRUE); + + fd = ::socket (PF_INET, SOCK_STREAM, 0); + if (fd<0) return; + + for(i = 0; i<5;i++) { + name.sin_family = AF_INET; + name.sin_port = htons (port+i); + name.sin_addr.s_addr = htonl (INADDR_ANY); + if (bind (fd, (struct sockaddr *) &name, sizeof (name)) >= 0) + break; + // printf("...Port %d in use\n", port+i); + } + mySin = name; + // printf("I'm using Port %d\n", port+i); + if (i==5) { + printf("Error in bind to port %d\n", port); + close(fd); + fd = -1; + return; + } + for(j = 0; j<i;j++) + addListener("127.0.0.1", port+j); + + if (::listen(fd,5)<0) { + printf("Error in listen\n"); + close(fd); + fd = -1; + return; + } + + sn = new QSocketNotifier( fd, QSocketNotifier::Read ); + QObject::connect( sn, SIGNAL(activated(int)), + this, SLOT(gotConnection()) ); +} + +Network::~Network() +{ + if (fd<0) return; + close(fd); + + char tmp[50]; + int len = sprintf(tmp, "unreg %d", ntohs(mySin.sin_port)); + + Listener* l; + for(l=listeners.first(); l!=0; l=listeners.next()) { + if (l->reachable) + sendString( l->sin, tmp, len); + } + listeners.clear(); + + delete sn; +} + +void Network::gotConnection() +{ + static char tmp[1024]; + int len=0; + struct sockaddr_in sin; + kde_socklen_t sz = sizeof (sin); + + // printf("GotConnection: "); + int s = accept(fd,(struct sockaddr *)&sin, &sz); + if (s<0) { + printf("Error in accept\n"); + return; + } + while(read(s, tmp+len, 1)==1) len++; + close(s); + tmp[len]=0; len++; + // printf("Got: '%s'\n",tmp); + if (strncmp(tmp,"reg ",4)==0) { + int port = atoi(tmp+4); + sin.sin_port = htons( port ); + Listener *l = new Listener(0,0,sin); + // printf("Reg of 0x%x:%d\n", + // ntohl(sin.sin_addr.s_addr ), ntohs(sin.sin_port)); + listeners.append(l); + return; + } + + if (strncmp(tmp,"unreg ",6)==0) { + int port = atoi(tmp+6); + sin.sin_port = htons( port ); + Listener* l; + for(l=listeners.first(); l!=0; l=listeners.next()) + if (l->sin.sin_addr.s_addr == sin.sin_addr.s_addr && + l->sin.sin_port == sin.sin_port) break; + if (l==0) { + printf("Error: UnReg of 0x%x:%d. Not Found\n", + ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port)); + return; + } + listeners.remove(l); + // printf("UnReg of 0x%x:%d\n", + // ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port)); + return; + } + + if (strncmp(tmp,"pos ",4)==0) { + emit gotPosition(tmp+4); + } +} + +void Network::addListener(const char* host, int port) +{ + struct hostent *hostinfo; + struct sockaddr_in name; + + memset(&name, 0, sizeof(struct sockaddr_in)); + name.sin_family = AF_INET; + name.sin_port = htons (port); + hostinfo = gethostbyname (host); + if (hostinfo == NULL) { + printf ("Error in addListener: Unknown host %s.\n", host); + return; + } + name.sin_addr = *(struct in_addr *) hostinfo->h_addr; + + Listener *l = new Listener(host,port,name); +// printf("Added Listener %s, 0x%x:%d\n", +// host, ntohl(name.sin_addr.s_addr), ntohs(name.sin_port)); + listeners.append(l); + + char tmp[50]; + int len = sprintf(tmp, "reg %d", ntohs(mySin.sin_port)); + + if (!sendString( name, tmp, len)) + listeners.remove(l); +} + +void Network::broadcast(const char* pos) +{ + char tmp[1024]; + int len = sprintf(tmp,"pos %s", pos); + + for(Listener* l=listeners.first(); l!=0; l=listeners.next()) + if (l->reachable) + l->reachable = sendString(l->sin, tmp, len); +} + +bool Network::sendString(struct sockaddr_in sin, char* str, int len) +{ + int s = ::socket (PF_INET, SOCK_STREAM, 0); + if (s<0) { + printf("Error in sendString/socket ??\n"); + return false; + } + if (::connect (s, (struct sockaddr *)&sin, sizeof (sin)) <0) { + printf("Error in sendString/connect to socket 0x%x:%d\n", + ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port) ); + return false; + } + write(s, str, len); + close(s); + // printf("Send '%s' to 0x%x:%d\n", str, + // ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port) ); + return true; +} + +#include "Network.moc" diff --git a/kenolaba/Network.h b/kenolaba/Network.h new file mode 100644 index 00000000..d5251cc6 --- /dev/null +++ b/kenolaba/Network.h @@ -0,0 +1,60 @@ +/* + * Simple Network Support + * Install a listening socket; receive positions on incoming + * connections (incoming positions are treated as if pasted in) + */ + +#ifndef _NETWORK_H_ +#define _NETWORK_H_ + +#include <sys/types.h> +#include <netinet/in.h> + +#include <qobject.h> +#include <qptrlist.h> +#include <qsocketnotifier.h> + +class Listener { + public: + Listener(const char*,int,struct sockaddr_in,bool=true); + + char host[100]; + int port; + struct sockaddr_in sin; + bool reachable; +}; + + +class Network: public QObject +{ + Q_OBJECT + + public: + enum { defaultPort = 23412 }; + + /* install listening TCP socket on port */ + Network(int port = defaultPort); + ~Network(); + + bool isOK() { return (fd>=0); } + void addListener(const char* host, int port); + void broadcast(const char* pos); + + signals: + void gotPosition(const char* pos); + + private slots: + void gotConnection(); + + private: + bool sendString(struct sockaddr_in sin, char* str, int len); + + QPtrList<Listener> listeners; + struct sockaddr_in mySin; + int fd, myPort; + QSocketNotifier *sn; +}; + +#endif + + diff --git a/kenolaba/README b/kenolaba/README new file mode 100644 index 00000000..6d69911b --- /dev/null +++ b/kenolaba/README @@ -0,0 +1,23 @@ +Another kool game for KDE :) + +Kenolaba is a game like Abalone. You play against the computer on a +board. For rules look at the HTML manual. + +INSTALLATION: +If you find this directory (and README) in a kde package bundled with +other applications, there is nothing to do. By installing the package +Kenolaba should be installed too. + +Otherwise get the kdeapps package and unpack it. +Make the kenolaba/ directory (with this README) a subdirectory of +kdeapps/ and add "kenolaba" to the SUBDIRS variable in the toplevel +Makefile.in of the kdeapps package. By installing the package kdeapps now +Kenolaba should be installed too. + +Have fun... +...and remember: Your computer already is a real thinking machine ! + +Greetings, + +Josef Weidendorfer diff --git a/kenolaba/Spy.cpp b/kenolaba/Spy.cpp new file mode 100644 index 00000000..07f17702 --- /dev/null +++ b/kenolaba/Spy.cpp @@ -0,0 +1,155 @@ +/* Class Spion + * + * Josef Weidendorfer, 10/97 + */ + + +#include <qgroupbox.h> +#include <qlayout.h> +#include <qlabel.h> + +#include <klocale.h> +#include <kapplication.h> + +#include "BoardWidget.h" +#include "Spy.h" + +Spy::Spy(Board& b) + :board(b) +{ + int i; + + top = new QVBoxLayout(this, 5); + + QLabel *l = new QLabel(this); + l->setText( i18n("Actual examined position:") ); + l->setFixedHeight( l->sizeHint().height() ); + l->setAlignment( AlignVCenter | AlignLeft ); + top->addWidget( l ); + + QHBoxLayout* b1 = new QHBoxLayout(); + top->addLayout( b1, 10 ); + + for(i=0;i<BoardCount;i++) { + QVBoxLayout *b2 = new QVBoxLayout(); + b1->addLayout( b2 ); + + actBoard[i] = new BoardWidget(board,this); + actLabel[i] = new QLabel(this); + actLabel[i]->setText("---"); + // actLabel[i]->setFrameStyle( QFrame::Panel | QFrame::Sunken ); + actLabel[i]->setAlignment( AlignHCenter | AlignVCenter); + actLabel[i]->setFixedHeight( actLabel[i]->sizeHint().height() ); + + b2->addWidget( actBoard[i] ); + b2->addWidget( actLabel[i] ); + connect( actBoard[i], SIGNAL(mousePressed()), this, SLOT(nextStep()) ); + } + + l = new QLabel(this); + l->setText( i18n("Best move so far:") ); + l->setFixedHeight( l->sizeHint().height() ); + l->setAlignment( AlignVCenter | AlignLeft ); + top->addWidget( l ); + + b1 = new QHBoxLayout(); + top->addLayout( b1, 10 ); + + for(i=0;i<BoardCount;i++) { + QVBoxLayout *b2 = new QVBoxLayout(); + b1->addLayout( b2 ); + + bestBoard[i] = new BoardWidget(board,this); + bestLabel[i] = new QLabel(this); + bestLabel[i]->setText("---"); + // bestLabel[i]->setFrameStyle( QFrame::Panel | QFrame::Sunken ); + bestLabel[i]->setAlignment( AlignHCenter | AlignVCenter); + bestLabel[i]->setFixedHeight( bestLabel[i]->sizeHint().height() ); + + b2->addWidget( bestBoard[i] ); + b2->addWidget( bestLabel[i] ); + connect( bestBoard[i], SIGNAL(mousePressed()), this, SLOT(nextStep()) ); + } + + connect( &board, SIGNAL(update(int,int,Move&,bool)), + this, SLOT(update(int,int,Move&,bool)) ); + connect( &board, SIGNAL(updateBest(int,int,Move&,bool)), + this, SLOT(updateBest(int,int,Move&,bool)) ); + top->activate(); + setCaption(i18n("Spy")); + // KWM::setDecoration(winId(), 2); + resize(500,300); +} + +void Spy::keyPressEvent(QKeyEvent *) +{ + nextStep(); +} + +void Spy::nextStep() +{ + next = true; +} + +void Spy::clearActBoards() +{ + for(int i=0;i<BoardCount;i++) { + actBoard[i]->clearPosition(); + actBoard[i]->draw(); + actLabel[i]->setText("---"); + } +} + +void Spy::update(int depth, int value, Move& m, bool wait) +{ + next = false; + + if (depth>BoardCount-1) return; + actBoard[depth]->showMove(m,3); + // actBoard[depth]->showMove(m,0,false); + + if (!wait) { + actLabel[depth]->setText("---"); + return; + } + + if (depth<BoardCount-1) { + board.playMove(m); + actBoard[depth+1]->updatePosition(true); + actLabel[depth+1]->setNum(value); + board.takeBack(); + + if (depth<BoardCount-2) { + actBoard[depth+2]->clearPosition(); + actBoard[depth+2]->draw(); + } + } + + while(!next) + kapp->processEvents(); +} + +void Spy::updateBest(int depth, int value, Move& m, bool cutoff) +{ + if (depth>BoardCount-1) return; + bestBoard[depth]->showMove(m,3); + // board.showMove(m,0); + + if (depth<BoardCount-1) { + board.playMove(m); + bestBoard[depth+1]->updatePosition(true); + + QString tmp; + tmp.setNum(value); + if (cutoff) tmp += " (CutOff)"; + bestLabel[depth+1]->setText(tmp); + board.takeBack(); + } +} + + + + + + +#include "Spy.moc" diff --git a/kenolaba/Spy.h b/kenolaba/Spy.h new file mode 100644 index 00000000..f69d99d3 --- /dev/null +++ b/kenolaba/Spy.h @@ -0,0 +1,46 @@ +/* Class Spion + * + * Josef Weidendorfer, 10/97 + */ + +#ifndef _SPY_H_ +#define _SPY_H_ + + +#include <qlayout.h> +#include "Board.h" + + +class BoardWidget; +class QLabel; + +class Spy: public QWidget +{ + Q_OBJECT + +public: + Spy(Board&); + ~Spy() {} + + enum { BoardCount = 5 }; + + void clearActBoards(); + + void keyPressEvent(QKeyEvent *e); + +public slots: + void update(int,int,Move&,bool); + void updateBest(int,int,Move&,bool); + void nextStep(); + +private: + bool next; + Board &board; + QBoxLayout *top; + BoardWidget *actBoard[BoardCount], *bestBoard[BoardCount]; + QLabel *actLabel[BoardCount], *bestLabel[BoardCount]; +}; + + + +#endif /* _SPION_H_ */ diff --git a/kenolaba/TODO b/kenolaba/TODO new file mode 100644 index 00000000..baad7913 --- /dev/null +++ b/kenolaba/TODO @@ -0,0 +1,8 @@ +TODO for Abalone > 1.05b + +* "Back" in Network mode +* Computer Character Editor (=Rating values) +* Search Inspector +* Computer playing in own process/thread +* 3 player mode +* OpenGL 3D board diff --git a/kenolaba/bitmaps/Arrow1 b/kenolaba/bitmaps/Arrow1 new file mode 100644 index 00000000..45c2ce41 --- /dev/null +++ b/kenolaba/bitmaps/Arrow1 @@ -0,0 +1,8 @@ +#define Arrow1_width 16 +#define Arrow1_height 16 +#define Arrow1_x_hot 7 +#define Arrow1_y_hot 7 +static unsigned char Arrow1_bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x03, 0x00, 0x0f, + 0xfc, 0x3f, 0xfe, 0x7f, 0xfc, 0x3f, 0x00, 0x0f, 0x80, 0x03, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow1Mask b/kenolaba/bitmaps/Arrow1Mask new file mode 100644 index 00000000..2e50b48d --- /dev/null +++ b/kenolaba/bitmaps/Arrow1Mask @@ -0,0 +1,6 @@ +#define Arrow1Mask_width 16 +#define Arrow1Mask_height 16 +static unsigned char Arrow1Mask_bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0xc0, 0x03, 0xc0, 0x0f, 0xfc, 0x3f, + 0xfe, 0x7f, 0xff, 0xff, 0xfe, 0x7f, 0xfc, 0x3f, 0xc0, 0x0f, 0xc0, 0x03, + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow2 b/kenolaba/bitmaps/Arrow2 new file mode 100644 index 00000000..47487a89 --- /dev/null +++ b/kenolaba/bitmaps/Arrow2 @@ -0,0 +1,8 @@ +#define Arrow2_width 16 +#define Arrow2_height 16 +#define Arrow2_x_hot 7 +#define Arrow2_y_hot 7 +static unsigned char Arrow2_bits[] = { + 0x00, 0x00, 0x10, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf0, 0x00, 0xf0, 0x08, + 0xe0, 0x0d, 0xc0, 0x0f, 0xc0, 0x0f, 0xf0, 0x0f, 0xe0, 0x0f, 0x80, 0x0f, + 0x00, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow2Mask b/kenolaba/bitmaps/Arrow2Mask new file mode 100644 index 00000000..121295e6 --- /dev/null +++ b/kenolaba/bitmaps/Arrow2Mask @@ -0,0 +1,6 @@ +#define Arrow2Mask_width 16 +#define Arrow2Mask_height 16 +static unsigned char Arrow2Mask_bits[] = { + 0x10, 0x00, 0x38, 0x00, 0x7c, 0x00, 0xfc, 0x00, 0xf8, 0x09, 0xf8, 0x1d, + 0xf0, 0x1f, 0xe0, 0x1f, 0xf0, 0x1f, 0xf8, 0x1f, 0xf0, 0x1f, 0xe0, 0x1f, + 0x80, 0x1f, 0x00, 0x1e, 0x00, 0x18, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow3 b/kenolaba/bitmaps/Arrow3 new file mode 100644 index 00000000..b511a017 --- /dev/null +++ b/kenolaba/bitmaps/Arrow3 @@ -0,0 +1,8 @@ +#define Arrow3_width 16 +#define Arrow3_height 16 +#define Arrow3_x_hot 7 +#define Arrow3_y_hot 7 +static unsigned char Arrow3_bits[] = { + 0x00, 0x00, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x0f, 0x80, 0x07, 0x88, 0x07, + 0xd8, 0x03, 0xf8, 0x01, 0xf8, 0x01, 0xf8, 0x07, 0xf8, 0x03, 0xf8, 0x00, + 0x38, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow3Mask b/kenolaba/bitmaps/Arrow3Mask new file mode 100644 index 00000000..f4af9ccb --- /dev/null +++ b/kenolaba/bitmaps/Arrow3Mask @@ -0,0 +1,6 @@ +#define Arrow3Mask_width 16 +#define Arrow3Mask_height 16 +static unsigned char Arrow3Mask_bits[] = { + 0x00, 0x04, 0x00, 0x0e, 0x00, 0x1f, 0x80, 0x1f, 0xc8, 0x0f, 0xdc, 0x0f, + 0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x07, 0xfc, 0x0f, 0xfc, 0x07, 0xfc, 0x03, + 0xfc, 0x00, 0x3c, 0x00, 0x0c, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow4 b/kenolaba/bitmaps/Arrow4 new file mode 100644 index 00000000..dfcdbd82 --- /dev/null +++ b/kenolaba/bitmaps/Arrow4 @@ -0,0 +1,8 @@ +#define Arrow4_width 16 +#define Arrow4_height 16 +#define Arrow4_x_hot 8 +#define Arrow4_y_hot 7 +static unsigned char Arrow4_bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0x01, 0xf0, 0x00, + 0xfc, 0x3f, 0xfe, 0x7f, 0xfc, 0x3f, 0xf0, 0x00, 0xc0, 0x01, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow4Mask b/kenolaba/bitmaps/Arrow4Mask new file mode 100644 index 00000000..6c498fb5 --- /dev/null +++ b/kenolaba/bitmaps/Arrow4Mask @@ -0,0 +1,6 @@ +#define Arrow4Mask_width 16 +#define Arrow4Mask_height 16 +static unsigned char Arrow4Mask_bits[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0x03, 0xf0, 0x03, 0xfc, 0x3f, + 0xfe, 0x7f, 0xff, 0xff, 0xfe, 0x7f, 0xfc, 0x3f, 0xf0, 0x03, 0xc0, 0x03, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow5 b/kenolaba/bitmaps/Arrow5 new file mode 100644 index 00000000..72b93adc --- /dev/null +++ b/kenolaba/bitmaps/Arrow5 @@ -0,0 +1,8 @@ +#define Arrow5_width 16 +#define Arrow5_height 16 +#define Arrow5_x_hot 7 +#define Arrow5_y_hot 7 +static unsigned char Arrow5_bits[] = { + 0x00, 0x00, 0x08, 0x00, 0x38, 0x00, 0xf8, 0x00, 0xf8, 0x03, 0xf8, 0x07, + 0xf8, 0x01, 0xf8, 0x01, 0xd8, 0x03, 0x88, 0x07, 0x80, 0x07, 0x00, 0x0f, + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow5Mask b/kenolaba/bitmaps/Arrow5Mask new file mode 100644 index 00000000..da77ea00 --- /dev/null +++ b/kenolaba/bitmaps/Arrow5Mask @@ -0,0 +1,6 @@ +#define Arrow5Mask_width 16 +#define Arrow5Mask_height 16 +static unsigned char Arrow5Mask_bits[] = { + 0x0c, 0x00, 0x3c, 0x00, 0xfc, 0x00, 0xfc, 0x03, 0xfc, 0x07, 0xfc, 0x0f, + 0xfc, 0x07, 0xfc, 0x03, 0xfc, 0x07, 0xdc, 0x0f, 0xc8, 0x0f, 0x80, 0x1f, + 0x00, 0x1f, 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow6 b/kenolaba/bitmaps/Arrow6 new file mode 100644 index 00000000..159770b4 --- /dev/null +++ b/kenolaba/bitmaps/Arrow6 @@ -0,0 +1,8 @@ +#define Arrow6_width 16 +#define Arrow6_height 16 +#define Arrow6_x_hot 7 +#define Arrow6_y_hot 7 +static unsigned char Arrow6_bits[] = { + 0x00, 0x00, 0x00, 0x08, 0x00, 0x0e, 0x80, 0x0f, 0xe0, 0x0f, 0xf0, 0x0f, + 0xc0, 0x0f, 0xc0, 0x0f, 0xe0, 0x0d, 0xf0, 0x08, 0xf0, 0x00, 0x78, 0x00, + 0x38, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Arrow6Mask b/kenolaba/bitmaps/Arrow6Mask new file mode 100644 index 00000000..453ffde2 --- /dev/null +++ b/kenolaba/bitmaps/Arrow6Mask @@ -0,0 +1,6 @@ +#define Arrow6Mask_width 16 +#define Arrow6Mask_height 16 +static unsigned char Arrow6Mask_bits[] = { + 0x00, 0x18, 0x00, 0x1e, 0x80, 0x1f, 0xe0, 0x1f, 0xf0, 0x1f, 0xf8, 0x1f, + 0xf0, 0x1f, 0xe0, 0x1f, 0xf0, 0x1f, 0xf8, 0x1d, 0xf8, 0x09, 0xfc, 0x00, + 0x7c, 0x00, 0x38, 0x00, 0x10, 0x00, 0x00, 0x00}; diff --git a/kenolaba/bitmaps/Makefile.am b/kenolaba/bitmaps/Makefile.am new file mode 100644 index 00000000..d25cc3b2 --- /dev/null +++ b/kenolaba/bitmaps/Makefile.am @@ -0,0 +1 @@ +EXTRA_DIST = Arrow1 Arrow1Mask Arrow2 Arrow2Mask Arrow3 Arrow3Mask Arrow4 Arrow4Mask Arrow5 Arrow5Mask Arrow6 Arrow6Mask diff --git a/kenolaba/hi128-app-kenolaba.png b/kenolaba/hi128-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..d645ff30 --- /dev/null +++ b/kenolaba/hi128-app-kenolaba.png diff --git a/kenolaba/hi16-app-kenolaba.png b/kenolaba/hi16-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..44974a0f --- /dev/null +++ b/kenolaba/hi16-app-kenolaba.png diff --git a/kenolaba/hi22-app-kenolaba.png b/kenolaba/hi22-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..d5b649f4 --- /dev/null +++ b/kenolaba/hi22-app-kenolaba.png diff --git a/kenolaba/hi32-app-kenolaba.png b/kenolaba/hi32-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..9620d54b --- /dev/null +++ b/kenolaba/hi32-app-kenolaba.png diff --git a/kenolaba/hi48-app-kenolaba.png b/kenolaba/hi48-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..2952e03e --- /dev/null +++ b/kenolaba/hi48-app-kenolaba.png diff --git a/kenolaba/hi64-app-kenolaba.png b/kenolaba/hi64-app-kenolaba.png Binary files differnew file mode 100644 index 00000000..9e5aa438 --- /dev/null +++ b/kenolaba/hi64-app-kenolaba.png diff --git a/kenolaba/kenolaba.cpp b/kenolaba/kenolaba.cpp new file mode 100644 index 00000000..e59aa9d7 --- /dev/null +++ b/kenolaba/kenolaba.cpp @@ -0,0 +1,71 @@ +/* Start point */ + +#include <qobject.h> + +#include <kapplication.h> +#include <klocale.h> +#include <kglobal.h> +#include <kcmdlineargs.h> + +#include <kaboutdata.h> + +#include "version.h" +#include "AbTop.h" + + +static const char description[] = + I18N_NOOP("Board game inspired by Abalone"); + +static KCmdLineOptions options[] = +{ + { "h", 0, 0}, + { "host <host>", I18N_NOOP("Use 'host' for network game"), 0 }, + { "p", 0, 0}, + { "port <port>", I18N_NOOP("Use 'port' for network game"), 0 }, + KCmdLineLastOption +}; + +AbTop *create(KCmdLineArgs *args) +{ + AbTop* top = new AbTop; + if (args->isSet("port")) + top->netPort( args->getOption("port").toInt() ); + if (args->isSet("host")) + top->netHost( args->getOption("host").data() ); + top->readConfig(); + return top; +} + +int main(int argc, char *argv[]) +{ + KAboutData aboutData( "kenolaba", I18N_NOOP("Kenolaba"), + KENOLABA_VERSION, description, KAboutData::License_GPL, + "(c) 1997-2000, Josef Weidendorfer"); + aboutData.addAuthor("Josef Weidendorfer",0, "[email protected]"); + aboutData.addAuthor("Robert Williams"); + KCmdLineArgs::init( argc, argv, &aboutData ); + KCmdLineArgs::addCmdLineOptions( options ); // Add our own options. + + KApplication app; + KGlobal::locale()->insertCatalogue("libkdegames"); + + /* command line handling */ + KCmdLineArgs *args = KCmdLineArgs::parsedArgs(); + + /* session management */ + if ( app.isRestored() ) { + uint n = 1; + while ( KMainWindow::canBeRestored(n) ) { + AbTop *top = create(args); + top->restore(n); + n++; + } + } else { + AbTop *top = create(args); + app.setMainWidget(top); + top->show(); + } + args->clear(); + return app.exec(); +} + diff --git a/kenolaba/kenolaba.desktop b/kenolaba/kenolaba.desktop new file mode 100644 index 00000000..add3fdda --- /dev/null +++ b/kenolaba/kenolaba.desktop @@ -0,0 +1,64 @@ +[Desktop Entry] +Name=Kenolaba +Name[ar]=لعبة Kenolaba +Name[be]=Абалон +Name[bn]=কেনোলাবা +Name[hi]=के-नोलाबा +Name[ne]=केनोलाबा +Name[pa]=ਕੀਨੋਲਾਬਾ +Name[ta]=கெனோப்ளா +Name[tg]=Кенолаба +Name[zh_TW]=Kenolaba 互推 +Name[zu]=I-Kenolaba +Icon=kenolaba +Type=Application +Exec=kenolaba %i %m -caption "%c" +DocPath=kenolaba/index.html +GenericName=Abalone-like Board Game +GenericName[be]=Настольная гульня тыпу Абалон +GenericName[bg]=Логическа игра +GenericName[bn]=অ্যাবালন-জাতীয় ছকভিত্তিক খেলা +GenericName[br]=Ur c'hoari taolenn a seurt gant Abalone +GenericName[bs]=Igra nalik na Abalone +GenericName[ca]=Jocs de taula similar a l'Abalone +GenericName[cs]=Deskové hry podobné Abalone +GenericName[cy]=Gêm Fwrdd sy'n debyg i Abalone +GenericName[da]=Abalone-lignende brætspil +GenericName[de]=Abalone-ähnliches Brettspiel +GenericName[el]=Επιτραπέζιο παιχνίδι παρόμοιο με το Abalone +GenericName[eo]=Abalone-simila bretludo +GenericName[es]=Juegos de tablero similar a Abalone +GenericName[et]=Abalone moodi lauamäng +GenericName[eu]=Abalone bezalako mahai-jokoa +GenericName[fa]=بازی Abalone-like Board +GenericName[fi]=Abalone-tyylinen lautapeli +GenericName[fr]=Jeu de plateau dans le style d'Abalone +GenericName[he]=חיקוי Abalon, משחק לוח +GenericName[hr]=Igra na ploči poput Abalonea +GenericName[hu]=Abalone-szerű táblás +GenericName[is]=Leikur sem líkist Abalone +GenericName[it]=Gioco da tavolo simile ad Abalone +GenericName[ja]=Abalone のようなボードゲーム +GenericName[km]=ល្បែងក្តារដូច Abalone +GenericName[lv]=Abalone līdzīga galda spēle +GenericName[mk]=Игра на табла слична на Abalone +GenericName[nb]=Abalone-lignende brettspill +GenericName[nds]=Abalone-liek Brettspeel +GenericName[ne]=एबालोन जस्तै बोर्ड खेल +GenericName[nl]=Abalone-achtig bordspel +GenericName[nn]=Abalone-liknande brettspel +GenericName[pl]=Gra planszowa typu Abalone +GenericName[pt]=Jogo de Tabuleiro tipo Abalone +GenericName[pt_BR]=Jogo parecido com Abalone +GenericName[ru]=Абалоне +GenericName[se]=Abalone-lágan duolbbášspeallu +GenericName[sk]=Stolová hra typu Abalone +GenericName[sl]=Ploščadna igra, podobna Abalone +GenericName[sr]=Игра на табли налик на Abalone +GenericName[sr@Latn]=Igra na tabli nalik na Abalone +GenericName[sv]=Abalone-liknande brädspel +GenericName[uk]=Гра на дошці подібна до гри Abalone +GenericName[zh_TW]=類似 Abalone 的棋盤遊戲 +X-KDE-StartupNotify=true +X-DCOP-ServiceType=Multi +Categories=Qt;KDE;Game;BoardGame; diff --git a/kenolaba/kenolabaui.rc b/kenolaba/kenolabaui.rc new file mode 100644 index 00000000..cf8c1626 --- /dev/null +++ b/kenolaba/kenolabaui.rc @@ -0,0 +1,53 @@ +<!DOCTYPE kpartgui> +<kpartgui name="kenolaba" version="5"> + + <MenuBar> + <Menu name="game"><text>&Game</text> + <Action name="game_net"/> + </Menu> + <Menu name="move"><text>&Move</text> + <Action name="move_stop"/> + <Action name="move_back"/> + <Action name="move_forward"/> + </Menu> + <Menu name="edit"><text>&Edit</text> + <Action name="edit_modify"/> + <Separator/> + <Action name="edit_save"/> + <Action name="edit_restore"/> + </Menu> + <Menu name="settings"><text>&Settings</text> + <Action name="options_iplay" append="save_merge"/> + <Action name="options_moveSlow" append="save_merge"/> + <Action name="options_renderBalls" append="save_merge"/> + <Action name="options_showSpy" append="save_merge"/> + </Menu> + </MenuBar> + + <Menu name="rmbPopup"> + <Menu name="rmbSettings"><text>&Settings</text> + <Action name="options_show_menubar"/> + <Action name="options_show_toolbar"/> + <Action name="options_show_statusbar"/> + <Separator/> + <Action name="options_save_options"/> + </Menu> + <Separator/> + <Action name="game_new"/> + <Action name="move_back"/> + <Action name="move_hint"/> + <Action name="move_stop"/> + </Menu> + + <ToolBar noMerge="1" name="mainToolBar"><text>Main Toolbar</text> + <Action name="game_new"/> + <Action name="edit_modify"/> + <Separator/> + <Action name="move_back"/> + <Action name="move_hint"/> + <Action name="move_stop"/> + <Separator/> + <Action name="game_net"/> + </ToolBar> + +</kpartgui> diff --git a/kenolaba/toolbar/Makefile.am b/kenolaba/toolbar/Makefile.am new file mode 100644 index 00000000..5fdccbb7 --- /dev/null +++ b/kenolaba/toolbar/Makefile.am @@ -0,0 +1,7 @@ +tb_DATA = new.xpm stop.xpm edit.xpm hint.xpm undo.xpm \ + redball.xpm yellowball.xpm noball.xpm warning.xpm ok.xpm \ + spy0.xpm spy1.xpm spy2.xpm spy3.xpm network.xpm +tbdir = $(kde_datadir)/kenolaba/pics + +EXTRA_DIST = $(tb_DATA) + diff --git a/kenolaba/toolbar/edit.xpm b/kenolaba/toolbar/edit.xpm new file mode 100644 index 00000000..20412f2e --- /dev/null +++ b/kenolaba/toolbar/edit.xpm @@ -0,0 +1,38 @@ +/* XPM */ +static char*ab[]={ +"22 22 13 1", +"j c #ffa858", +"d c #c0c0c0", +"c c #d6cdbb", +"g c #ffc0c0", +"h c #c05800", +"# c #000000", +"k c #ffdca8", +". c None", +"e c #c00000", +"b c #a0a0a4", +"a c #dcdcdc", +"i c #ffffff", +"f c #ff0000", +"......................", +"................#aa...", +"...............#aa#b..", +".............cc#aa#bc.", +"......#########aa#bb..", +".....#dddddddd#aa#bc..", +".....#dededed#aa#bb...", +"....#ddfgfgfg#aa#bcc..", +"....#ddddddd####bb.cc.", +"...#dddddde#aa##bc....", +"...#dddhdd#iia##b.....", +"..#ddddjkd#iab##b#c...", +"..#dddddd#iab##bb#c...", +"..c#ddhdd#ab##bb#c....", +"...#ddjk#ib##bbi#c....", +"...c#dd####bbbi#c.....", +"....#ddhbbbbddi#c.....", +"....c#djkjkjki#c......", +".....#iiiiiiii#c......", +".....c########c.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/help.xpm b/kenolaba/toolbar/help.xpm new file mode 100644 index 00000000..71348f4d --- /dev/null +++ b/kenolaba/toolbar/help.xpm @@ -0,0 +1,29 @@ +/* XPM */ +static char * help_xpm[] = { +"22 22 4 1", +" c None", +". c #000000", +"X c #000086", +"o c #868286", +" ", +" ", +" ", +" ", +" . XXXXXo ", +" .. XX oXXo ", +" ... XXo XXX ", +" .... XXo XXX ", +" ..... oXX oXXo ", +" ...... XXo ", +" ....... XX ", +" ........ XXo ", +" ..... XXo ", +" .. .. ", +" . .. XXX ", +" .. XXX ", +" .. ", +" .. ", +" ", +" ", +" ", +" "}; diff --git a/kenolaba/toolbar/hint.xpm b/kenolaba/toolbar/hint.xpm new file mode 100644 index 00000000..399c7c07 --- /dev/null +++ b/kenolaba/toolbar/hint.xpm @@ -0,0 +1,31 @@ +/* XPM */ +static char * hint_xpm[] = { +"22 22 6 1", +" c None", +". c #000086", +"X c #868286", +"o c black", +"O c red", +"+ c yellow", +" ", +" ", +" .....X ", +" .. X..X ", +" ..X ... ", +" ..X ... ", +" X.. X..X ", +" ..X ", +" .. ", +" oooo ..X ", +" oooooooo ..X ", +" ooOOOOoooo ", +" oOOo oooo ... ", +" oOOo oo oooo... ", +" oOo oooo o+o ", +" oOo oooo o+o ", +" oooo oo o++o ", +" oooo o++o ", +" ooooo+++oo ", +" oooooooo ", +" oooo ", +" "}; diff --git a/kenolaba/toolbar/network.xpm b/kenolaba/toolbar/network.xpm new file mode 100644 index 00000000..0878c2bb --- /dev/null +++ b/kenolaba/toolbar/network.xpm @@ -0,0 +1,35 @@ +/* XPM */ +static char*net[]={ +"22 22 10 1", +". c None", +"b c #808080", +"f c #a0a0a0", +"a c #c3c3c3", +"# c #000000", +"e c #0000c0", +"h c #ffff00", +"d c #585858", +"c c #ffffff", +"g c #ff0000", +"......................", +"......................", +".....#######..........", +"...##aaaabbb##........", +"...#ccaaaaabbb##......", +"...#ddccaaaaabbb#.....", +"...#eeddccaaabbbb#....", +"...#eeeeddcaadbbb#....", +"...#eeeeeecbbdbbb#....", +"...#eeeeeecbbdbbb#....", +"...#aeeeeecbbdbbb#....", +"....#aaeeecbbdbb#.....", +"....###aaecbb###......", +"....#aa##aa##dd#......", +".....##aa##dd##.......", +"..###..##ad##..d##d...", +".##aa##..##.#.##aa##..", +".#aaaaa##..#.#fgagaf#.", +"..##daaaa##..#aaaaaa##", +"....##daa#...#ahaaha#.", +"......###.....##ah##..", +"...............d##d..."}; diff --git a/kenolaba/toolbar/new.xpm b/kenolaba/toolbar/new.xpm new file mode 100644 index 00000000..e5aa03fc --- /dev/null +++ b/kenolaba/toolbar/new.xpm @@ -0,0 +1,36 @@ +/* XPM */ +static char*ab[]={ +"22 22 11 1", +"h c #ffa858", +"d c #d6cdbb", +"b c #c0c0c0", +"f c #ffc0c0", +"g c #c05800", +"# c #000000", +"i c #ffdca8", +". c None", +"c c #c00000", +"a c #ffffff", +"e c #ff0000", +"......................", +"................#a....", +"................#a....", +".............#a.#a.#a.", +"......#######.#a#a#a..", +".....#bbbbbbbb.#.#....", +".....#bcbcbcba.d......", +"....#bbefefefb#a#a#a..", +"....#bbbbbbbb#a.#a.#a.", +"...#bbbbbbcbcbb.#a....", +"...#bbbgbbefefba#a....", +"..#bbbbhibbbbbbba#d...", +"..#bbbbbbbbbbcbba#d...", +"..d#bbgbbbgbbefa#d....", +"...#bbhibbhibbba#d....", +"...d#bbbbbbbbba#d.....", +"....#bbgbgbgbba#d.....", +"....d#bhihihia#d......", +".....#aaaaaaaa#d......", +".....d########d.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/noball.xpm b/kenolaba/toolbar/noball.xpm new file mode 100644 index 00000000..14673de6 --- /dev/null +++ b/kenolaba/toolbar/noball.xpm @@ -0,0 +1,22 @@ +/* XPM */ +static char*noball[]={ +"16 16 3 1", +"# c #808080", +". c None", +"a c #ffffff", +".....#####......", +"...#########....", +"..###aaaaa###...", +".###a.....a###a.", +".##a........##a.", +"##a..........##a", +"##a..........##a", +"##a..........##a", +"##a..........##a", +"##a..........##a", +".##a........##a.", +".###.......###a.", +"..###.....###a..", +"...#########a...", +"...aa#####aa....", +".....aaaaa......"}; diff --git a/kenolaba/toolbar/ok.xpm b/kenolaba/toolbar/ok.xpm new file mode 100644 index 00000000..290d4657 --- /dev/null +++ b/kenolaba/toolbar/ok.xpm @@ -0,0 +1,25 @@ +/* XPM */ +static char*ok[]={ +"16 16 6 1", +"d c #00ff00", +"b c #004000", +"# c #c0c0ff", +"a c #000000", +". c None", +"c c #ffffff", +".....#####......", +"...#######......", +"..#######.abbc..", +".#######.abbbc..", +".######.abbdbc..", +"#######.abdbc.#.", +"######.abdbc.##.", +"##.###.abbc.###.", +"#.ac#.abdc.####.", +"#abc..abbc.####.", +"..bbcabbc.####..", +".#.bcbbc.#####..", +"...abbc.#####...", +"....bbc#####....", +"....ac.###......", +"................"}; diff --git a/kenolaba/toolbar/redball.xpm b/kenolaba/toolbar/redball.xpm new file mode 100644 index 00000000..24450be5 --- /dev/null +++ b/kenolaba/toolbar/redball.xpm @@ -0,0 +1,25 @@ +/* XPM */ +static char*redball[]={ +"16 16 6 1", +"# c #000000", +"a c #400000", +"b c #800000", +". c None", +"d c #ffffff", +"c c #ff0000", +".....#####......", +"...##aaaaa##....", +"..##aabbbbb##...", +".##aabbbbbbb##..", +".#aabbbbbbbbb#..", +"#aabbbbbbbbbbb#.", +"#aabbbbbcccbbb#.", +"#aabbbbcccccbb#.", +"#aabbbcccccccb#.", +"#aabbbccccdccb#.", +".#aabbcccdddc#..", +".##aabbcccdc##..", +"..##aabbccc##...", +"...##aaaaa##....", +".....#####......", +"................"}; diff --git a/kenolaba/toolbar/spy0.xpm b/kenolaba/toolbar/spy0.xpm new file mode 100644 index 00000000..a6cbb1c5 --- /dev/null +++ b/kenolaba/toolbar/spy0.xpm @@ -0,0 +1,39 @@ +/* XPM */ +static char*spy0[]={ +"22 22 14 1", +"a c #808080", +"j c #ffa858", +"l c #d6cdbb", +"c c #c0c0c0", +"g c #ffc0c0", +"i c #c05800", +"# c #000000", +". c None", +"k c #ffdca8", +"d c #c00000", +"h c #585858", +"e c #dcdcdc", +"b c #ffffff", +"f c #ff0000", +"......................", +"...........####.......", +"..........#....#......", +".........#.aaaa.#.....", +"......####baaaa.#b....", +".....#ccc#baaaa.#b....", +".....#cdc#eaaaa.#b....", +"....#ccfgf#ebbe#b.....", +"....#cccccc#####h.....", +"...#ccccccdcdcc.hb....", +"...#ccciccfgfgc.#h....", +"..#ccccjkccccccc.hb...", +"..#ccccccccccdcc.#h...", +"..l#cciccciccfgb#.hb..", +"...#ccjkccjkcccb#..h..", +"...l#cccccccccb#l..h..", +"....#cciciciccb#l.....", +"....l#cjkjkjkb#l......", +".....#bbbbbbbb#l......", +".....l########l.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/spy1.xpm b/kenolaba/toolbar/spy1.xpm new file mode 100644 index 00000000..24baa2ba --- /dev/null +++ b/kenolaba/toolbar/spy1.xpm @@ -0,0 +1,38 @@ +/* XPM */ +static char*spy1[]={ +"22 22 13 1", +"i c #ffa858", +"k c #d6cdbb", +"e c #c0c0c0", +"g c #ffc0c0", +"h c #c05800", +"# c #000000", +". c None", +"j c #ffdca8", +"f c #c00000", +"d c #a0a0a4", +"a c #dcdcdc", +"b c #ffffff", +"c c #ff0000", +"......................", +"...........####.......", +"..........#abba#......", +".........#ac##ca#.....", +"......####bdccbb#b....", +".....#eee#bbccbb#b....", +".....#efe#acbbca#b....", +"....#eecgc#abba#bb....", +"....#eeeeee######b....", +"...#eeeeeefefee##bb...", +"...#eeeheecgcge###b...", +"..#eeeeijeeeeeee##b...", +"..#eeeeeeeeeefee###b..", +"..k#eeheeeheecgbb#....", +"...#eeijeeijeeebb.....", +"...k#eeeeeeeeeb#k.....", +"....#eeheheheeb#k.....", +"....k#eijijijb#k......", +".....#bbbbbbbb#k......", +".....k########k.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/spy2.xpm b/kenolaba/toolbar/spy2.xpm new file mode 100644 index 00000000..cd2cb150 --- /dev/null +++ b/kenolaba/toolbar/spy2.xpm @@ -0,0 +1,40 @@ +/* XPM */ +static char*spy2[]={ +"22 22 15 1", +"j c #ffa858", +"g c #c3c3c3", +"l c #d6cdbb", +"e c #c0c0c0", +"m c #ffc0c0", +"i c #c05800", +"# c #000000", +". c None", +"h c #800000", +"k c #ffdca8", +"f c #c00000", +"d c #a0a0a4", +"a c #dcdcdc", +"b c #ffffff", +"c c #ff0000", +"......................", +"...........####.......", +".........##abba##.....", +".........#ac##ca#.....", +"......####bdccbb##....", +".....#ee#b#bccb#b#....", +".....#ef#gachhcab#....", +"....#eec#bhhhhhhb#....", +"....#eee##ehhhhb##....", +"...#eeeee#gggbgg#bb...", +"...#eeeie##bbbb###b...", +"..#eeeejkee#######bb..", +"..#eeeeeeeeeefee###b..", +"..l#eeieeeieecmbb#....", +"...#eejkeejkeeebb.....", +"...l#eeeeeeeeeb#l.....", +"....#eeieieieeb#l.....", +"....l#ejkjkjkb#l......", +".....#bbbbbbbb#l......", +".....l########l.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/spy3.xpm b/kenolaba/toolbar/spy3.xpm new file mode 100644 index 00000000..b19cbdcc --- /dev/null +++ b/kenolaba/toolbar/spy3.xpm @@ -0,0 +1,38 @@ +/* XPM */ +static char*spy3[]={ +"22 22 13 1", +"j c #ffa858", +"d c #c3c3c3", +"h c #d6cdbb", +"f c #c0c0c0", +"i c #c05800", +"# c #000000", +". c None", +"g c #800000", +"k c #ffdca8", +"e c #a0a0a4", +"a c #dcdcdc", +"b c #ffffff", +"c c #ff0000", +"...........####.......", +".........########.....", +"........###abba###....", +".......###ac##ca###...", +"......###dbeccbbd##...", +".....#f##b#cccc#b##...", +".....###ddacggcabd##..", +"....#f##dbggggggbd##..", +"....#f##d###gg###d##..", +"...#ff##dd#cccc#dd##..", +"...#ff###ddbccbdd##...", +"..#ffff###dddddd###...", +"..#ffffd####dd####....", +"..h#ffifd######b#.....", +"...#ffjkfdd######.....", +"...h#fffffffffb#h.....", +"....#ffifififfb#h.....", +"....h#fjkjkjkb#h......", +".....#bbbbbbbb#h......", +".....h########h.......", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/stop.xpm b/kenolaba/toolbar/stop.xpm new file mode 100644 index 00000000..c8e641c6 --- /dev/null +++ b/kenolaba/toolbar/stop.xpm @@ -0,0 +1,30 @@ +/* XPM */ +static char * ab_stop_xpm[] = { +"22 22 5 1", +" c none", +". c black", +"X c white", +"o c red", +"O c #820782078207", +" ", +" ", +" ", +" ....... ", +" ......... ", +" ..XXXXXX... ", +" ..X o o o ... ", +" ..X o o o o ... ", +" ..Xo o o o oO.. ", +" ..X o o o o O.. ", +" ..Xo o o o oO.. ", +" ..X o o o o O.. ", +" ..Xo o o o oO.. ", +" ... o o o o O.. ", +" ... o o o O.. ", +" ...OOOOOO.. ", +" ......... ", +" ....... ", +" ", +" ", +" ", +" "}; diff --git a/kenolaba/toolbar/undo.xpm b/kenolaba/toolbar/undo.xpm new file mode 100644 index 00000000..9b002026 --- /dev/null +++ b/kenolaba/toolbar/undo.xpm @@ -0,0 +1,27 @@ +/* XPM */ +static char*undo[]={ +"22 22 2 1", +"# c #000080", +". c None", +"......................", +"......................", +"......................", +"......................", +"......................", +"......................", +"......................", +"..........######......", +".........########.....", +"........####....##....", +"........###...........", +".......###............", +".....#######..........", +"......#####...........", +".......###............", +"........#.............", +"......................", +"......................", +"......................", +"......................", +"......................", +"......................"}; diff --git a/kenolaba/toolbar/warning.xpm b/kenolaba/toolbar/warning.xpm new file mode 100644 index 00000000..b2674f2a --- /dev/null +++ b/kenolaba/toolbar/warning.xpm @@ -0,0 +1,26 @@ +/* XPM */ +static char*warning[]={ +"16 16 7 1", +"e c #d6cdbb", +"# c #c0c0ff", +"a c #000000", +". c None", +"c c #400000", +"b c #ffffff", +"d c #ff0000", +"................", +"...##.aaab.#....", +"..##.accccb.#...", +".###.accdcb.##..", +".###.accdcb.##..", +"####..adcb.####.", +"#####.accb.####.", +"######.ab.#####.", +"######.ab.#####.", +"######.b.######.", +".######..#####..", +".#####.ab.####..", +"..###.adcb.##...", +"...###.cbe##....", +".....#.be#......", +"................"}; diff --git a/kenolaba/toolbar/yellowball.xpm b/kenolaba/toolbar/yellowball.xpm new file mode 100644 index 00000000..fc986c52 --- /dev/null +++ b/kenolaba/toolbar/yellowball.xpm @@ -0,0 +1,25 @@ +/* XPM */ +static char*yellowball[]={ +"16 16 6 1", +"b c #c0c000", +"a c #808000", +"# c #000000", +"c c #ffff00", +". c None", +"d c #ffffff", +".....#####......", +"...##aaaaa##....", +"..##aaaaaaa##...", +".##aaaabbbaa##..", +".#aaaabbbbbaa#..", +"#aaaabbbbbbbaa#.", +"#aaabbbbbbbbba#.", +"#aaabbbccccbba#.", +"#aaabbbcccccba#.", +"#aaaabbcccdcaa#.", +".#aaaabccddda#..", +".##aaaabccdc##..", +"..##aaaaaaa##...", +"...##aaaaa##....", +".....#####......", +"................"}; diff --git a/kenolaba/version.h b/kenolaba/version.h new file mode 100644 index 00000000..90e8ddd1 --- /dev/null +++ b/kenolaba/version.h @@ -0,0 +1 @@ +#define KENOLABA_VERSION "1.06b" |
