Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegames@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 4302 insertions, 0 deletions

diff --git a/kolf/game.cpp b/kolf/game.cpp
new file mode 100644
index 00000000..55b324ce
--- /dev/null
+++ b/kolf/game.cpp
@@ -0,0 +1,4302 @@
+#include <arts/kmedia2.h>
+#include <arts/kplayobject.h>
+#include <arts/kplayobjectfactory.h>
+
+#include <kapplication.h>
+#include <kconfig.h>
+#include <kcursor.h>
+#include <kdebug.h>
+#include <knuminput.h>
+#include <kfiledialog.h>
+#include <kglobal.h>
+#include <klineedit.h>
+#include <kmessagebox.h>
+#include <kpixmapeffect.h>
+#include <kprinter.h>
+#include <kstandarddirs.h>
+
+#include <qbrush.h>
+#include <qcanvas.h>
+#include <qcheckbox.h>
+#include <qcolor.h>
+#include <qcursor.h>
+#include <qevent.h>
+#include <qfont.h>
+#include <qfontmetrics.h>
+#include <qimage.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qmap.h>
+#include <qpainter.h>
+#include <qpaintdevicemetrics.h>
+#include <qpen.h>
+#include <qpixmap.h>
+#include <qpixmapcache.h>
+#include <qpoint.h>
+#include <qpointarray.h>
+#include <qrect.h>
+#include <qsimplerichtext.h>
+#include <qsize.h>
+#include <qslider.h>
+#include <qspinbox.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qtimer.h>
+#include <qtooltip.h>
+#include <qvaluelist.h>
+#include <qwhatsthis.h>
+
+#include <math.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "kcomboboxdialog.h"
+#include "kvolumecontrol.h"
+#include "vector.h"
+#include "game.h"
+
+
+inline QString makeGroup(int id, int hole, QString name, int x, int y)
+{
+	return QString("%1-%2@%3,%4|%5").arg(hole).arg(name).arg(x).arg(y).arg(id);
+}
+
+inline QString makeStateGroup(int id, const QString &name)
+{
+	return QString("%1|%2").arg(name).arg(id);
+}
+
+/////////////////////////
+
+RectPoint::RectPoint(QColor color, RectItem *rect, QCanvas *canvas)
+	: QCanvasEllipse(canvas)
+{
+	setZ(9999);
+	setSize(10, 10);
+	this->rect = rect;
+	setBrush(QBrush(color));
+	setSizeFactor(1.0);
+	dontmove = false;
+}
+
+void RectPoint::moveBy(double dx, double dy)
+{
+	QCanvasEllipse::moveBy(dx, dy);
+
+	if (dontmove)
+	{
+		dontmove = false;
+		return;
+	}
+
+	QCanvasItem *qitem = dynamic_cast<QCanvasItem *>(rect);
+	if (!qitem)
+		return;
+
+	double nw = m_sizeFactor * fabs(x() - qitem->x());
+	double nh = m_sizeFactor * fabs(y() - qitem->y());
+	if (nw <= 0 || nh <= 0)
+		return;
+
+	rect->newSize(nw, nh);
+}
+
+Config *RectPoint::config(QWidget *parent)
+{
+	CanvasItem *citem = dynamic_cast<CanvasItem *>(rect);
+	if (citem)
+		return citem->config(parent);
+	else
+		return CanvasItem::config(parent);
+}
+
+/////////////////////////
+
+Arrow::Arrow(QCanvas *canvas)
+	: QCanvasLine(canvas)
+{
+	line1 = new QCanvasLine(canvas);
+	line2 = new QCanvasLine(canvas);
+
+	m_angle = 0;
+	m_length = 20;
+	m_reversed = false;
+
+	setPen(black);
+
+	updateSelf();
+	setVisible(false);
+}
+
+void Arrow::setPen(QPen p)
+{
+	QCanvasLine::setPen(p);
+	line1->setPen(p);
+	line2->setPen(p);
+}
+
+void Arrow::setZ(double newz)
+{
+	QCanvasLine::setZ(newz);
+	line1->setZ(newz);
+	line2->setZ(newz);
+}
+
+void Arrow::setVisible(bool yes)
+{
+	QCanvasLine::setVisible(yes);
+	line1->setVisible(yes);
+	line2->setVisible(yes);
+}
+
+void Arrow::moveBy(double dx, double dy)
+{
+	QCanvasLine::moveBy(dx, dy);
+	line1->moveBy(dx, dy);
+	line2->moveBy(dx, dy);
+}
+
+void Arrow::aboutToDie()
+{
+	delete line1;
+	delete line2;
+}
+
+void Arrow::updateSelf()
+{
+	QPoint start = startPoint();
+	QPoint end(m_length * cos(m_angle), m_length * sin(m_angle));
+
+	if (m_reversed)
+	{
+		QPoint tmp(start);
+		start = end;
+		end = tmp;
+	}
+
+	setPoints(start.x(), start.y(), end.x(), end.y());
+
+	const double lineLen = m_length / 2;
+
+	const double angle1 = m_angle - M_PI / 2 - 1;
+	line1->move(end.x() + x(), end.y() + y());
+	start = end;
+	end = QPoint(lineLen * cos(angle1), lineLen * sin(angle1));
+	line1->setPoints(0, 0, end.x(), end.y());
+
+	const double angle2 = m_angle + M_PI / 2 + 1;
+	line2->move(start.x() + x(), start.y() + y());
+	end = QPoint(lineLen * cos(angle2), lineLen * sin(angle2));
+	line2->setPoints(0, 0, end.x(), end.y());
+}
+
+/////////////////////////
+
+BridgeConfig::BridgeConfig(Bridge *bridge, QWidget *parent)
+	: Config(parent)
+{
+	this->bridge = bridge;
+
+	m_vlayout = new QVBoxLayout(this, marginHint(), spacingHint());
+	QGridLayout *layout = new QGridLayout(m_vlayout, 2, 3, spacingHint());
+	layout->addWidget(new QLabel(i18n("Walls on:"), this), 0, 0);
+	top = new QCheckBox(i18n("&Top"), this);
+	layout->addWidget(top, 0, 1);
+	connect(top, SIGNAL(toggled(bool)), this, SLOT(topWallChanged(bool)));
+	top->setChecked(bridge->topWallVisible());
+	bot = new QCheckBox(i18n("&Bottom"), this);
+	layout->addWidget(bot, 1, 1);
+	connect(bot, SIGNAL(toggled(bool)), this, SLOT(botWallChanged(bool)));
+	bot->setChecked(bridge->botWallVisible());
+	left = new QCheckBox(i18n("&Left"), this);
+	layout->addWidget(left, 1, 0);
+	connect(left, SIGNAL(toggled(bool)), this, SLOT(leftWallChanged(bool)));
+	left->setChecked(bridge->leftWallVisible());
+	right = new QCheckBox(i18n("&Right"), this);
+	layout->addWidget(right, 1, 2);
+	connect(right, SIGNAL(toggled(bool)), this, SLOT(rightWallChanged(bool)));
+	right->setChecked(bridge->rightWallVisible());
+}
+
+void BridgeConfig::topWallChanged(bool yes)
+{
+	bridge->setTopWallVisible(yes);
+	changed();
+}
+
+void BridgeConfig::botWallChanged(bool yes)
+{
+	bridge->setBotWallVisible(yes);
+	changed();
+}
+
+void BridgeConfig::leftWallChanged(bool yes)
+{
+	bridge->setLeftWallVisible(yes);
+	changed();
+}
+
+void BridgeConfig::rightWallChanged(bool yes)
+{
+	bridge->setRightWallVisible(yes);
+	changed();
+}
+
+/////////////////////////
+
+Bridge::Bridge(QRect rect, QCanvas *canvas)
+	: QCanvasRectangle(rect, canvas)
+{
+	QColor color("#92772D");
+	setBrush(QBrush(color));
+	setPen(NoPen);
+	setZ(998);
+
+	topWall = new Wall(canvas);
+	topWall->setAlwaysShow(true);
+	botWall = new Wall(canvas);
+	botWall->setAlwaysShow(true);
+	leftWall = new Wall(canvas);
+	leftWall->setAlwaysShow(true);
+	rightWall = new Wall(canvas);
+	rightWall->setAlwaysShow(true);
+
+	setWallZ(z() + 0.01);
+	setWallColor(color);
+
+	topWall->setVisible(false);
+	botWall->setVisible(false);
+	leftWall->setVisible(false);
+	rightWall->setVisible(false);
+
+	point = new RectPoint(color, this, canvas);
+	editModeChanged(false);
+
+	newSize(width(), height());
+}
+
+bool Bridge::collision(Ball *ball, long int /*id*/)
+{
+	ball->setFrictionMultiplier(.63);
+	return false;
+}
+
+void Bridge::setWallZ(double newz)
+{
+	topWall->setZ(newz);
+	botWall->setZ(newz);
+	leftWall->setZ(newz);
+	rightWall->setZ(newz);
+}
+
+void Bridge::setGame(KolfGame *game)
+{
+	CanvasItem::setGame(game);
+	topWall->setGame(game);
+	botWall->setGame(game);
+	leftWall->setGame(game);
+	rightWall->setGame(game);
+}
+
+void Bridge::setWallColor(QColor color)
+{
+	topWall->setPen(QPen(color.dark(), 3));
+	botWall->setPen(topWall->pen());
+	leftWall->setPen(topWall->pen());
+	rightWall->setPen(topWall->pen());
+}
+
+void Bridge::aboutToDie()
+{
+	delete point;
+	topWall->aboutToDie();
+	delete topWall;
+	botWall->aboutToDie();
+	delete botWall;
+	leftWall->aboutToDie();
+	delete leftWall;
+	rightWall->aboutToDie();
+	delete rightWall;
+}
+
+void Bridge::editModeChanged(bool changed)
+{
+	point->setVisible(changed);
+	moveBy(0, 0);
+}
+
+void Bridge::moveBy(double dx, double dy)
+{
+	QCanvasRectangle::moveBy(dx, dy);
+
+	point->dontMove();
+	point->move(x() + width(), y() + height());
+
+	topWall->move(x(), y());
+	botWall->move(x(), y() - 1);
+	leftWall->move(x(), y());
+	rightWall->move(x(), y());
+
+	QCanvasItemList list = collisions(true);
+	for (QCanvasItemList::Iterator it = list.begin(); it != list.end(); ++it)
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(*it);
+		if (citem)
+			citem->updateZ();
+	}
+}
+
+void Bridge::load(KConfig *cfg)
+{
+	doLoad(cfg);
+}
+
+void Bridge::doLoad(KConfig *cfg)
+{
+	newSize(cfg->readNumEntry("width", width()), cfg->readNumEntry("height", height()));
+	setTopWallVisible(cfg->readBoolEntry("topWallVisible", topWallVisible()));
+	setBotWallVisible(cfg->readBoolEntry("botWallVisible", botWallVisible()));
+	setLeftWallVisible(cfg->readBoolEntry("leftWallVisible", leftWallVisible()));
+	setRightWallVisible(cfg->readBoolEntry("rightWallVisible", rightWallVisible()));
+}
+
+void Bridge::save(KConfig *cfg)
+{
+	doSave(cfg);
+}
+
+void Bridge::doSave(KConfig *cfg)
+{
+	cfg->writeEntry("width", width());
+	cfg->writeEntry("height", height());
+	cfg->writeEntry("topWallVisible", topWallVisible());
+	cfg->writeEntry("botWallVisible", botWallVisible());
+	cfg->writeEntry("leftWallVisible", leftWallVisible());
+	cfg->writeEntry("rightWallVisible", rightWallVisible());
+}
+
+QPtrList<QCanvasItem> Bridge::moveableItems() const
+{
+	QPtrList<QCanvasItem> ret;
+	ret.append(point);
+	return ret;
+}
+
+void Bridge::newSize(int width, int height)
+{
+	setSize(width, height);
+}
+
+void Bridge::setSize(int width, int height)
+{
+	QCanvasRectangle::setSize(width, height);
+
+	topWall->setPoints(0, 0, width, 0);
+	botWall->setPoints(0, height, width, height);
+	leftWall->setPoints(0, 0, 0, height);
+	rightWall->setPoints(width, 0, width, height);
+
+	moveBy(0, 0);
+}
+
+/////////////////////////
+
+WindmillConfig::WindmillConfig(Windmill *windmill, QWidget *parent)
+	: BridgeConfig(windmill, parent)
+{
+	this->windmill = windmill;
+	m_vlayout->addStretch();
+
+	QCheckBox *check = new QCheckBox(i18n("Windmill on bottom"), this);
+	check->setChecked(windmill->bottom());
+	connect(check, SIGNAL(toggled(bool)), this, SLOT(endChanged(bool)));
+	m_vlayout->addWidget(check);
+
+	QHBoxLayout *hlayout = new QHBoxLayout(m_vlayout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Slow"), this));
+	QSlider *slider = new QSlider(1, 10, 1, windmill->curSpeed(), Qt::Horizontal, this);
+	hlayout->addWidget(slider);
+	hlayout->addWidget(new QLabel(i18n("Fast"), this));
+	connect(slider, SIGNAL(valueChanged(int)), this, SLOT(speedChanged(int)));
+
+	endChanged(check->isChecked());
+}
+
+void WindmillConfig::speedChanged(int news)
+{
+	windmill->setSpeed(news);
+	changed();
+}
+
+void WindmillConfig::endChanged(bool bottom)
+{
+	windmill->setBottom(bottom);
+	changed();
+
+	bot->setEnabled(!bottom);
+	if (startedUp)
+	{
+		bot->setChecked(!bottom);
+		botWallChanged(bot->isChecked());
+	}
+	top->setEnabled(bottom);
+	if (startedUp)
+	{
+		top->setChecked(bottom);
+		topWallChanged(top->isChecked());
+	}
+}
+
+/////////////////////////
+
+Windmill::Windmill(QRect rect, QCanvas *canvas)
+	: Bridge(rect, canvas), speedfactor(16), m_bottom(true)
+{
+	guard = new WindmillGuard(canvas);
+	guard->setPen(QPen(black, 5));
+	guard->setVisible(true);
+	guard->setAlwaysShow(true);
+	setSpeed(5);
+	guard->setZ(wallZ() + .1);
+
+	left = new Wall(canvas);
+	left->setPen(wallPen());
+	left->setAlwaysShow(true);
+	right = new Wall(canvas);
+	right->setPen(wallPen());
+	right->setAlwaysShow(true);
+	left->setZ(wallZ());
+	right->setZ(wallZ());
+	left->setVisible(true);
+	right->setVisible(true);
+
+	setTopWallVisible(false);
+	setBotWallVisible(false);
+	setLeftWallVisible(true);
+	setRightWallVisible(true);
+
+	newSize(width(), height());
+	moveBy(0, 0);
+}
+
+void Windmill::aboutToDie()
+{
+	Bridge::aboutToDie();
+	guard->aboutToDie();
+	delete guard;
+	left->aboutToDie();
+	delete left;
+	right->aboutToDie();
+	delete right;
+}
+
+void Windmill::setSpeed(int news)
+{
+	if (news < 0)
+		return;
+	speed = news;
+	guard->setXVelocity(((double)news / (double)3) * (guard->xVelocity() > 0? 1 : -1));
+}
+
+void Windmill::setGame(KolfGame *game)
+{
+	Bridge::setGame(game);
+	guard->setGame(game);
+	left->setGame(game);
+	right->setGame(game);
+}
+
+void Windmill::save(KConfig *cfg)
+{
+	cfg->writeEntry("speed", speed);
+	cfg->writeEntry("bottom", m_bottom);
+
+	doSave(cfg);
+}
+
+void Windmill::load(KConfig *cfg)
+{
+	setSpeed(cfg->readNumEntry("speed", -1));
+
+	doLoad(cfg);
+
+	left->editModeChanged(false);
+	right->editModeChanged(false);
+	guard->editModeChanged(false);
+
+	setBottom(cfg->readBoolEntry("bottom", true));
+}
+
+void Windmill::moveBy(double dx, double dy)
+{
+	Bridge::moveBy(dx, dy);
+
+	left->move(x(), y());
+	right->move(x(), y());
+
+	guard->moveBy(dx, dy);
+	guard->setBetween(x(), x() + width());
+
+	update();
+}
+
+void Windmill::setSize(int width, int height)
+{
+	newSize(width, height);
+}
+
+void Windmill::setBottom(bool yes)
+{
+	m_bottom = yes;
+	newSize(width(), height());
+}
+
+void Windmill::newSize(int width, int height)
+{
+	Bridge::newSize(width, height);
+
+	const int indent = width / 4;
+
+	double indentY = m_bottom? height : 0;
+	left->setPoints(0, indentY, indent, indentY);
+	right->setPoints(width - indent, indentY, width, indentY);
+
+	guard->setBetween(x(), x() + width);
+	double guardY = m_bottom? height + 4 : -4;
+	guard->setPoints(0, guardY, (double)indent / (double)1.07 - 2, guardY);
+}
+
+/////////////////////////
+
+void WindmillGuard::advance(int phase)
+{
+	Wall::advance(phase);
+
+	if (phase == 1)
+	{
+		if (x() + startPoint().x() <= min)
+			setXVelocity(fabs(xVelocity()));
+		else if (x() + endPoint().x() >= max)
+			setXVelocity(-fabs(xVelocity()));
+	}
+}
+
+/////////////////////////
+
+Sign::Sign(QCanvas *canvas)
+	: Bridge(QRect(0, 0, 110, 40), canvas)
+{
+	setZ(998.8);
+	m_text = m_untranslatedText = i18n("New Text");
+	setBrush(QBrush(white));
+	setWallColor(black);
+	setWallZ(z() + .01);
+
+	setTopWallVisible(true);
+	setBotWallVisible(true);
+	setLeftWallVisible(true);
+	setRightWallVisible(true);
+}
+
+void Sign::load(KConfig *cfg)
+{
+	m_text = cfg->readEntry("Comment", m_text);
+	m_untranslatedText = cfg->readEntryUntranslated("Comment", m_untranslatedText);
+
+	doLoad(cfg);
+}
+
+void Sign::save(KConfig *cfg)
+{
+	cfg->writeEntry("Comment", m_untranslatedText);
+
+	doSave(cfg);
+}
+
+void Sign::setText(const QString &text)
+{
+	m_text = text;
+	m_untranslatedText = text;
+
+	update();
+}
+
+void Sign::draw(QPainter &painter)
+{
+	Bridge::draw(painter);
+
+	painter.setPen(QPen(black, 1));
+	QSimpleRichText txt(m_text, kapp->font());
+	const int indent = wallPen().width() + 3;
+	txt.setWidth(width() - 2*indent);
+	QColorGroup colorGroup;
+	colorGroup.setColor(QColorGroup::Foreground, black);
+	colorGroup.setColor(QColorGroup::Text, black);
+	colorGroup.setColor(QColorGroup::Background, black);
+	colorGroup.setColor(QColorGroup::Base, black);
+	txt.draw(&painter, x() + indent, y(), QRect(x() + indent, y(), width() - indent, height() - indent), colorGroup);
+}
+
+/////////////////////////
+
+SignConfig::SignConfig(Sign *sign, QWidget *parent)
+	: BridgeConfig(sign, parent)
+{
+	this->sign = sign;
+	m_vlayout->addStretch();
+	m_vlayout->addWidget(new QLabel(i18n("Sign HTML:"), this));
+	KLineEdit *name = new KLineEdit(sign->text(), this);
+	m_vlayout->addWidget(name);
+	connect(name, SIGNAL(textChanged(const QString &)), this, SLOT(textChanged(const QString &)));
+}
+
+void SignConfig::textChanged(const QString &text)
+{
+	sign->setText(text);
+	changed();
+}
+
+/////////////////////////
+
+EllipseConfig::EllipseConfig(Ellipse *ellipse, QWidget *parent)
+	: Config(parent), slow1(0), fast1(0), slow2(0), fast2(0), slider1(0), slider2(0)
+{
+	this->ellipse = ellipse;
+
+	m_vlayout = new QVBoxLayout(this, marginHint(), spacingHint());
+
+	QCheckBox *check = new QCheckBox(i18n("Enable show/hide"), this);
+	m_vlayout->addWidget(check);
+	connect(check, SIGNAL(toggled(bool)), this, SLOT(check1Changed(bool)));
+	check->setChecked(ellipse->changeEnabled());
+
+	QHBoxLayout *hlayout = new QHBoxLayout(m_vlayout, spacingHint());
+	slow1 = new QLabel(i18n("Slow"), this);
+	hlayout->addWidget(slow1);
+	slider1 = new QSlider(1, 100, 5, 100 - ellipse->changeEvery(), Qt::Horizontal, this);
+	hlayout->addWidget(slider1);
+	fast1 = new QLabel(i18n("Fast"), this);
+	hlayout->addWidget(fast1);
+
+	connect(slider1, SIGNAL(valueChanged(int)), this, SLOT(value1Changed(int)));
+
+	check1Changed(ellipse->changeEnabled());
+
+	// TODO add slider2 and friends and make it possible for ellipses to grow and contract
+
+	m_vlayout->addStretch();
+}
+
+void EllipseConfig::value1Changed(int news)
+{
+	ellipse->setChangeEvery(100 - news);
+	changed();
+}
+
+void EllipseConfig::value2Changed(int /*news*/)
+{
+	changed();
+}
+
+void EllipseConfig::check1Changed(bool on)
+{
+	ellipse->setChangeEnabled(on);
+	if (slider1)
+		slider1->setEnabled(on);
+	if (slow1)
+		slow1->setEnabled(on);
+	if (fast1)
+		fast1->setEnabled(on);
+
+	changed();
+}
+
+void EllipseConfig::check2Changed(bool on)
+{
+	//ellipse->setChangeEnabled(on);
+	if (slider2)
+		slider2->setEnabled(on);
+	if (slow2)
+		slow2->setEnabled(on);
+	if (fast2)
+		fast2->setEnabled(on);
+
+	changed();
+}
+
+/////////////////////////
+
+Ellipse::Ellipse(QCanvas *canvas)
+	: QCanvasEllipse(canvas)
+{
+	savingDone();
+	setChangeEnabled(false);
+	setChangeEvery(50);
+	count = 0;
+	setVisible(true);
+
+	point = new RectPoint(black, this, canvas);
+	point->setSizeFactor(2.0);
+}
+
+void Ellipse::aboutToDie()
+{
+	delete point;
+}
+
+void Ellipse::setChangeEnabled(bool changeEnabled)
+{
+	m_changeEnabled = changeEnabled;
+	setAnimated(m_changeEnabled);
+
+	if (!m_changeEnabled)
+		setVisible(true);
+}
+
+QPtrList<QCanvasItem> Ellipse::moveableItems() const
+{
+	QPtrList<QCanvasItem> ret;
+	ret.append(point);
+	return ret;
+}
+
+void Ellipse::newSize(int width, int height)
+{
+	QCanvasEllipse::setSize(width, height);
+}
+
+void Ellipse::moveBy(double dx, double dy)
+{
+	QCanvasEllipse::moveBy(dx, dy);
+
+	point->dontMove();
+	point->move(x() + width() / 2, y() + height() / 2);
+}
+
+void Ellipse::editModeChanged(bool changed)
+{
+	point->setVisible(changed);
+	moveBy(0, 0);
+}
+
+void Ellipse::advance(int phase)
+{
+	QCanvasEllipse::advance(phase);
+
+	if (phase == 1 && m_changeEnabled && !dontHide)
+	{
+		if (count > (m_changeEvery + 10) * 1.8)
+			count = 0;
+		if (count == 0)
+			setVisible(!isVisible());
+
+		count++;
+	}
+}
+
+void Ellipse::load(KConfig *cfg)
+{
+	setChangeEnabled(cfg->readBoolEntry("changeEnabled", changeEnabled()));
+	setChangeEvery(cfg->readNumEntry("changeEvery", changeEvery()));
+	double newWidth = width(), newHeight = height();
+	newWidth = cfg->readNumEntry("width", newWidth);
+	newHeight = cfg->readNumEntry("height", newHeight);
+	newSize(newWidth, newHeight);
+}
+
+void Ellipse::save(KConfig *cfg)
+{
+	cfg->writeEntry("changeEvery", changeEvery());
+	cfg->writeEntry("changeEnabled", changeEnabled());
+	cfg->writeEntry("width", width());
+	cfg->writeEntry("height", height());
+}
+
+Config *Ellipse::config(QWidget *parent)
+{
+	return new EllipseConfig(this, parent);
+}
+
+void Ellipse::aboutToSave()
+{
+	setVisible(true);
+	dontHide = true;
+}
+
+void Ellipse::savingDone()
+{
+	dontHide = false;
+}
+
+/////////////////////////
+
+Puddle::Puddle(QCanvas *canvas)
+	: Ellipse(canvas)
+{
+	setSize(45, 30);
+
+	QBrush brush;
+	QPixmap pic;
+
+	if (!QPixmapCache::find("puddle", pic))
+	{
+		pic.load(locate("appdata", "pics/puddle.png"));
+		QPixmapCache::insert("puddle", pic);
+	}
+
+	brush.setPixmap(pic);
+	setBrush(brush);
+
+	KPixmap pointPic(pic);
+	KPixmapEffect::intensity(pointPic, .45);
+	brush.setPixmap(pointPic);
+	point->setBrush(brush);
+
+	setZ(-25);
+}
+
+bool Puddle::collision(Ball *ball, long int /*id*/)
+{
+	if (ball->isVisible())
+	{
+		QCanvasRectangle i(QRect(ball->x(), ball->y(), 1, 1), canvas());
+		i.setVisible(true);
+
+		// is center of ball in?
+		if (i.collidesWith(this)/* && ball->curVector().magnitude() < 4*/)
+		{
+			playSound("puddle");
+			ball->setAddStroke(ball->addStroke() + 1);
+			ball->setPlaceOnGround(true);
+			ball->setVisible(false);
+			ball->setState(Stopped);
+			ball->setVelocity(0, 0);
+			if (game && game->curBall() == ball)
+				game->stoppedBall();
+		}
+		else
+			return true;
+	}
+
+	return false;
+}
+
+/////////////////////////
+
+Sand::Sand(QCanvas *canvas)
+	: Ellipse(canvas)
+{
+	setSize(45, 40);
+
+	QBrush brush;
+	QPixmap pic;
+
+	if (!QPixmapCache::find("sand", pic))
+	{
+		pic.load(locate("appdata", "pics/sand.png"));
+		QPixmapCache::insert("sand", pic);
+	}
+
+	brush.setPixmap(pic);
+	setBrush(brush);
+
+	KPixmap pointPic(pic);
+	KPixmapEffect::intensity(pointPic, .45);
+	brush.setPixmap(pointPic);
+	point->setBrush(brush);
+
+	setZ(-26);
+}
+
+bool Sand::collision(Ball *ball, long int /*id*/)
+{
+	QCanvasRectangle i(QRect(ball->x(), ball->y(), 1, 1), canvas());
+	i.setVisible(true);
+
+	// is center of ball in?
+	if (i.collidesWith(this)/* && ball->curVector().magnitude() < 4*/)
+	{
+		if (ball->curVector().magnitude() > 0)
+			ball->setFrictionMultiplier(7);
+		else
+		{
+			ball->setVelocity(0, 0);
+			ball->setState(Stopped);
+		}
+	}
+
+	return true;
+}
+
+/////////////////////////
+
+Putter::Putter(QCanvas *canvas)
+	: QCanvasLine(canvas)
+{
+	m_showGuideLine = true;
+	oneDegree = M_PI / 180;
+	len = 9;
+	angle = 0;
+
+	guideLine = new QCanvasLine(canvas);
+	guideLine->setPen(QPen(white, 1, QPen::DotLine));
+	guideLine->setZ(998.8);
+
+	setPen(QPen(black, 4));
+	putterWidth = 11;
+	maxAngle = 2 * M_PI;
+
+	hideInfo();
+
+	// this also sets Z
+	resetAngles();
+}
+
+void Putter::showInfo()
+{
+	guideLine->setVisible(isVisible());
+}
+
+void Putter::hideInfo()
+{
+	guideLine->setVisible(m_showGuideLine? isVisible() : false);
+}
+
+void Putter::moveBy(double dx, double dy)
+{
+	QCanvasLine::moveBy(dx, dy);
+	guideLine->move(x(), y());
+}
+
+void Putter::setShowGuideLine(bool yes)
+{
+	m_showGuideLine = yes;
+	setVisible(isVisible());
+}
+
+void Putter::setVisible(bool yes)
+{
+	QCanvasLine::setVisible(yes);
+	guideLine->setVisible(m_showGuideLine? yes : false);
+}
+
+void Putter::setOrigin(int _x, int _y)
+{
+	setVisible(true);
+	move(_x, _y);
+	len = 9;
+	finishMe();
+}
+
+void Putter::setAngle(Ball *ball)
+{
+	angle = angleMap.contains(ball)? angleMap[ball] : 0;
+	finishMe();
+}
+
+void Putter::go(Direction d, Amount amount)
+{
+	double addition = (amount == Amount_More? 6 * oneDegree : amount == Amount_Less? .5 * oneDegree : 2 * oneDegree);
+
+	switch (d)
+	{
+		case Forwards:
+			len -= 1;
+			guideLine->setVisible(false);
+			break;
+		case Backwards:
+			len += 1;
+			guideLine->setVisible(false);
+			break;
+		case D_Left:
+			angle += addition;
+			if (angle > maxAngle)
+				angle -= maxAngle;
+			break;
+		case D_Right:
+			angle -= addition;
+			if (angle < 0)
+				angle = maxAngle - fabs(angle);
+			break;
+	}
+
+	finishMe();
+}
+
+void Putter::finishMe()
+{
+	midPoint.setX(cos(angle) * len);
+	midPoint.setY(-sin(angle) * len);
+
+	QPoint start;
+	QPoint end;
+
+	if (midPoint.y() || !midPoint.x())
+	{
+		start.setX(midPoint.x() - putterWidth * sin(angle));
+		start.setY(midPoint.y() - putterWidth * cos(angle));
+		end.setX(midPoint.x() + putterWidth * sin(angle));
+		end.setY(midPoint.y() + putterWidth * cos(angle));
+	}
+	else
+	{
+		start.setX(midPoint.x());
+		start.setY(midPoint.y() + putterWidth);
+		end.setY(midPoint.y() - putterWidth);
+		end.setX(midPoint.x());
+	}
+
+ 	guideLine->setPoints(midPoint.x(), midPoint.y(), -cos(angle) * len * 4, sin(angle) * len * 4);
+
+	setPoints(start.x(), start.y(), end.x(), end.y());
+}
+
+/////////////////////////
+
+Bumper::Bumper(QCanvas *canvas)
+	: QCanvasEllipse(20, 20, canvas)
+{
+	setZ(-25);
+
+	firstColor = QColor("#E74804");
+	secondColor = firstColor.light();
+
+	count = 0;
+	setBrush(firstColor);
+	setAnimated(false);
+
+	inside = new Inside(this, canvas);
+	inside->setBrush(firstColor.light(109));
+	inside->setSize(width() / 2.6, height() / 2.6);
+	inside->show();
+}
+
+void Bumper::aboutToDie()
+{
+	delete inside;
+}
+
+void Bumper::moveBy(double dx, double dy)
+{
+	QCanvasEllipse::moveBy(dx, dy);
+	//const double insideLen = (double)(width() - inside->width()) / 2.0;
+	inside->move(x(), y());
+}
+
+void Bumper::editModeChanged(bool changed)
+{
+	inside->setVisible(!changed);
+}
+
+void Bumper::advance(int phase)
+{
+	QCanvasEllipse::advance(phase);
+
+	if (phase == 1)
+	{
+		count++;
+		if (count > 2)
+		{
+			count = 0;
+			setBrush(firstColor);
+			update();
+			setAnimated(false);
+		}
+	}
+}
+
+bool Bumper::collision(Ball *ball, long int /*id*/)
+{
+	setBrush(secondColor);
+
+	double speed = 1.8 + ball->curVector().magnitude() * .9;
+	if (speed > 8)
+		speed = 8;
+
+	const QPoint start(x(), y());
+	const QPoint end(ball->x(), ball->y());
+
+	Vector betweenVector(start, end);
+	betweenVector.setMagnitude(speed);
+
+	// add some randomness so we don't go indefinetely
+	betweenVector.setDirection(betweenVector.direction() + deg2rad((kapp->random() % 3) - 1));
+
+	ball->setVector(betweenVector);
+	// for some reason, x is always switched...
+	ball->setXVelocity(-ball->xVelocity());
+	ball->setState(Rolling);
+
+	setAnimated(true);
+
+	return true;
+}
+
+/////////////////////////
+
+Hole::Hole(QColor color, QCanvas *canvas)
+	: QCanvasEllipse(15, 15, canvas)
+{
+	setZ(998.1);
+	setPen(black);
+	setBrush(color);
+}
+
+bool Hole::collision(Ball *ball, long int /*id*/)
+{
+	bool wasCenter = false;
+
+	switch (result(QPoint(ball->x(), ball->y()), ball->curVector().magnitude(), &wasCenter))
+	{
+		case Result_Holed:
+			place(ball, wasCenter);
+			return false;
+
+		default:
+		break;
+	}
+
+	return true;
+}
+
+HoleResult Hole::result(QPoint p, double s, bool * /*wasCenter*/)
+{
+	const double longestRadius = width() > height()? width() : height();
+	if (s > longestRadius / 5.0)
+		return Result_Miss;
+
+	QCanvasRectangle i(QRect(p, QSize(1, 1)), canvas());
+	i.setVisible(true);
+
+	// is center of ball in cup?
+	if (i.collidesWith(this))
+	{
+		return Result_Holed;
+	}
+	else
+		return Result_Miss;
+}
+
+/////////////////////////
+
+Cup::Cup(QCanvas *canvas)
+	: Hole(QColor("#808080"), canvas)
+{
+	if (!QPixmapCache::find("cup", pixmap))
+	{
+		pixmap.load(locate("appdata", "pics/cup.png"));
+		QPixmapCache::insert("cup", pixmap);
+	}
+}
+
+void Cup::draw(QPainter &p)
+{
+	p.drawPixmap(QPoint(x() - width() / 2, y() - height() / 2), pixmap);
+}
+
+bool Cup::place(Ball *ball, bool /*wasCenter*/)
+{
+	ball->setState(Holed);
+	playSound("holed");
+
+	// the picture's center is a little different
+	ball->move(x() - 1, y());
+	ball->setVelocity(0, 0);
+	if (game && game->curBall() == ball)
+		game->stoppedBall();
+	return true;
+}
+
+void Cup::save(KConfig *cfg)
+{
+	cfg->writeEntry("dummykey", true);
+}
+
+/////////////////////////
+
+BlackHole::BlackHole(QCanvas *canvas)
+	: Hole(black, canvas), exitDeg(0)
+{
+	infoLine = 0;
+	m_minSpeed = 3.0;
+	m_maxSpeed = 5.0;
+	runs = 0;
+
+	const QColor myColor((QRgb)(kapp->random() % 0x01000000));
+
+	outside = new QCanvasEllipse(canvas);
+	outside->setZ(z() - .001);
+
+	outside->setBrush(QBrush(myColor));
+	setBrush(black);
+
+	exitItem = new BlackHoleExit(this, canvas);
+	exitItem->setPen(QPen(myColor, 6));
+	exitItem->setX(300);
+	exitItem->setY(100);
+
+	setSize(width(), width() / .8);
+	const float factor = 1.3;
+	outside->setSize(width() * factor, height() * factor);
+	outside->setVisible(true);
+
+	moveBy(0, 0);
+
+	finishMe();
+}
+
+void BlackHole::showInfo()
+{
+	delete infoLine;
+	infoLine = new QCanvasLine(canvas());
+	infoLine->setVisible(true);
+	infoLine->setPen(QPen(exitItem->pen().color(), 2));
+	infoLine->setZ(10000);
+	infoLine->setPoints(x(), y(), exitItem->x(), exitItem->y());
+
+	exitItem->showInfo();
+}
+
+void BlackHole::hideInfo()
+{
+	delete infoLine;
+	infoLine = 0;
+
+	exitItem->hideInfo();
+}
+
+void BlackHole::aboutToDie()
+{
+	Hole::aboutToDie();
+	delete outside;
+	exitItem->aboutToDie();
+	delete exitItem;
+}
+
+void BlackHole::updateInfo()
+{
+	if (infoLine)
+	{
+		infoLine->setVisible(true);
+		infoLine->setPoints(x(), y(), exitItem->x(), exitItem->y());
+		exitItem->showInfo();
+	}
+}
+
+void BlackHole::moveBy(double dx, double dy)
+{
+	QCanvasEllipse::moveBy(dx, dy);
+	outside->move(x(), y());
+	updateInfo();
+}
+
+void BlackHole::setExitDeg(int newdeg)
+{
+	exitDeg = newdeg;
+	if (game && game->isEditing() && game->curSelectedItem() == exitItem)
+		game->updateHighlighter();
+
+	exitItem->updateArrowAngle();
+	finishMe();
+}
+
+QPtrList<QCanvasItem> BlackHole::moveableItems() const
+{
+	QPtrList<QCanvasItem> ret;
+	ret.append(exitItem);
+	return ret;
+}
+
+BlackHoleTimer::BlackHoleTimer(Ball *ball, double speed, int msec)
+	: m_speed(speed), m_ball(ball)
+{
+	QTimer::singleShot(msec, this, SLOT(mySlot()));
+	QTimer::singleShot(msec / 2, this, SLOT(myMidSlot()));
+}
+
+void BlackHoleTimer::mySlot()
+{
+	emit eject(m_ball, m_speed);
+	delete this;
+}
+
+void BlackHoleTimer::myMidSlot()
+{
+	emit halfway();
+}
+
+bool BlackHole::place(Ball *ball, bool /*wasCenter*/)
+{
+	// most number is 10
+	if (runs > 10 && game && game->isInPlay())
+		return false;
+
+	playSound("blackholeputin");
+
+	const double diff = (m_maxSpeed - m_minSpeed);
+	const double speed = m_minSpeed + ball->curVector().magnitude() * (diff / 3.75);
+
+	ball->setVelocity(0, 0);
+	ball->setState(Stopped);
+	ball->setVisible(false);
+	ball->setForceStillGoing(true);
+
+	double magnitude = Vector(QPoint(x(), y()), QPoint(exitItem->x(), exitItem->y())).magnitude();
+	BlackHoleTimer *timer = new BlackHoleTimer(ball, speed, magnitude * 2.5 - speed * 35 + 500);
+
+	connect(timer, SIGNAL(eject(Ball *, double)), this, SLOT(eject(Ball *, double)));
+	connect(timer, SIGNAL(halfway()), this, SLOT(halfway()));
+
+	playSound("blackhole");
+	return false;
+}
+
+void BlackHole::eject(Ball *ball, double speed)
+{
+	ball->move(exitItem->x(), exitItem->y());
+
+	Vector v;
+	v.setMagnitude(10);
+	v.setDirection(deg2rad(exitDeg));
+	ball->setVector(v);
+
+	// advance ball 10
+	ball->doAdvance();
+
+	v.setMagnitude(speed);
+	ball->setVector(v);
+
+	ball->setForceStillGoing(false);
+	ball->setVisible(true);
+	ball->setState(Rolling);
+
+	runs++;
+
+	playSound("blackholeeject");
+}
+
+void BlackHole::halfway()
+{
+	playSound("blackhole");
+}
+
+void BlackHole::load(KConfig *cfg)
+{
+	QPoint exit = cfg->readPointEntry("exit", &exit);
+	exitItem->setX(exit.x());
+	exitItem->setY(exit.y());
+	exitDeg = cfg->readNumEntry("exitDeg", exitDeg);
+	m_minSpeed = cfg->readDoubleNumEntry("minspeed", m_minSpeed);
+	m_maxSpeed = cfg->readDoubleNumEntry("maxspeed", m_maxSpeed);
+	exitItem->updateArrowAngle();
+	exitItem->updateArrowLength();
+
+	finishMe();
+}
+
+void BlackHole::finishMe()
+{
+	double radians = deg2rad(exitDeg);
+	QPoint midPoint(0, 0);
+	QPoint start;
+	QPoint end;
+	const int width = 15;
+
+	if (midPoint.y() || !midPoint.x())
+	{
+		start.setX(midPoint.x() - width*sin(radians));
+		start.setY(midPoint.y() - width*cos(radians));
+		end.setX(midPoint.x() + width*sin(radians));
+		end.setY(midPoint.y() + width*cos(radians));
+	}
+	else
+	{
+		start.setX(midPoint.x());
+		start.setY(midPoint.y() + width);
+		end.setY(midPoint.y() - width);
+		end.setX(midPoint.x());
+	}
+
+	exitItem->setPoints(start.x(), start.y(), end.x(), end.y());
+	exitItem->setVisible(true);
+}
+
+void BlackHole::save(KConfig *cfg)
+{
+	cfg->writeEntry("exit", QPoint(exitItem->x(), exitItem->y()));
+	cfg->writeEntry("exitDeg", exitDeg);
+	cfg->writeEntry("minspeed", m_minSpeed);
+	cfg->writeEntry("maxspeed", m_maxSpeed);
+}
+
+/////////////////////////
+
+BlackHoleExit::BlackHoleExit(BlackHole *blackHole, QCanvas *canvas)
+	: QCanvasLine(canvas)
+{
+	this->blackHole = blackHole;
+	arrow = new Arrow(canvas);
+	setZ(blackHole->z());
+	arrow->setZ(z() - .00001);
+	updateArrowLength();
+	arrow->setVisible(false);
+}
+
+void BlackHoleExit::aboutToDie()
+{
+	arrow->aboutToDie();
+	delete arrow;
+}
+
+void BlackHoleExit::moveBy(double dx, double dy)
+{
+	QCanvasLine::moveBy(dx, dy);
+	arrow->move(x(), y());
+	blackHole->updateInfo();
+}
+
+void BlackHoleExit::setPen(QPen p)
+{
+	QCanvasLine::setPen(p);
+	arrow->setPen(QPen(p.color(), 1));
+}
+
+void BlackHoleExit::updateArrowAngle()
+{
+	// arrows work in a different angle system
+	arrow->setAngle(-deg2rad(blackHole->curExitDeg()));
+	arrow->updateSelf();
+}
+
+void BlackHoleExit::updateArrowLength()
+{
+	arrow->setLength(10.0 + 5.0 * (double)(blackHole->minSpeed() + blackHole->maxSpeed()) / 2.0);
+	arrow->updateSelf();
+}
+
+void BlackHoleExit::editModeChanged(bool editing)
+{
+	if (editing)
+		showInfo();
+	else
+		hideInfo();
+}
+
+void BlackHoleExit::showInfo()
+{
+	arrow->setVisible(true);
+}
+
+void BlackHoleExit::hideInfo()
+{
+	arrow->setVisible(false);
+}
+
+Config *BlackHoleExit::config(QWidget *parent)
+{
+	return blackHole->config(parent);
+}
+
+/////////////////////////
+
+BlackHoleConfig::BlackHoleConfig(BlackHole *blackHole, QWidget *parent)
+	: Config(parent)
+{
+	this->blackHole = blackHole;
+	QVBoxLayout *layout = new QVBoxLayout(this, marginHint(), spacingHint());
+	layout->addWidget(new QLabel(i18n("Exiting ball angle:"), this));
+	QSpinBox *deg = new QSpinBox(0, 359, 10, this);
+	deg->setSuffix(QString(" ") + i18n("degrees"));
+	deg->setValue(blackHole->curExitDeg());
+	deg->setWrapping(true);
+	layout->addWidget(deg);
+	connect(deg, SIGNAL(valueChanged(int)), this, SLOT(degChanged(int)));
+
+	layout->addStretch();
+
+	QHBoxLayout *hlayout = new QHBoxLayout(layout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Minimum exit speed:"), this));
+	KDoubleNumInput *min = new KDoubleNumInput(this);
+	min->setRange(0, 8, 1, true);
+	hlayout->addWidget(min);
+	connect(min, SIGNAL(valueChanged(double)), this, SLOT(minChanged(double)));
+	min->setValue(blackHole->minSpeed());
+
+	hlayout = new QHBoxLayout(layout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Maximum:"), this));
+	KDoubleNumInput *max = new KDoubleNumInput(this);
+	max->setRange(1, 10, 1, true);
+	hlayout->addWidget(max);
+	connect(max, SIGNAL(valueChanged(double)), this, SLOT(maxChanged(double)));
+	max->setValue(blackHole->maxSpeed());
+}
+
+void BlackHoleConfig::degChanged(int newdeg)
+{
+	blackHole->setExitDeg(newdeg);
+	changed();
+}
+
+void BlackHoleConfig::minChanged(double news)
+{
+	blackHole->setMinSpeed(news);
+	changed();
+}
+
+void BlackHoleConfig::maxChanged(double news)
+{
+	blackHole->setMaxSpeed(news);
+	changed();
+}
+
+/////////////////////////
+
+WallPoint::WallPoint(bool start, Wall *wall, QCanvas *canvas)
+	: QCanvasEllipse(canvas)
+{
+	this->wall = wall;
+	this->start = start;
+	alwaysShow = false;
+	editing = false;
+	visible = true;
+	lastId = INT_MAX - 10;
+	dontmove = false;
+
+	move(0, 0);
+	QPoint p;
+	if (start)
+		p = wall->startPoint();
+	else
+		p = wall->endPoint();
+	setX(p.x());
+	setY(p.y());
+}
+
+void WallPoint::clean()
+{
+	int oldWidth = width();
+	setSize(7, 7);
+	update();
+
+	QCanvasItem *onPoint = 0;
+	QCanvasItemList l = collisions(true);
+	for (QCanvasItemList::Iterator it = l.begin(); it != l.end(); ++it)
+		if ((*it)->rtti() == rtti())
+			onPoint = (*it);
+
+	if (onPoint)
+		move(onPoint->x(), onPoint->y());
+
+	setSize(oldWidth, oldWidth);
+}
+
+void WallPoint::moveBy(double dx, double dy)
+{
+	QCanvasEllipse::moveBy(dx, dy);
+	if (!editing)
+		updateVisible();
+
+	if (dontmove)
+	{
+		dontmove = false;
+		return;
+	}
+
+	if (!wall)
+		return;
+
+	if (start)
+	{
+		wall->setPoints(x(), y(), wall->endPoint().x() + wall->x(), wall->endPoint().y() + wall->y());
+	}
+	else
+	{
+		wall->setPoints(wall->startPoint().x() + wall->x(), wall->startPoint().y() + wall->y(), x(), y());
+	}
+	wall->move(0, 0);
+}
+
+void WallPoint::updateVisible()
+{
+	if (!wall->isVisible())
+	{
+		visible = false;
+		return;
+	}
+
+	if (alwaysShow)
+		visible = true;
+	else
+	{
+		visible = true;
+		QCanvasItemList l = collisions(true);
+		for (QCanvasItemList::Iterator it = l.begin(); it != l.end(); ++it)
+			if ((*it)->rtti() == rtti())
+				visible = false;
+	}
+}
+
+void WallPoint::editModeChanged(bool changed)
+{
+	editing = changed;
+	setVisible(true);
+	if (!editing)
+		updateVisible();
+}
+
+bool WallPoint::collision(Ball *ball, long int id)
+{
+	if (ball->curVector().magnitude() <= 0)
+		return false;
+
+	long int tempLastId = lastId;
+	lastId = id;
+	QCanvasItemList l = collisions(true);
+	for (QCanvasItemList::Iterator it = l.begin(); it != l.end(); ++it)
+	{
+		if ((*it)->rtti() == rtti())
+		{
+			WallPoint *point = (WallPoint *)(*it);
+			point->lastId = id;
+		}
+	}
+
+	//kdDebug(12007) << "WallPoint::collision id: " << id << ", tempLastId: " << tempLastId << endl;
+	Vector ballVector(ball->curVector());
+
+	//kdDebug(12007) << "Wall::collision ball speed: " << ball->curVector().magnitude() << endl;
+	int allowableDifference = 1;
+	if (ballVector.magnitude() < .30)
+		allowableDifference = 8;
+	else if (ballVector.magnitude() < .50)
+		allowableDifference = 6;
+	else if (ballVector.magnitude() < .65)
+		allowableDifference = 4;
+	else if (ballVector.magnitude() < .95)
+		allowableDifference = 2;
+
+	if (abs(id - tempLastId) <= allowableDifference)
+	{
+		//kdDebug(12007) << "WallPoint::collision - SKIP\n";
+	}
+	else
+	{
+	bool weirdBounce = visible;
+
+	QPoint relStart(start? wall->startPoint() : wall->endPoint());
+	QPoint relEnd(start? wall->endPoint() : wall->startPoint());
+	Vector wallVector(relStart, relEnd);
+	wallVector.setDirection(-wallVector.direction());
+
+	// find the angle between vectors, between 0 and PI
+	{
+		double difference = fabs(wallVector.direction() - ballVector.direction());
+		while (difference > 2 * M_PI)
+			difference -= 2 * M_PI;
+
+		if (difference < M_PI / 2 || difference > 3 * M_PI / 2)
+			weirdBounce = false;
+	}
+
+	playSound("wall", ball->curVector().magnitude() / 10.0);
+
+	ballVector /= wall->dampening;
+	const double ballAngle = ballVector.direction();
+
+	double wallAngle = wallVector.direction();
+
+	// opposite bounce, because we're the endpoint
+	if (weirdBounce)
+		wallAngle += M_PI / 2;
+
+	const double collisionAngle = ballAngle - wallAngle;
+	const double leavingAngle = wallAngle - collisionAngle;
+
+	ballVector.setDirection(leavingAngle);
+	ball->setVector(ballVector);
+	wall->lastId = id;
+
+	//kdDebug(12007) << "WallPoint::collision - NOT skip, weirdBounce is " << weirdBounce << endl;
+	} // end if that skips
+
+	wall->lastId = id;
+	return false;
+}
+
+/////////////////////////
+
+Wall::Wall(QCanvas *canvas)
+	: QCanvasLine(canvas)
+{
+	editing = false;
+	lastId = INT_MAX - 10;
+
+	dampening = 1.2;
+
+	startItem = 0;
+	endItem = 0;
+
+	moveBy(0, 0);
+	setZ(50);
+
+	startItem = new WallPoint(true, this, canvas);
+	endItem = new WallPoint(false, this, canvas);
+	startItem->setVisible(true);
+	endItem->setVisible(true);
+	setPen(QPen(darkRed, 3));
+
+	setPoints(-15, 10, 15, -5);
+
+	moveBy(0, 0);
+
+	editModeChanged(false);
+}
+
+void Wall::selectedItem(QCanvasItem *item)
+{
+	if (item->rtti() == Rtti_WallPoint)
+	{
+		WallPoint *wallPoint = dynamic_cast<WallPoint *>(item);
+		if (wallPoint) {
+			setPoints(startPoint().x(), startPoint().y(), wallPoint->x() - x(), wallPoint->y() - y());
+		}
+	}
+}
+
+void Wall::clean()
+{
+	startItem->clean();
+	endItem->clean();
+}
+
+void Wall::setAlwaysShow(bool yes)
+{
+	startItem->setAlwaysShow(yes);
+	endItem->setAlwaysShow(yes);
+}
+
+void Wall::setVisible(bool yes)
+{
+	QCanvasLine::setVisible(yes);
+
+	startItem->setVisible(yes);
+	endItem->setVisible(yes);
+	startItem->updateVisible();
+	endItem->updateVisible();
+}
+
+void Wall::setZ(double newz)
+{
+	QCanvasLine::setZ(newz);
+	if (startItem)
+		startItem->setZ(newz + .002);
+	if (endItem)
+		endItem->setZ(newz + .001);
+}
+
+void Wall::setPen(QPen p)
+{
+	QCanvasLine::setPen(p);
+
+	if (startItem)
+		startItem->setBrush(QBrush(p.color()));
+	if (endItem)
+		endItem->setBrush(QBrush(p.color()));
+}
+
+void Wall::aboutToDie()
+{
+	delete startItem;
+	delete endItem;
+}
+
+void Wall::setGame(KolfGame *game)
+{
+	CanvasItem::setGame(game);
+	startItem->setGame(game);
+	endItem->setGame(game);
+}
+
+QPtrList<QCanvasItem> Wall::moveableItems() const
+{
+	QPtrList<QCanvasItem> ret;
+	ret.append(startItem);
+	ret.append(endItem);
+	return ret;
+}
+
+void Wall::moveBy(double dx, double dy)
+{
+	QCanvasLine::moveBy(dx, dy);
+
+	if (!startItem || !endItem)
+		return;
+
+	startItem->dontMove();
+	endItem->dontMove();
+	startItem->move(startPoint().x() + x(), startPoint().y() + y());
+	endItem->move(endPoint().x() + x(), endPoint().y() + y());
+}
+
+void Wall::setVelocity(double vx, double vy)
+{
+	QCanvasLine::setVelocity(vx, vy);
+	/*
+	startItem->setVelocity(vx, vy);
+	endItem->setVelocity(vx, vy);
+	*/
+}
+
+QPointArray Wall::areaPoints() const
+{
+	// editing we want full width for easy moving
+	if (editing)
+		return QCanvasLine::areaPoints();
+
+	// lessen width, for QCanvasLine::areaPoints() likes
+	// to make lines _very_ fat :(
+	// from qcanvas.cpp, only the stuff for a line width of 1 taken
+
+	// it's all squished because I don't want my
+	// line counts to count code I didn't write!
+	QPointArray p(4); const int xi = int(x()); const int yi = int(y()); const QPoint start = startPoint(); const QPoint end = endPoint(); const int x1 = start.x(); const int x2 = end.x(); const int y1 = start.y(); const int y2 = end.y(); const int dx = QABS(x1-x2); const int dy = QABS(y1-y2); if ( dx > dy ) { p[0] = QPoint(x1+xi,y1+yi-1); p[1] = QPoint(x2+xi,y2+yi-1); p[2] = QPoint(x2+xi,y2+yi+1); p[3] = QPoint(x1+xi,y1+yi+1); } else { p[0] = QPoint(x1+xi-1,y1+yi); p[1] = QPoint(x2+xi-1,y2+yi); p[2] = QPoint(x2+xi+1,y2+yi); p[3] = QPoint(x1+xi+1,y1+yi); } return p;
+}
+
+void Wall::editModeChanged(bool changed)
+{
+	// make big for debugging?
+	const bool debugPoints = false;
+
+	editing = changed;
+
+	startItem->setZ(z() + .002);
+	endItem->setZ(z() + .001);
+	startItem->editModeChanged(editing);
+	endItem->editModeChanged(editing);
+
+	int neww = 0;
+	if (changed || debugPoints)
+		neww = 10;
+	else
+		neww = pen().width();
+
+	startItem->setSize(neww, neww);
+	endItem->setSize(neww, neww);
+
+	moveBy(0, 0);
+}
+
+bool Wall::collision(Ball *ball, long int id)
+{
+	if (ball->curVector().magnitude() <= 0)
+		return false;
+
+	long int tempLastId = lastId;
+	lastId = id;
+	startItem->lastId = id;
+	endItem->lastId = id;
+
+	//kdDebug(12007) << "Wall::collision id: " << id << ", tempLastId: " << tempLastId << endl;
+	Vector ballVector(ball->curVector());
+
+	//kdDebug(12007) << "Wall::collision ball speed: " << ball->curVector().magnitude() << endl;
+	int allowableDifference = 1;
+	if (ballVector.magnitude() < .30)
+		allowableDifference = 8;
+	else if (ballVector.magnitude() < .50)
+		allowableDifference = 6;
+	else if (ballVector.magnitude() < .75)
+		allowableDifference = 4;
+	else if (ballVector.magnitude() < .95)
+		allowableDifference = 2;
+	//kdDebug(12007) << "Wall::collision allowableDifference is " << allowableDifference << endl;
+	if (abs(id - tempLastId) <= allowableDifference)
+	{
+		//kdDebug(12007) << "Wall::collision - SKIP\n";
+		return false;
+	}
+
+	playSound("wall", ball->curVector().magnitude() / 10.0);
+
+	ballVector /= dampening;
+	const double ballAngle = ballVector.direction();
+
+	const double wallAngle = -Vector(startPoint(), endPoint()).direction();
+	const double collisionAngle = ballAngle - wallAngle;
+	const double leavingAngle = wallAngle - collisionAngle;
+
+	ballVector.setDirection(leavingAngle);
+	ball->setVector(ballVector);
+
+	//kdDebug(12007) << "Wall::collision - NOT skip\n";
+	return false;
+}
+
+void Wall::load(KConfig *cfg)
+{
+	QPoint start(startPoint());
+	start = cfg->readPointEntry("startPoint", &start);
+	QPoint end(endPoint());
+	end = cfg->readPointEntry("endPoint", &end);
+
+	setPoints(start.x(), start.y(), end.x(), end.y());
+
+	moveBy(0, 0);
+	startItem->move(start.x(), start.y());
+	endItem->move(end.x(), end.y());
+}
+
+void Wall::save(KConfig *cfg)
+{
+	cfg->writeEntry("startPoint", QPoint(startItem->x(), startItem->y()));
+	cfg->writeEntry("endPoint", QPoint(endItem->x(), endItem->y()));
+}
+
+/////////////////////////
+
+HoleConfig::HoleConfig(HoleInfo *holeInfo, QWidget *parent)
+	: Config(parent)
+{
+	this->holeInfo = holeInfo;
+
+	QVBoxLayout *layout = new QVBoxLayout(this, marginHint(), spacingHint());
+
+	QHBoxLayout *hlayout = new QHBoxLayout(layout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Course name: "), this));
+	KLineEdit *nameEdit = new KLineEdit(holeInfo->untranslatedName(), this);
+	hlayout->addWidget(nameEdit);
+	connect(nameEdit, SIGNAL(textChanged(const QString &)), this, SLOT(nameChanged(const QString &)));
+
+	hlayout = new QHBoxLayout(layout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Course author: "), this));
+	KLineEdit *authorEdit = new KLineEdit(holeInfo->author(), this);
+	hlayout->addWidget(authorEdit);
+	connect(authorEdit, SIGNAL(textChanged(const QString &)), this, SLOT(authorChanged(const QString &)));
+
+	layout->addStretch();
+
+	hlayout = new QHBoxLayout(layout, spacingHint());
+	hlayout->addWidget(new QLabel(i18n("Par:"), this));
+	QSpinBox *par = new QSpinBox(1, 15, 1, this);
+	par->setValue(holeInfo->par());
+	hlayout->addWidget(par);
+	connect(par, SIGNAL(valueChanged(int)), this, SLOT(parChanged(int)));
+	hlayout->addStretch();
+
+	hlayout->addWidget(new QLabel(i18n("Maximum:"), this));
+	QSpinBox *maxstrokes = new QSpinBox(holeInfo->lowestMaxStrokes(), 30, 1, this);
+	QWhatsThis::add(maxstrokes, i18n("Maximum number of strokes player can take on this hole."));
+	QToolTip::add(maxstrokes, i18n("Maximum number of strokes"));
+	maxstrokes->setSpecialValueText(i18n("Unlimited"));
+	maxstrokes->setValue(holeInfo->maxStrokes());
+	hlayout->addWidget(maxstrokes);
+	connect(maxstrokes, SIGNAL(valueChanged(int)), this, SLOT(maxStrokesChanged(int)));
+
+	QCheckBox *check = new QCheckBox(i18n("Show border walls"), this);
+	check->setChecked(holeInfo->borderWalls());
+	layout->addWidget(check);
+	connect(check, SIGNAL(toggled(bool)), this, SLOT(borderWallsChanged(bool)));
+}
+
+void HoleConfig::authorChanged(const QString &newauthor)
+{
+	holeInfo->setAuthor(newauthor);
+	changed();
+}
+
+void HoleConfig::nameChanged(const QString &newname)
+{
+	holeInfo->setName(newname);
+	holeInfo->setUntranslatedName(newname);
+	changed();
+}
+
+void HoleConfig::parChanged(int newpar)
+{
+	holeInfo->setPar(newpar);
+	changed();
+}
+
+void HoleConfig::maxStrokesChanged(int newms)
+{
+	holeInfo->setMaxStrokes(newms);
+	changed();
+}
+
+void HoleConfig::borderWallsChanged(bool yes)
+{
+	holeInfo->borderWallsChanged(yes);
+	changed();
+}
+
+/////////////////////////
+
+StrokeCircle::StrokeCircle(QCanvas *canvas)
+	: QCanvasItem(canvas)
+{
+	dvalue = 0;
+	dmax = 360;
+	iwidth = 100;
+	iheight = 100;
+	ithickness = 8;
+	setZ(10000);
+}
+
+void StrokeCircle::setValue(double v)
+{
+	dvalue = v;
+	if (dvalue > dmax)
+		dvalue = dmax;
+
+	update();
+}
+
+double StrokeCircle::value()
+{
+	return dvalue;
+}
+
+bool StrokeCircle::collidesWith(const QCanvasItem*) const { return false; }
+
+bool StrokeCircle::collidesWith(const QCanvasSprite*, const QCanvasPolygonalItem*, const QCanvasRectangle*, const QCanvasEllipse*, const QCanvasText*) const { return false; }
+
+QRect StrokeCircle::boundingRect() const { return QRect(x(), y(), iwidth, iheight); }
+
+void StrokeCircle::setMaxValue(double m)
+{
+	dmax = m;
+	if (dvalue > dmax)
+		dvalue = dmax;
+
+	update();
+}
+void StrokeCircle::setSize(int w, int h)
+{
+	if (w > 0)
+		iwidth = w;
+	if (h > 0)
+		iheight = h;
+
+	update();
+}
+void StrokeCircle::setThickness(int t)
+{
+	if (t > 0)
+		ithickness = t;
+
+	update();
+}
+
+int StrokeCircle::thickness() const
+{
+	return ithickness;
+}
+
+int StrokeCircle::width() const
+{
+	return iwidth;
+}
+
+int StrokeCircle::height() const
+{
+	return iheight;
+}
+
+void StrokeCircle::draw(QPainter &p)
+{
+	int al = (int)((dvalue * 360 * 16) / dmax);
+	int length, deg;
+	if (al < 0)
+	{
+		deg = 270 * 16;
+		length = -al;
+	}
+	else if (al <= (270 * 16))
+	{
+		deg = 270 * 16 - al;
+		length = al;
+	}
+	else
+	{
+		deg = (360 * 16) - (al - (270 * 16));
+		length = al;
+	}
+
+	p.setBrush(QBrush(black, Qt::NoBrush));
+	p.setPen(QPen(white, ithickness / 2));
+	p.drawEllipse(x() + ithickness / 2, y() + ithickness / 2, iwidth - ithickness, iheight - ithickness);
+	p.setPen(QPen(QColor((int)(0xff * dvalue) / dmax, 0, 0xff - (int)(0xff * dvalue) / dmax), ithickness));
+	p.drawArc(x() + ithickness / 2, y() + ithickness / 2, iwidth - ithickness, iheight - ithickness, deg, length);
+
+	p.setPen(QPen(white, 1));
+	p.drawEllipse(x(), y(), iwidth, iheight);
+	p.drawEllipse(x() + ithickness, y() + ithickness, iwidth - ithickness * 2, iheight - ithickness * 2);
+	p.setPen(QPen(white, 3));
+	p.drawLine(x() + iwidth / 2, y() + iheight - ithickness * 1.5, x() + iwidth / 2, y() + iheight);
+	p.drawLine(x() + iwidth / 4 - iwidth / 20, y() + iheight - iheight / 4 + iheight / 20, x() + iwidth / 4 + iwidth / 20, y() + iheight - iheight / 4 - iheight / 20);
+	p.drawLine(x() + iwidth - iwidth / 4 + iwidth / 20, y() + iheight - iheight / 4 + iheight / 20, x() + iwidth - iwidth / 4 - iwidth / 20, y() + iheight - iheight / 4 - iheight / 20);
+}
+
+/////////////////////////////////////////
+
+KolfGame::KolfGame(ObjectList *obj, PlayerList *players, QString filename, QWidget *parent, const char *name )
+	: QCanvasView(parent, name)
+{
+	// for mouse control
+	setMouseTracking(true);
+	viewport()->setMouseTracking(true);
+	setFrameShape(NoFrame);
+
+	regAdv = false;
+	curHole = 0; // will get ++'d
+	cfg = 0;
+	setFilename(filename);
+	this->players = players;
+	this->obj = obj;
+	curPlayer = players->end();
+	curPlayer--; // will get ++'d to end and sent back
+	             // to beginning
+	paused = false;
+	modified = false;
+	inPlay = false;
+	putting = false;
+	stroking = false;
+	editing = false;
+	strict = false;
+	lastDelId = -1;
+	m_showInfo = false;
+	ballStateList.canUndo = false;
+	fastAdvancedExist = false;
+	soundDir = locate("appdata", "sounds/");
+	dontAddStroke = false;
+	addingNewHole = false;
+	scoreboardHoles = 0;
+	infoShown = false;
+	m_useMouse = true;
+	m_useAdvancedPutting = false;
+	m_useAdvancedPutting = true;
+	m_sound = true;
+	m_ignoreEvents = false;
+	soundedOnce = false;
+	oldPlayObjects.setAutoDelete(true);
+	highestHole = 0;
+	recalcHighestHole = false;
+
+	holeInfo.setGame(this);
+	holeInfo.setAuthor(i18n("Course Author"));
+	holeInfo.setName(i18n("Course Name"));
+	holeInfo.setUntranslatedName(i18n("Course Name"));
+	holeInfo.setMaxStrokes(10);
+	holeInfo.borderWallsChanged(true);
+
+	// width and height are the width and height of the canvas
+	// in easy storage
+	width = 400;
+	height = 400;
+	grass = QColor("#35760D");
+
+	margin = 10;
+
+	setFocusPolicy(QWidget::StrongFocus);
+	setFixedSize(width + 2 * margin, height + 2 * margin);
+
+	setMargins(margin, margin, margin, margin);
+
+	course = new QCanvas(this);
+	course->setBackgroundColor(white);
+	course->resize(width, height);
+
+	QPixmap pic;
+	if (!QPixmapCache::find("grass", pic))
+	{
+		pic.load(locate("appdata", "pics/grass.png"));
+		QPixmapCache::insert("grass", pic);
+	}
+	course->setBackgroundPixmap(pic);
+
+	setCanvas(course);
+	move(0, 0);
+	adjustSize();
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		(*it).ball()->setCanvas(course);
+
+	// highlighter shows current item
+	highlighter = new QCanvasRectangle(course);
+	highlighter->setPen(QPen(yellow, 1));
+	highlighter->setBrush(QBrush(NoBrush));
+	highlighter->setVisible(false);
+	highlighter->setZ(10000);
+
+	// shows some info about hole
+	infoText = new QCanvasText(course);
+	infoText->setText("");
+	infoText->setColor(white);
+	QFont font = kapp->font();
+	font.setPixelSize(12);
+	infoText->move(15, width/2);
+	infoText->setZ(10001);
+	infoText->setFont(font);
+	infoText->setVisible(false);
+
+	// create the advanced putting indicator
+	strokeCircle = new StrokeCircle(course);
+	strokeCircle->move(width - 90, height - 90);
+	strokeCircle->setSize(80, 80);
+	strokeCircle->setThickness(8);
+	strokeCircle->setVisible(false);
+	strokeCircle->setValue(0);
+	strokeCircle->setMaxValue(360);
+
+	// whiteBall marks the spot of the whole whilst editing
+	whiteBall = new Ball(course);
+	whiteBall->setGame(this);
+	whiteBall->setColor(white);
+	whiteBall->setVisible(false);
+	whiteBall->setDoDetect(false);
+
+	int highestLog = 0;
+
+	// if players have scores from loaded game, move to last hole
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		if ((int)(*it).scores().count() > highestLog)
+			highestLog = (*it).scores().count();
+
+		(*it).ball()->setGame(this);
+		(*it).ball()->setAnimated(true);
+	}
+
+	// here only for saved games
+	if (highestLog)
+		curHole = highestLog;
+
+	putter = new Putter(course);
+
+	// border walls:
+
+	// horiz
+	addBorderWall(QPoint(margin, margin), QPoint(width - margin, margin));
+	addBorderWall(QPoint(margin, height - margin - 1), QPoint(width - margin, height - margin - 1));
+
+	// vert
+	addBorderWall(QPoint(margin, margin), QPoint(margin, height - margin));
+	addBorderWall(QPoint(width - margin - 1, margin), QPoint(width - margin - 1, height - margin));
+
+	timer = new QTimer(this);
+	connect(timer, SIGNAL(timeout()), this, SLOT(timeout()));
+	timerMsec = 300;
+
+	fastTimer = new QTimer(this);
+	connect(fastTimer, SIGNAL(timeout()), this, SLOT(fastTimeout()));
+	fastTimerMsec = 11;
+
+	autoSaveTimer = new QTimer(this);
+	connect(autoSaveTimer, SIGNAL(timeout()), this, SLOT(autoSaveTimeout()));
+	autoSaveMsec = 5 * 1000 * 60; // 5 min autosave
+
+	// setUseAdvancedPutting() sets maxStrength!
+	setUseAdvancedPutting(false);
+
+	putting = false;
+	putterTimer = new QTimer(this);
+	connect(putterTimer, SIGNAL(timeout()), this, SLOT(putterTimeout()));
+	putterTimerMsec = 20;
+}
+
+void KolfGame::startFirstHole(int hole)
+{
+	if (curHole > 0) // if there was saved game, sync scoreboard
+	                 // with number of holes
+	{
+		for (; scoreboardHoles < curHole; ++scoreboardHoles)
+		{
+			cfg->setGroup(QString("%1-hole@-50,-50|0").arg(scoreboardHoles + 1));
+			emit newHole(cfg->readNumEntry("par", 3));
+		}
+
+		// lets load all of the scores from saved game if there are any
+		for (int hole = 1; hole <= curHole; ++hole)
+			for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+				emit scoreChanged((*it).id(), hole, (*it).score(hole));
+	}
+
+	curHole = hole - 1;
+
+	// this increments curHole, etc
+	recalcHighestHole = true;
+	startNextHole();
+	paused = true;
+	unPause();
+}
+
+void KolfGame::setFilename(const QString &filename)
+{
+	this->filename = filename;
+	delete cfg;
+	cfg = new KConfig(filename, false, false);
+}
+
+KolfGame::~KolfGame()
+{
+	oldPlayObjects.clear();
+	delete cfg;
+}
+
+void KolfGame::setModified(bool mod)
+{
+	modified = mod;
+	emit modifiedChanged(mod);
+}
+
+void KolfGame::pause()
+{
+	if (paused)
+	{
+		// play along with people who call pause() again, instead of unPause()
+		unPause();
+		return;
+	}
+
+	paused = true;
+	timer->stop();
+	fastTimer->stop();
+	putterTimer->stop();
+}
+
+void KolfGame::unPause()
+{
+	if (!paused)
+		return;
+
+	paused = false;
+
+	timer->start(timerMsec);
+	fastTimer->start(fastTimerMsec);
+
+	if (putting || stroking)
+		putterTimer->start(putterTimerMsec);
+}
+
+void KolfGame::addBorderWall(QPoint start, QPoint end)
+{
+	Wall *wall = new Wall(course);
+	wall->setPoints(start.x(), start.y(), end.x(), end.y());
+	wall->setVisible(true);
+	wall->setGame(this);
+	wall->setZ(998.7);
+	borderWalls.append(wall);
+}
+
+void KolfGame::updateHighlighter()
+{
+	if (!selectedItem)
+		return;
+	QRect rect = selectedItem->boundingRect();
+	highlighter->move(rect.x() + 1, rect.y() + 1);
+	highlighter->setSize(rect.width(), rect.height());
+}
+
+void KolfGame::handleMouseDoubleClickEvent(QMouseEvent *e)
+{
+	// allow two fast single clicks
+	handleMousePressEvent(e);
+}
+
+void KolfGame::handleMousePressEvent(QMouseEvent *e)
+{
+	if (m_ignoreEvents)
+		return;
+
+	if (editing)
+	{
+		if (inPlay)
+			return;
+
+		storedMousePos = e->pos();
+
+		QCanvasItemList list = course->collisions(e->pos());
+		if (list.first() == highlighter)
+			list.pop_front();
+
+		moving = false;
+		highlighter->setVisible(false);
+		selectedItem = 0;
+		movingItem = 0;
+
+		if (list.count() < 1)
+		{
+			emit newSelectedItem(&holeInfo);
+			return;
+		}
+		// only items we keep track of
+		if ((!(items.containsRef(list.first()) || list.first() == whiteBall || extraMoveable.containsRef(list.first()))))
+		{
+			emit newSelectedItem(&holeInfo);
+			return;
+		}
+
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(list.first());
+		if (!citem || !citem->moveable())
+		{
+			emit newSelectedItem(&holeInfo);
+			return;
+		}
+
+		switch (e->button())
+		{
+			// select AND move now :)
+			case LeftButton:
+			{
+				selectedItem = list.first();
+				movingItem = selectedItem;
+				moving = true;
+
+				if (citem->cornerResize())
+					setCursor(KCursor::sizeFDiagCursor());
+				else
+					setCursor(KCursor::sizeAllCursor());
+
+				emit newSelectedItem(citem);
+				highlighter->setVisible(true);
+				QRect rect = selectedItem->boundingRect();
+				highlighter->move(rect.x() + 1, rect.y() + 1);
+				highlighter->setSize(rect.width(), rect.height());
+			}
+			break;
+
+			default:
+			break;
+		}
+	}
+	else
+	{
+		if (m_useMouse)
+		{
+			if (!inPlay && e->button() == LeftButton)
+				puttPress();
+			else if (e->button() == RightButton)
+				toggleShowInfo();
+		}
+	}
+
+	setFocus();
+}
+
+QPoint KolfGame::viewportToViewport(const QPoint &p)
+{
+	// for some reason viewportToContents doesn't work right
+	return p - QPoint(margin, margin);
+}
+
+// the following four functions are needed to handle both
+// border presses and regular in-course presses
+
+void KolfGame::mouseReleaseEvent(QMouseEvent * e)
+{
+	QMouseEvent fixedEvent (QEvent::MouseButtonRelease, viewportToViewport(viewportToContents(e->pos())), e->button(), e->state());
+	handleMouseReleaseEvent(&fixedEvent);
+}
+
+void KolfGame::mousePressEvent(QMouseEvent * e)
+{
+	QMouseEvent fixedEvent (QEvent::MouseButtonPress, viewportToViewport(viewportToContents(e->pos())), e->button(), e->state());
+	handleMousePressEvent(&fixedEvent);
+}
+
+void KolfGame::mouseDoubleClickEvent(QMouseEvent * e)
+{
+	QMouseEvent fixedEvent (QEvent::MouseButtonDblClick, viewportToViewport(viewportToContents(e->pos())), e->button(), e->state());
+	handleMouseDoubleClickEvent(&fixedEvent);
+}
+
+void KolfGame::mouseMoveEvent(QMouseEvent * e)
+{
+	QMouseEvent fixedEvent (QEvent::MouseMove, viewportToViewport(viewportToContents(e->pos())), e->button(), e->state());
+	handleMouseMoveEvent(&fixedEvent);
+}
+
+void KolfGame::handleMouseMoveEvent(QMouseEvent *e)
+{
+	if (inPlay || !putter || m_ignoreEvents)
+		return;
+
+	QPoint mouse = e->pos();
+
+	// mouse moving of putter
+	if (!editing)
+	{
+		updateMouse();
+		return;
+	}
+
+	if (!moving)
+	{
+		// lets change the cursor to a hand
+		// if we're hovering over something
+
+		QCanvasItemList list = course->collisions(e->pos());
+		if (list.count() > 0)
+			setCursor(KCursor::handCursor());
+		else
+			setCursor(KCursor::arrowCursor());
+		return;
+	}
+
+	int moveX = storedMousePos.x() - mouse.x();
+	int moveY = storedMousePos.y() - mouse.y();
+
+	// moving counts as modifying
+	if (moveX || moveY)
+		setModified(true);
+
+	highlighter->moveBy(-(double)moveX, -(double)moveY);
+	movingItem->moveBy(-(double)moveX, -(double)moveY);
+	QRect brect = movingItem->boundingRect();
+	emit newStatusText(QString("%1x%2").arg(brect.x()).arg(brect.y()));
+	storedMousePos = mouse;
+}
+
+void KolfGame::updateMouse()
+{
+	// don't move putter if in advanced putting sequence
+	if (!m_useMouse || ((stroking || putting) && m_useAdvancedPutting))
+		return;
+
+	const QPoint cursor = viewportToViewport(viewportToContents(mapFromGlobal(QCursor::pos())));
+	const QPoint ball((*curPlayer).ball()->x(), (*curPlayer).ball()->y());
+	putter->setAngle(-Vector(cursor, ball).direction());
+}
+
+void KolfGame::handleMouseReleaseEvent(QMouseEvent *e)
+{
+	setCursor(KCursor::arrowCursor());
+
+	if (editing)
+	{
+		emit newStatusText(QString::null);
+		moving = false;
+	}
+
+	if (m_ignoreEvents)
+		return;
+
+	if (!editing && m_useMouse)
+	{
+		if (!inPlay && e->button() == LeftButton)
+			puttRelease();
+		else if (e->button() == RightButton)
+			toggleShowInfo();
+	}
+
+	setFocus();
+}
+
+void KolfGame::keyPressEvent(QKeyEvent *e)
+{
+	if (inPlay || editing || m_ignoreEvents)
+		return;
+
+	switch (e->key())
+	{
+		case Key_Up:
+			if (!e->isAutoRepeat())
+				toggleShowInfo();
+		break;
+
+		case Key_Escape:
+			putting = false;
+			stroking = false;
+			finishStroking = false;
+			strokeCircle->setVisible(false);
+			putterTimer->stop();
+			putter->setOrigin((*curPlayer).ball()->x(), (*curPlayer).ball()->y());
+		break;
+
+		case Key_Left:
+		case Key_Right:
+			// don't move putter if in advanced putting sequence
+			if ((!stroking && !putting) || !m_useAdvancedPutting)
+				putter->go(e->key() == Key_Left? D_Left : D_Right, e->state() & ShiftButton? Amount_More : e->state() & ControlButton? Amount_Less : Amount_Normal);
+		break;
+
+		case Key_Space: case Key_Down:
+			puttPress();
+		break;
+
+		default:
+		break;
+	}
+}
+
+void KolfGame::toggleShowInfo()
+{
+	setShowInfo(!m_showInfo);
+}
+
+void KolfGame::updateShowInfo()
+{
+	setShowInfo(m_showInfo);
+}
+
+void KolfGame::setShowInfo(bool yes)
+{
+	m_showInfo = yes;
+
+	if (m_showInfo)
+	{
+		QCanvasItem *item = 0;
+		for (item = items.first(); item; item = items.next())
+		{
+			CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+			if (citem)
+				citem->showInfo();
+		}
+
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->showInfo();
+
+		showInfo();
+	}
+	else
+	{
+		QCanvasItem *item = 0;
+		for (item = items.first(); item; item = items.next())
+		{
+			CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+			if (citem)
+				citem->hideInfo();
+		}
+
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->hideInfo();
+
+		hideInfo();
+	}
+}
+
+void KolfGame::puttPress()
+{
+	// Advanced putting: 1st click start putting sequence, 2nd determine strength, 3rd determine precision
+
+	if (!putting && !stroking && !inPlay)
+	{
+		puttCount = 0;
+		puttReverse = false;
+		putting = true;
+		stroking = false;
+		strength = 0;
+		if (m_useAdvancedPutting)
+		{
+			strokeCircle->setValue(0);
+			int pw = putter->endPoint().x() - putter->startPoint().x();
+			if (pw < 0) pw = -pw;
+			int px = (int)putter->x() + pw / 2;
+			int py = (int)putter->y();
+			if (px > width / 2 && py < height / 2)
+				strokeCircle->move(px - pw / 2 - 10 - strokeCircle->width(), py + 10);
+			else if (px > width / 2)
+				strokeCircle->move(px - pw / 2 - 10 - strokeCircle->width(), py - 10 - strokeCircle->height());
+			else if (py < height / 2)
+				strokeCircle->move(px + pw / 2 + 10, py + 10);
+			else
+				strokeCircle->move(px + pw / 2 + 10, py - 10 - strokeCircle->height());
+			strokeCircle->setVisible(true);
+		}
+		putterTimer->start(putterTimerMsec);
+	}
+	else if (m_useAdvancedPutting && putting && !editing)
+	{
+		putting = false;
+		stroking = true;
+		puttReverse = false;
+		finishStroking = false;
+	}
+	else if (m_useAdvancedPutting && stroking)
+	{
+		finishStroking = true;
+		putterTimeout();
+	}
+}
+
+void KolfGame::keyReleaseEvent(QKeyEvent *e)
+{
+	if (e->isAutoRepeat() || m_ignoreEvents)
+		return;
+
+	if (e->key() == Key_Space || e->key() == Key_Down)
+		puttRelease();
+	else if ((e->key() == Key_Backspace || e->key() == Key_Delete) && !(e->state() & ControlButton))
+	{
+		if (editing && !moving && selectedItem)
+		{
+			CanvasItem *citem = dynamic_cast<CanvasItem *>(selectedItem);
+			if (!citem)
+				return;
+			citem = citem->itemToDelete();
+			if (!citem)
+				return;
+			QCanvasItem *item = dynamic_cast<QCanvasItem *>(citem);
+			if (citem && citem->deleteable())
+			{
+				lastDelId = citem->curId();
+
+				highlighter->setVisible(false);
+				items.removeRef(item);
+				citem->hideInfo();
+				citem->aboutToDelete();
+				citem->aboutToDie();
+				delete citem;
+				selectedItem = 0;
+				emit newSelectedItem(&holeInfo);
+
+				setModified(true);
+			}
+		}
+	}
+	else if (e->key() == Key_I || e->key() == Key_Up)
+		toggleShowInfo();
+}
+
+void KolfGame::puttRelease()
+{
+	if (!m_useAdvancedPutting && putting && !editing)
+	{
+		putting = false;
+		stroking = true;
+	}
+}
+
+void KolfGame::stoppedBall()
+{
+	if (!inPlay)
+	{
+		inPlay = true;
+		dontAddStroke = true;
+	}
+}
+
+void KolfGame::timeout()
+{
+	Ball *curBall = (*curPlayer).ball();
+
+	// test if the ball is gone
+	// in this case we want to stop the ball and
+	// later undo the shot
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		if (!course->rect().contains(QPoint((*it).ball()->x(), (*it).ball()->y())))
+		{
+			(*it).ball()->setState(Stopped);
+
+			// don't do it if he's past maxStrokes
+			if ((*it).score(curHole) < holeInfo.maxStrokes() - 1 || !holeInfo.hasMaxStrokes())
+			{
+				loadStateList();
+			}
+			shotDone();
+
+			return;
+		}
+	}
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		if ((*it).ball()->forceStillGoing() || ((*it).ball()->curState() == Rolling && (*it).ball()->curVector().magnitude() > 0 && (*it).ball()->isVisible()))
+			return;
+
+	int curState = curBall->curState();
+	if (curState == Stopped && inPlay)
+	{
+		inPlay = false;
+		QTimer::singleShot(0, this, SLOT(shotDone()));
+	}
+
+	if (curState == Holed && inPlay)
+	{
+		emit inPlayEnd();
+		emit playerHoled(&(*curPlayer));
+
+		int curScore = (*curPlayer).score(curHole);
+		if (!dontAddStroke)
+			curScore++;
+
+		if (curScore == 1)
+		{
+			playSound("holeinone");
+		}
+		else if (curScore <= holeInfo.par())
+		{
+			// I don't have a sound!!
+			// *sob*
+			// playSound("woohoo");
+		}
+
+		(*curPlayer).ball()->setZ((*curPlayer).ball()->z() + .1 - (.1)/(curScore));
+
+		if (allPlayersDone())
+		{
+			inPlay = false;
+
+			if (curHole > 0 && !dontAddStroke)
+			{
+				(*curPlayer).addStrokeToHole(curHole);
+				emit scoreChanged((*curPlayer).id(), curHole, (*curPlayer).score(curHole));
+			}
+			QTimer::singleShot(600, this, SLOT(holeDone()));
+		}
+		else
+		{
+			inPlay = false;
+			QTimer::singleShot(0, this, SLOT(shotDone()));
+		}
+	}
+}
+
+void KolfGame::fastTimeout()
+{
+	// do regular advance every other time
+	if (regAdv)
+		course->advance();
+	regAdv = !regAdv;
+
+	if (!editing)
+	{
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->doAdvance();
+
+		if (fastAdvancedExist)
+		{
+			CanvasItem *citem = 0;
+			for (citem = fastAdvancers.first(); citem; citem = fastAdvancers.next())
+				citem->doAdvance();
+		}
+
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->fastAdvanceDone();
+
+		if (fastAdvancedExist)
+		{
+			CanvasItem *citem = 0;
+			for (citem = fastAdvancers.first(); citem; citem = fastAdvancers.next())
+				citem->fastAdvanceDone();
+		}
+	}
+}
+
+void KolfGame::ballMoved()
+{
+	if (putter->isVisible())
+	{
+		putter->move((*curPlayer).ball()->x(), (*curPlayer).ball()->y());
+		updateMouse();
+	}
+}
+
+void KolfGame::putterTimeout()
+{
+	if (inPlay || editing)
+		return;
+
+	if (m_useAdvancedPutting)
+	{
+		if (putting)
+		{
+			const float base = 2.0;
+
+			if (puttReverse && strength <= 0)
+			{
+				// aborted
+				putting = false;
+				strokeCircle->setVisible(false);
+			}
+			else if (strength > maxStrength || puttReverse)
+			{
+				// decreasing strength as we've reached the top
+				puttReverse = true;
+				strength -= pow(base, strength / maxStrength) - 1.8;
+				if ((int)strength < puttCount * 2)
+				{
+					puttCount--;
+					if (puttCount >= 0)
+						putter->go(Forwards);
+				}
+			}
+			else
+			{
+				// make the increase at high strength faster
+				strength += pow(base, strength / maxStrength) - .3;
+				if ((int)strength > puttCount * 2)
+				{
+					putter->go(Backwards);
+					puttCount++;
+				}
+			}
+			// make the visible steps at high strength smaller
+			strokeCircle->setValue(pow(strength / maxStrength, 0.8) * 360);
+		}
+		else if (stroking)
+		{
+			double al = strokeCircle->value();
+			if (al >= 45)
+				al -= 0.2 + strength / 50 + al / 100;
+			else
+				al -= 0.2 + strength / 50;
+
+			if (puttReverse)
+			{
+				// show the stroke
+				puttCount--;
+				if (puttCount >= 0)
+					putter->go(Forwards);
+				else
+				{
+					strokeCircle->setVisible(false);
+					finishStroking = false;
+					putterTimer->stop();
+					putting = false;
+					stroking = false;
+					shotStart();
+				}
+			}
+			else if (al < -45 || finishStroking)
+			{
+				strokeCircle->setValue(al);
+				int deg;
+				// if > 45 or < -45 then bad stroke
+				if (al > 45)
+				{
+					deg = putter->curDeg() - 45 + rand() % 90;
+					strength -= rand() % (int)strength;
+				}
+				else if (!finishStroking)
+				{
+					deg = putter->curDeg() - 45 + rand() % 90;
+					strength -= rand() % (int)strength;
+				}
+				else
+					deg = putter->curDeg() + (int)(strokeCircle->value() / 3);
+
+				if (deg < 0)
+					deg += 360;
+				else if (deg > 360)
+					deg -= 360;
+
+				putter->setDeg(deg);
+				puttReverse = true;
+			}
+			else
+			{
+				strokeCircle->setValue(al);
+				putterTimer->changeInterval(putterTimerMsec/10);
+			}
+		}
+
+	}
+	else
+	{
+		if (putting)
+		{
+			putter->go(Backwards);
+			puttCount++;
+			strength += 1.5;
+			if (strength > maxStrength)
+			{
+				putting = false;
+				stroking = true;
+			}
+		}
+		else if (stroking)
+		{
+			if (putter->curLen() < (*curPlayer).ball()->height() + 2)
+			{
+				stroking = false;
+				putterTimer->stop();
+				putting = false;
+				stroking = false;
+				shotStart();
+			}
+
+			putter->go(Forwards);
+			putterTimer->changeInterval(putterTimerMsec/10);
+		}
+	}
+}
+
+void KolfGame::autoSaveTimeout()
+{
+	// this should be a config option
+	// until it is i'll disable it
+	if (editing)
+	{
+		//save();
+	}
+}
+
+void KolfGame::recreateStateList()
+{
+	stateDB.clear();
+
+	QCanvasItem *item = 0;
+
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+		{
+			stateDB.setName(makeStateGroup(citem->curId(), citem->name()));
+			citem->saveState(&stateDB);
+		}
+	}
+
+	ballStateList.clear();
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		ballStateList.append((*it).stateInfo(curHole));
+
+	ballStateList.canUndo = true;
+}
+
+void KolfGame::undoShot()
+{
+	if (ballStateList.canUndo)
+		loadStateList();
+}
+
+void KolfGame::loadStateList()
+{
+	QCanvasItem *item = 0;
+
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+		{
+			stateDB.setName(makeStateGroup(citem->curId(), citem->name()));
+			citem->loadState(&stateDB);
+		}
+	}
+
+	for (BallStateList::Iterator it = ballStateList.begin(); it != ballStateList.end(); ++it)
+	{
+		BallStateInfo info = (*it);
+		Player &player = (*players->at(info.id - 1));
+		player.ball()->move(info.spot.x(), info.spot.y());
+		player.ball()->setBeginningOfHole(info.beginningOfHole);
+		if ((*curPlayer).id() == info.id)
+			ballMoved();
+		else
+			player.ball()->setVisible(!info.beginningOfHole);
+		player.setScoreForHole(info.score, curHole);
+		player.ball()->setState(info.state);
+		emit scoreChanged(info.id, curHole, info.score);
+	}
+}
+
+void KolfGame::shotDone()
+{
+	inPlay = false;
+	emit inPlayEnd();
+	setFocus();
+
+	Ball *ball = (*curPlayer).ball();
+	double oldx = ball->x(), oldy = ball->y();
+
+	if (!dontAddStroke && (*curPlayer).numHoles())
+		(*curPlayer).addStrokeToHole(curHole);
+
+	dontAddStroke = false;
+
+	// do hack stuff, shouldn't be done here
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		if ((*it).ball()->addStroke())
+		{
+			for (int i = 1; i <= (*it).ball()->addStroke(); ++i)
+				(*it).addStrokeToHole(curHole);
+
+			// emit that we have a new stroke count
+			emit scoreChanged((*it).id(), curHole, (*it).score(curHole));
+		}
+		(*it).ball()->setAddStroke(0);
+	}
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		Ball *ball = (*it).ball();
+
+		if (ball->curState() == Holed)
+			continue;
+
+		Vector v;
+		if (ball->placeOnGround(v))
+		{
+			ball->setPlaceOnGround(false);
+
+			QStringList options;
+			const QString placeOutside = i18n("Drop Outside of Hazard");
+			const QString rehit = i18n("Rehit From Last Location");
+			options << placeOutside << rehit;
+			const QString choice = KComboBoxDialog::getItem(i18n("What would you like to do for your next shot?"), i18n("%1 is in a Hazard").arg((*it).name()), options, placeOutside, "hazardOptions");
+
+			if (choice == placeOutside)
+			{
+				(*it).ball()->setDoDetect(false);
+
+				double x = ball->x(), y = ball->y();
+
+				while (1)
+				{
+					QCanvasItemList list = ball->collisions(true);
+					bool keepMoving = false;
+					while (!list.isEmpty())
+					{
+						QCanvasItem *item = list.first();
+						if (item->rtti() == Rtti_DontPlaceOn)
+							keepMoving = true;
+
+						list.pop_front();
+					}
+					if (!keepMoving)
+						break;
+
+					const float movePixel = 3.0;
+					x -= cos(v.direction()) * movePixel;
+					y += sin(v.direction()) * movePixel;
+
+					ball->move(x, y);
+				}
+
+				// move another two pixels away
+				x -= cos(v.direction()) * 2;
+				y += sin(v.direction()) * 2;
+			}
+			else if (choice == rehit)
+			{
+				for (BallStateList::Iterator it = ballStateList.begin(); it != ballStateList.end(); ++it)
+				{
+					if ((*it).id == (*curPlayer).id())
+					{
+						if ((*it).beginningOfHole)
+							ball->move(whiteBall->x(), whiteBall->y());
+						else
+							ball->move((*it).spot.x(), (*it).spot.y());
+
+						break;
+					}
+				}
+			}
+
+			ball->setVisible(true);
+			ball->setState(Stopped);
+
+			(*it).ball()->setDoDetect(true);
+			ball->collisionDetect(oldx, oldy);
+		}
+	}
+
+	// emit again
+	emit scoreChanged((*curPlayer).id(), curHole, (*curPlayer).score(curHole));
+
+	ball->setVelocity(0, 0);
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		Ball *ball = (*it).ball();
+
+		int curStrokes = (*it).score(curHole);
+		if (curStrokes >= holeInfo.maxStrokes() && holeInfo.hasMaxStrokes())
+		{
+			ball->setState(Holed);
+			ball->setVisible(false);
+
+			// move to center in case he/she hit out
+			ball->move(width / 2, height / 2);
+			playerWhoMaxed = (*it).name();
+
+			if (allPlayersDone())
+			{
+				startNextHole();
+				QTimer::singleShot(100, this, SLOT(emitMax()));
+				return;
+			}
+
+			QTimer::singleShot(100, this, SLOT(emitMax()));
+		}
+	}
+
+	// change player to next player
+	// skip player if he's Holed
+	do
+	{
+		curPlayer++;
+		if (curPlayer == players->end())
+			curPlayer = players->begin();
+	}
+	while ((*curPlayer).ball()->curState() == Holed);
+
+	emit newPlayersTurn(&(*curPlayer));
+
+	(*curPlayer).ball()->setVisible(true);
+
+	putter->setAngle((*curPlayer).ball());
+	putter->setOrigin((*curPlayer).ball()->x(), (*curPlayer).ball()->y());
+	updateMouse();
+
+	inPlay = false;
+	(*curPlayer).ball()->collisionDetect(oldx, oldy);
+}
+
+void KolfGame::emitMax()
+{
+	emit maxStrokesReached(playerWhoMaxed);
+}
+
+void KolfGame::startBall(const Vector &vector)
+{
+	playSound("hit");
+
+	emit inPlayStart();
+	putter->setVisible(false);
+
+	(*curPlayer).ball()->setState(Rolling);
+	(*curPlayer).ball()->setVector(vector);
+
+	QCanvasItem *item = 0;
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+			citem->shotStarted();
+	}
+
+	inPlay = true;
+}
+
+void KolfGame::shotStart()
+{
+	// ensure we never hit the ball back into the hole which
+	// can cause hole skippage
+	if ((*curPlayer).ball()->curState() == Holed)
+		return;
+
+	// save state
+	recreateStateList();
+
+	putter->saveAngle((*curPlayer).ball());
+	strength /= 8;
+	if (!strength)
+		strength = 1;
+
+	startBall(Vector(strength, putter->curAngle() + M_PI));
+
+	addHoleInfo(ballStateList);
+}
+
+void KolfGame::addHoleInfo(BallStateList &list)
+{
+	list.player = (*curPlayer).id();
+	list.vector = (*curPlayer).ball()->curVector();
+	list.hole = curHole;
+}
+
+void KolfGame::sayWhosGoing()
+{
+	if (players->count() >= 2)
+	{
+		KMessageBox::information(this, i18n("%1 will start off.").arg((*curPlayer).name()), i18n("New Hole"), "newHole");
+	}
+}
+
+void KolfGame::holeDone()
+{
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		(*it).ball()->setVisible(false);
+	startNextHole();
+	sayWhosGoing();
+}
+
+// this function is WAY too smart for it's own good
+// ie, bad design :-(
+void KolfGame::startNextHole()
+{
+	setFocus();
+
+	bool reset = true;
+	if (askSave(true))
+	{
+		if (allPlayersDone())
+		{
+			// we'll reload this hole, but not reset
+			curHole--;
+			reset = false;
+		}
+		else
+			return;
+	}
+	else
+		setModified(false);
+
+	pause();
+
+	dontAddStroke = false;
+
+	inPlay = false;
+	timer->stop();
+	putter->resetAngles();
+
+	int oldCurHole = curHole;
+	curHole++;
+	emit currentHole(curHole);
+
+	if (reset)
+	{
+		whiteBall->move(width/2, height/2);
+		holeInfo.borderWallsChanged(true);
+	}
+
+	int leastScore = INT_MAX;
+
+	// to get the first player to go first on every hole,
+	// don't do the score stuff below
+	curPlayer = players->begin();
+	double oldx=(*curPlayer).ball()->x(), oldy=(*curPlayer).ball()->y();
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		if (curHole > 1)
+		{
+			bool ahead = false;
+			if ((*it).lastScore() != 0)
+			{
+				if ((*it).lastScore() < leastScore)
+					ahead = true;
+				else if ((*it).lastScore() == leastScore)
+				{
+					for (int i = curHole - 1; i > 0; --i)
+					{
+						const int thisScore = (*it).score(i);
+						const int thatScore = (*curPlayer).score(i);
+						if (thisScore < thatScore)
+						{
+							ahead = true;
+							break;
+						}
+						else if (thisScore > thatScore)
+							break;
+					}
+				}
+			}
+
+			if (ahead)
+			{
+				curPlayer = it;
+				leastScore = (*it).lastScore();
+			}
+		}
+
+		if (reset)
+			(*it).ball()->move(width / 2, height / 2);
+		else
+			(*it).ball()->move(whiteBall->x(), whiteBall->y());
+
+		(*it).ball()->setState(Stopped);
+
+		// this gets set to false when the ball starts
+		// to move by the Mr. Ball himself.
+		(*it).ball()->setBeginningOfHole(true);
+		if ((int)(*it).scores().count() < curHole)
+			(*it).addHole();
+		(*it).ball()->setVelocity(0, 0);
+		(*it).ball()->setVisible(false);
+	}
+
+	emit newPlayersTurn(&(*curPlayer));
+
+	if (reset)
+		openFile();
+
+	inPlay = false;
+	timer->start(timerMsec);
+
+	// if (false) { we're done with the round! }
+	if (oldCurHole != curHole)
+	{
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->setPlaceOnGround(false);
+
+		// here we have to make sure the scoreboard shows
+		// all of the holes up until now;
+
+		for (; scoreboardHoles < curHole; ++scoreboardHoles)
+		{
+			cfg->setGroup(QString("%1-hole@-50,-50|0").arg(scoreboardHoles + 1));
+			emit newHole(cfg->readNumEntry("par", 3));
+		}
+
+		resetHoleScores();
+		updateShowInfo();
+
+		// this is from shotDone()
+		(*curPlayer).ball()->setVisible(true);
+		putter->setOrigin((*curPlayer).ball()->x(), (*curPlayer).ball()->y());
+		updateMouse();
+
+		ballStateList.canUndo = false;
+
+		(*curPlayer).ball()->collisionDetect(oldx, oldy);
+	}
+
+	unPause();
+}
+
+void KolfGame::showInfo()
+{
+	QString text = i18n("Hole %1: par %2, maximum %3 strokes").arg(curHole).arg(holeInfo.par()).arg(holeInfo.maxStrokes());
+	infoText->move((width - QFontMetrics(infoText->font()).width(text)) / 2, infoText->y());
+	infoText->setText(text);
+	// I hate this text! Let's not show it
+	//infoText->setVisible(true);
+
+	emit newStatusText(text);
+}
+
+void KolfGame::showInfoDlg(bool addDontShowAgain)
+{
+	KMessageBox::information(parentWidget(),
+	i18n("Course name: %1").arg(holeInfo.name()) + QString("\n")
+	+ i18n("Created by %1").arg(holeInfo.author()) + QString("\n")
+	+ i18n("%1 holes").arg(highestHole),
+	i18n("Course Information"),
+	addDontShowAgain? holeInfo.name() + QString(" ") + holeInfo.author() : QString::null);
+}
+
+void KolfGame::hideInfo()
+{
+	infoText->setText("");
+	infoText->setVisible(false);
+
+	emit newStatusText(QString::null);
+}
+
+void KolfGame::openFile()
+{
+	Object *curObj = 0;
+
+	QCanvasItem *item = 0;
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+		{
+			// sometimes info is still showing
+			citem->hideInfo();
+			citem->aboutToDie();
+		}
+	}
+
+	items.setAutoDelete(true);
+	items.clear();
+	items.setAutoDelete(false);
+
+	extraMoveable.setAutoDelete(false);
+	extraMoveable.clear();
+	fastAdvancers.setAutoDelete(false);
+	fastAdvancers.clear();
+	selectedItem = 0;
+
+	// will tell basic course info
+	// we do this here for the hell of it.
+	// there is no fake id, by the way,
+	// because it's old and when i added ids i forgot to change it.
+	cfg->setGroup("0-course@-50,-50");
+	holeInfo.setAuthor(cfg->readEntry("author", holeInfo.author()));
+	holeInfo.setName(cfg->readEntry("Name", holeInfo.name()));
+	holeInfo.setUntranslatedName(cfg->readEntryUntranslated("Name", holeInfo.untranslatedName()));
+	emit titleChanged(holeInfo.name());
+
+	cfg->setGroup(QString("%1-hole@-50,-50|0").arg(curHole));
+	curPar = cfg->readNumEntry("par", 3);
+	holeInfo.setPar(curPar);
+	holeInfo.borderWallsChanged(cfg->readBoolEntry("borderWalls", holeInfo.borderWalls()));
+	holeInfo.setMaxStrokes(cfg->readNumEntry("maxstrokes", 10));
+	bool hasFinalLoad = cfg->readBoolEntry("hasFinalLoad", true);
+
+	QStringList missingPlugins;
+	QStringList groups = cfg->groupList();
+
+	int numItems = 0;
+	int _highestHole = 0;
+
+	for (QStringList::Iterator it = groups.begin(); it != groups.end(); ++it)
+	{
+		// [<holeNum>-<name>@<x>,<y>|<id>]
+		cfg->setGroup(*it);
+
+		const int len = (*it).length();
+		const int dashIndex = (*it).find("-");
+		const int holeNum = (*it).left(dashIndex).toInt();
+		if (holeNum > _highestHole)
+			_highestHole = holeNum;
+
+		const int atIndex = (*it).find("@");
+		const QString name = (*it).mid(dashIndex + 1, atIndex - (dashIndex + 1));
+
+		if (holeNum != curHole)
+		{
+			// if we've had one, break, cause list is sorted
+			// erps, no, cause we need to know highest hole!
+			if (numItems && !recalcHighestHole)
+					break;
+			continue;
+		}
+		numItems++;
+
+
+		const int commaIndex = (*it).find(",");
+		const int pipeIndex = (*it).find("|");
+		const int x = (*it).mid(atIndex + 1, commaIndex - (atIndex + 1)).toInt();
+		const int y = (*it).mid(commaIndex + 1, pipeIndex - (commaIndex + 1)).toInt();
+
+		// will tell where ball is
+		if (name == "ball")
+		{
+			for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+				(*it).ball()->move(x, y);
+			whiteBall->move(x, y);
+			continue;
+		}
+
+		const int id = (*it).right(len - (pipeIndex + 1)).toInt();
+
+		bool loaded = false;
+
+		for (curObj = obj->first(); curObj; curObj = obj->next())
+		{
+			if (name != curObj->_name())
+				continue;
+
+			QCanvasItem *newItem = curObj->newObject(course);
+			items.append(newItem);
+
+			CanvasItem *canvasItem = dynamic_cast<CanvasItem *>(newItem);
+			if (!canvasItem)
+				continue;
+
+			canvasItem->setId(id);
+			canvasItem->setGame(this);
+			canvasItem->editModeChanged(editing);
+			canvasItem->setName(curObj->_name());
+			addItemsToMoveableList(canvasItem->moveableItems());
+			if (canvasItem->fastAdvance())
+				addItemToFastAdvancersList(canvasItem);
+
+			newItem->move(x, y);
+			canvasItem->firstMove(x, y);
+
+			newItem->setVisible(true);
+
+			// make things actually show
+			if (!hasFinalLoad)
+			{
+				cfg->setGroup(makeGroup(id, curHole, canvasItem->name(), x, y));
+				canvasItem->load(cfg);
+				course->update();
+			}
+
+			// we don't allow multiple items for the same thing in
+			// the file!
+
+			loaded = true;
+			break;
+		}
+
+		if (!loaded && name != "hole" && missingPlugins.contains(name) <= 0)
+			missingPlugins.append(name);
+	}
+
+	if (!missingPlugins.empty())
+	{
+		KMessageBox::informationList(this, QString("<p>&lt;http://katzbrown.com/kolf/Plugins/&gt;</p><p>") + i18n("This hole uses the following plugins, which you do not have installed:") + QString("</p>"), missingPlugins, QString::null, QString("%1 warning").arg(holeInfo.untranslatedName() + QString::number(curHole)));
+	}
+
+	lastDelId = -1;
+
+	// if it's the first hole let's not
+	if (!numItems && curHole > 1 && !addingNewHole && curHole >= _highestHole)
+	{
+		// we're done, let's quit
+		curHole--;
+		pause();
+		emit holesDone();
+
+		// tidy things up
+		setBorderWalls(false);
+		clearHole();
+		setModified(false);
+		for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+			(*it).ball()->setVisible(false);
+
+		return;
+	}
+
+	// do it down here; if !hasFinalLoad, do it up there!
+	QCanvasItem *qcanvasItem = 0;
+	QPtrList<CanvasItem> todo;
+	QPtrList<QCanvasItem> qtodo;
+	if (hasFinalLoad)
+	{
+		for (qcanvasItem = items.first(); qcanvasItem; qcanvasItem = items.next())
+		{
+			CanvasItem *item = dynamic_cast<CanvasItem *>(qcanvasItem);
+			if (item)
+			{
+				if (item->loadLast())
+				{
+					qtodo.append(qcanvasItem);
+					todo.append(item);
+				}
+				else
+				{
+					QString group = makeGroup(item->curId(), curHole, item->name(), (int)qcanvasItem->x(), (int)qcanvasItem->y());
+					cfg->setGroup(group);
+					item->load(cfg);
+				}
+			}
+		}
+
+		CanvasItem *citem = 0;
+		qcanvasItem = qtodo.first();
+		for (citem = todo.first(); citem; citem = todo.next())
+		{
+			cfg->setGroup(makeGroup(citem->curId(), curHole, citem->name(), (int)qcanvasItem->x(), (int)qcanvasItem->y()));
+			citem->load(cfg);
+
+			qcanvasItem = qtodo.next();
+		}
+	}
+
+	for (qcanvasItem = items.first(); qcanvasItem; qcanvasItem = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(qcanvasItem);
+		if (citem)
+			citem->updateZ();
+	}
+
+	if (curHole > _highestHole)
+		_highestHole = curHole;
+
+	if (recalcHighestHole)
+	{
+		highestHole = _highestHole;
+		recalcHighestHole = false;
+		emit largestHole(highestHole);
+	}
+
+	if (curHole == 1 && !filename.isNull() && !infoShown)
+	{
+		// let's not now, because they see it when they choose course
+		//showInfoDlg(true);
+		infoShown = true;
+	}
+
+	setModified(false);
+}
+
+void KolfGame::addItemsToMoveableList(QPtrList<QCanvasItem> list)
+{
+	QCanvasItem *item = 0;
+	for (item = list.first(); item; item = list.next())
+		extraMoveable.append(item);
+}
+
+void KolfGame::addItemToFastAdvancersList(CanvasItem *item)
+{
+	fastAdvancers.append(item);
+	fastAdvancedExist = fastAdvancers.count() > 0;
+}
+
+void KolfGame::addNewObject(Object *newObj)
+{
+	QCanvasItem *newItem = newObj->newObject(course);
+	items.append(newItem);
+	newItem->setVisible(true);
+
+	CanvasItem *canvasItem = dynamic_cast<CanvasItem *>(newItem);
+	if (!canvasItem)
+		return;
+
+	// we need to find a number that isn't taken
+	int i = lastDelId > 0? lastDelId : items.count() - 30;
+	if (i <= 0)
+		i = 0;
+
+	for (;; ++i)
+	{
+		bool found = false;
+		QCanvasItem *item = 0;
+		for (item = items.first(); item; item = items.next())
+		{
+			CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+			if (citem)
+			{
+				if (citem->curId() == i)
+				{
+					found = true;
+					break;
+				}
+			}
+		}
+
+
+		if (!found)
+			break;
+	}
+	canvasItem->setId(i);
+
+	canvasItem->setGame(this);
+
+	if (m_showInfo)
+		canvasItem->showInfo();
+	else
+		canvasItem->hideInfo();
+
+	canvasItem->editModeChanged(editing);
+
+	canvasItem->setName(newObj->_name());
+	addItemsToMoveableList(canvasItem->moveableItems());
+
+	if (canvasItem->fastAdvance())
+		addItemToFastAdvancersList(canvasItem);
+
+	newItem->move(width/2 - 18, height / 2 - 18);
+
+	if (selectedItem)
+		canvasItem->selectedItem(selectedItem);
+
+	setModified(true);
+}
+
+bool KolfGame::askSave(bool noMoreChances)
+{
+	if (!modified)
+		// not cancel, don't save
+		return false;
+
+	int result = KMessageBox::warningYesNoCancel(this, i18n("There are unsaved changes to current hole. Save them?"), i18n("Unsaved Changes"), KStdGuiItem::save(), noMoreChances? KStdGuiItem::discard() : i18n("Save &Later"), noMoreChances? "DiscardAsk" : "SaveAsk", true);
+	switch (result)
+	{
+		case KMessageBox::Yes:
+			save();
+			// fallthrough
+
+		case KMessageBox::No:
+			return false;
+		break;
+
+		case KMessageBox::Cancel:
+			return true;
+		break;
+
+		default:
+		break;
+	}
+
+	return false;
+}
+
+void KolfGame::addNewHole()
+{
+	if (askSave(true))
+		return;
+
+	// either it's already false
+	// because it was saved by askSave(),
+	// or the user pressed the 'discard' button
+	setModified(false);
+
+	// find highest hole num, and create new hole
+	// now openFile makes highest hole for us
+
+	addingNewHole = true;
+	curHole = highestHole;
+	recalcHighestHole = true;
+	startNextHole();
+	addingNewHole = false;
+	emit currentHole(curHole);
+
+	// make sure even the current player isn't showing
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		(*it).ball()->setVisible(false);
+
+	whiteBall->setVisible(editing);
+	highlighter->setVisible(false);
+	putter->setVisible(!editing);
+	inPlay = false;
+
+	// add default objects
+	Object *curObj = 0;
+	for (curObj = obj->first(); curObj; curObj = obj->next())
+		if (curObj->addOnNewHole())
+			addNewObject(curObj);
+
+	save();
+}
+
+// kantan deshou ;-)
+void KolfGame::resetHole()
+{
+	if (askSave(true))
+		return;
+	setModified(false);
+	curHole--;
+	startNextHole();
+	resetHoleScores();
+}
+
+void KolfGame::resetHoleScores()
+{
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		(*it).resetScore(curHole);
+		emit scoreChanged((*it).id(), curHole, 0);
+	}
+}
+
+void KolfGame::clearHole()
+{
+	QCanvasItem *qcanvasItem = 0;
+	for (qcanvasItem = items.first(); qcanvasItem; qcanvasItem = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(qcanvasItem);
+		if (citem)
+			citem->aboutToDie();
+	}
+	items.setAutoDelete(true);
+	items.clear();
+	items.setAutoDelete(false);
+	emit newSelectedItem(&holeInfo);
+
+	// add default objects
+	Object *curObj = 0;
+	for (curObj = obj->first(); curObj; curObj = obj->next())
+		if (curObj->addOnNewHole())
+			addNewObject(curObj);
+
+	setModified(true);
+}
+
+void KolfGame::switchHole(int hole)
+{
+	if (inPlay)
+		return;
+	if (hole < 1 || hole > highestHole)
+		return;
+
+	bool wasEditing = editing;
+	if (editing)
+		toggleEditMode();
+
+	if (askSave(true))
+		return;
+	setModified(false);
+
+	curHole = hole;
+	resetHole();
+
+	if (wasEditing)
+		toggleEditMode();
+}
+
+void KolfGame::switchHole(const QString &holestring)
+{
+	bool ok;
+	int hole = holestring.toInt(&ok);
+	if (!ok)
+		return;
+	switchHole(hole);
+}
+
+void KolfGame::nextHole()
+{
+	switchHole(curHole + 1);
+}
+
+void KolfGame::prevHole()
+{
+	switchHole(curHole - 1);
+}
+
+void KolfGame::firstHole()
+{
+	switchHole(1);
+}
+
+void KolfGame::lastHole()
+{
+	switchHole(highestHole);
+}
+
+void KolfGame::randHole()
+{
+	int newHole = 1 + (int)((double)kapp->random() * ((double)(highestHole - 1) / (double)RAND_MAX));
+	switchHole(newHole);
+}
+
+void KolfGame::save()
+{
+	if (filename.isNull())
+	{
+		QString newfilename = KFileDialog::getSaveFileName(":kourses", "application/x-kourse", this, i18n("Pick Kolf Course to Save To"));
+		if (newfilename.isNull())
+			return;
+
+		setFilename(newfilename);
+	}
+
+	emit parChanged(curHole, holeInfo.par());
+	emit titleChanged(holeInfo.name());
+
+	// we use this bool for optimization
+	// in openFile().
+	bool hasFinalLoad = false;
+	fastAdvancedExist = false;
+
+	QCanvasItem *item = 0;
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+		{
+			citem->aboutToSave();
+			if (citem->loadLast())
+				hasFinalLoad = true;
+		}
+	}
+
+	QStringList groups = cfg->groupList();
+
+	// wipe out all groups from this hole
+	for (QStringList::Iterator it = groups.begin(); it != groups.end(); ++it)
+	{
+		int holeNum = (*it).left((*it).find("-")).toInt();
+		if (holeNum == curHole)
+			cfg->deleteGroup(*it);
+	}
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+		{
+			citem->clean();
+
+			cfg->setGroup(makeGroup(citem->curId(), curHole, citem->name(), (int)item->x(), (int)item->y()));
+			citem->save(cfg);
+		}
+	}
+
+	// save where ball starts (whiteBall tells all)
+	cfg->setGroup(QString("%1-ball@%2,%3").arg(curHole).arg((int)whiteBall->x()).arg((int)whiteBall->y()));
+	cfg->writeEntry("dummykey", true);
+
+	cfg->setGroup("0-course@-50,-50");
+	cfg->writeEntry("author", holeInfo.author());
+	cfg->writeEntry("Name", holeInfo.untranslatedName());
+
+	// save hole info
+	cfg->setGroup(QString("%1-hole@-50,-50|0").arg(curHole));
+	cfg->writeEntry("par", holeInfo.par());
+	cfg->writeEntry("maxstrokes", holeInfo.maxStrokes());
+	cfg->writeEntry("borderWalls", holeInfo.borderWalls());
+	cfg->writeEntry("hasFinalLoad", hasFinalLoad);
+
+	cfg->sync();
+
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+			citem->savingDone();
+	}
+
+	setModified(false);
+}
+
+void KolfGame::toggleEditMode()
+{
+	// won't be editing anymore, and user wants to cancel, we return
+	// this is pretty useless. when the person leaves the hole,
+	// he gets asked again
+	/*
+	if (editing && modified)
+	{
+		if (askSave(false))
+		{
+			emit checkEditing();
+			return;
+		}
+	}
+	*/
+
+	moving = false;
+	selectedItem = 0;
+
+	editing = !editing;
+
+	if (editing)
+	{
+		emit editingStarted();
+		emit newSelectedItem(&holeInfo);
+	}
+	else
+	{
+		emit editingEnded();
+		setCursor(KCursor::arrowCursor());
+	}
+
+	// alert our items
+	QCanvasItem *item = 0;
+	for (item = items.first(); item; item = items.next())
+	{
+		CanvasItem *citem = dynamic_cast<CanvasItem *>(item);
+		if (citem)
+			citem->editModeChanged(editing);
+	}
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		// curplayer shouldn't be hidden no matter what
+		if ((*it).ball()->beginningOfHole() && it != curPlayer)
+			(*it).ball()->setVisible(false);
+		else
+			(*it).ball()->setVisible(!editing);
+	}
+
+	whiteBall->setVisible(editing);
+	highlighter->setVisible(false);
+
+	// shouldn't see putter whilst editing
+	putter->setVisible(!editing);
+
+	if (editing)
+		autoSaveTimer->start(autoSaveMsec);
+	else
+		autoSaveTimer->stop();
+
+	inPlay = false;
+}
+
+void KolfGame::playSound(QString file, double vol)
+{
+	if (m_sound)
+	{
+		KPlayObject *oldPlayObject = 0;
+		for (oldPlayObject = oldPlayObjects.first(); oldPlayObject; oldPlayObject = oldPlayObjects.next())
+		{
+			if (oldPlayObject && oldPlayObject->state() != Arts::posPlaying)
+			{
+				oldPlayObjects.remove();
+
+				// because we will go to next() next time
+				// and after remove current item is one after
+				// removed item
+				(void) oldPlayObjects.prev();
+			}
+		}
+
+		file = soundDir + file + QString::fromLatin1(".wav");
+
+		// not needed when all of the files are in the distribution
+		//if (!QFile::exists(file))
+			//return;
+
+		KPlayObjectFactory factory(artsServer.server());
+		KPlayObject *playObject = factory.createPlayObject(KURL(file), true);
+
+		if (playObject && !playObject->isNull())
+		{
+			if (vol > 1)
+				vol = 1;
+			else if (vol <= .01)
+			{
+				delete playObject;
+				return;
+			}
+
+			if (vol < .99)
+			{
+				//new KVolumeControl(vol, artsServer.server(), playObject);
+			}
+
+			playObject->play();
+			oldPlayObjects.append(playObject);
+		}
+	}
+}
+
+void HoleInfo::borderWallsChanged(bool yes)
+{
+	m_borderWalls = yes;
+	game->setBorderWalls(yes);
+}
+
+void KolfGame::print(KPrinter &pr)
+{
+	QPainter p(&pr);
+
+	QPaintDeviceMetrics metrics(&pr);
+
+	// translate to center
+	p.translate(metrics.width() / 2 - course->rect().width() / 2, metrics.height() / 2 - course->rect().height() / 2);
+
+	QPixmap pix(width, height);
+	QPainter pixp(&pix);
+	course->drawArea(course->rect(), &pixp);
+	p.drawPixmap(0, 0, pix);
+
+	p.setPen(QPen(black, 2));
+	p.drawRect(course->rect());
+
+	p.resetXForm();
+
+	if (pr.option("kde-kolf-title") == "true")
+	{
+		QString text = i18n("%1 - Hole %2; by %3").arg(holeInfo.name()).arg(curHole).arg(holeInfo.author());
+		QFont font(kapp->font());
+		font.setPointSize(18);
+		QRect rect = QFontMetrics(font).boundingRect(text);
+		p.setFont(font);
+
+		p.drawText(metrics.width() / 2 - rect.width() / 2, metrics.height() / 2 - course->rect().height() / 2 -20 - rect.height(), text);
+	}
+}
+
+bool KolfGame::allPlayersDone()
+{
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+		if ((*it).ball()->curState() != Holed)
+			return false;
+
+	return true;
+}
+
+void KolfGame::setBorderWalls(bool showing)
+{
+	Wall *wall = 0;
+	for (wall = borderWalls.first(); wall; wall = borderWalls.next())
+		wall->setVisible(showing);
+}
+
+void KolfGame::setUseAdvancedPutting(bool yes)
+{
+	m_useAdvancedPutting = yes;
+
+	// increase maxStrength in advanced putting mode
+	if (yes)
+		maxStrength = 65;
+	else
+		maxStrength = 55;
+}
+
+void KolfGame::setShowGuideLine(bool yes)
+{
+	putter->setShowGuideLine(yes);
+}
+
+void KolfGame::setSound(bool yes)
+{
+	m_sound = yes;
+}
+
+void KolfGame::courseInfo(CourseInfo &info, const QString& filename)
+{
+	KConfig cfg(filename);
+	cfg.setGroup("0-course@-50,-50");
+	info.author = cfg.readEntry("author", info.author);
+	info.name = cfg.readEntry("Name", cfg.readEntry("name", info.name));
+	info.untranslatedName = cfg.readEntryUntranslated("Name", cfg.readEntryUntranslated("name", info.name));
+
+	unsigned int hole = 1;
+	unsigned int par= 0;
+	while (1)
+	{
+		QString group = QString("%1-hole@-50,-50|0").arg(hole);
+		if (!cfg.hasGroup(group))
+		{
+			hole--;
+			break;
+		}
+
+		cfg.setGroup(group);
+		par += cfg.readNumEntry("par", 3);
+
+		hole++;
+	}
+
+	info.par = par;
+	info.holes = hole;
+}
+
+void KolfGame::scoresFromSaved(KConfig *config, PlayerList &players)
+{
+	config->setGroup("0 Saved Game");
+	int numPlayers = config->readNumEntry("Players", 0);
+	if (numPlayers <= 0)
+		return;
+
+	for (int i = 1; i <= numPlayers; ++i)
+	{
+		// this is same as in kolf.cpp, but we use saved game values
+		config->setGroup(QString::number(i));
+		players.append(Player());
+		players.last().ball()->setColor(config->readEntry("Color", "#ffffff"));
+		players.last().setName(config->readEntry("Name"));
+		players.last().setId(i);
+
+		QStringList scores(config->readListEntry("Scores"));
+		QValueList<int> intscores;
+		for (QStringList::Iterator it = scores.begin(); it != scores.end(); ++it)
+			intscores.append((*it).toInt());
+
+		players.last().setScores(intscores);
+	}
+}
+
+void KolfGame::saveScores(KConfig *config)
+{
+	// wipe out old player info
+	QStringList groups = config->groupList();
+	for (QStringList::Iterator it = groups.begin(); it != groups.end(); ++it)
+	{
+		// this deletes all int groups, ie, the player info groups
+		bool ok = false;
+		(*it).toInt(&ok);
+		if (ok)
+			config->deleteGroup(*it);
+	}
+
+	config->setGroup("0 Saved Game");
+	config->writeEntry("Players", players->count());
+	config->writeEntry("Course", filename);
+	config->writeEntry("Current Hole", curHole);
+
+	for (PlayerList::Iterator it = players->begin(); it != players->end(); ++it)
+	{
+		config->setGroup(QString::number((*it).id()));
+		config->writeEntry("Name", (*it).name());
+		config->writeEntry("Color", (*it).ball()->color().name());
+
+		QStringList scores;
+		QValueList<int> intscores = (*it).scores();
+		for (QValueList<int>::Iterator it = intscores.begin(); it != intscores.end(); ++it)
+			scores.append(QString::number(*it));
+
+		config->writeEntry("Scores", scores);
+	}
+}
+
+CourseInfo::CourseInfo()
+: name(i18n("Course Name")), author(i18n("Course Author")), holes(0), par(0)
+{
+}
+
+#include "game.moc"