void FOV::draw(QPainter &p, float x, float y)
{
float xfactor = x / sizeX() * 57.3 * 60.0;
float yfactor = y / sizeY() * 57.3 * 60.0;
float zoomFactor = std::min(xfactor, yfactor);
switch( shape() ) {
case CROSSHAIRS: zoomFactor /= 3; break;
case BULLSEYE: zoomFactor /= 8; break;
default: ;
}
draw(p, zoomFactor);
}
/**
* @brief Solver::PddlStripsConst::createProblemFile
* @param outFileName
*/
void Solver::PddlStripsConst::createProblemFile(const std::string& outFileName) {
std::fstream data;
uint sizeX(gameField.getField().getSizeX());
uint sizeY(gameField.getField().getSizeY());
data.open(outFileName, std::ios::out);
data << "(define (problem modulo-strips-const)" << std::endl;
data << " (:domain Modulo-Strips-Const)" << std::endl;
data << " (:objects" << std::endl;
data << " )" << std::endl;
data << " (:init" << std::endl;
// Sagen das die Tiles unbenutzt sind
for(const Tile& t1: gameField.getTiles()) {
data << " (notUsed" << " Tile" << t1.getId() << ")" << std::endl;
}
// Sagen das die Tiles Positionen unbenutzt sind
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y) {
if(t.getField(x,y))
data << " (notUsed TileCell_T" << t.getId() <<"_X" << x << "_Y" << y << ")" << std::endl;
}
// Den Zellen Farbe geben
for(uint x=0; x<sizeX; ++x)
for(uint y=0; y<sizeY; ++y) {
data << " (hasColor" << (int)gameField.getField().getField(x,y) << " Cell_X" << x << "_Y" << y <<")" << std::endl;
}
data << " )" << std::endl;
// Zielzustand
data << " (:goal (and" << std::endl;
//1. Farbe
for(uint x=0; x<sizeX; ++x)
for(uint y=0; y<sizeY; ++y) {
data << " (hasColor0 Cell_X" << x << "_Y" << y <<")" << std::endl;
}
// 2. Alle Tilezellen wurden benutzt
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y) {
if(t.getField(x,y))
data << " (wasUsed TileCell_T" << t.getId() <<"_X" << x << "_Y" << y << ")" << std::endl;
}
// 3. Alle Tiles wurden benutzt
for(const Tile& t: gameField.getTiles()) {
data << " (wasUsed Tile" << t.getId() << ")" << std::endl;
}
data << " ))" << std::endl;
data << ")"<< std::endl;
data.close();
}
// fill the screen using current attributes
void fillScreen()
{
DWORD charsWritten;
COORD c; //upper left corner
c.X=0;
c.Y=0;
int size = sizeX()*sizeY(); //number of characters in the screen
//fill the screen with spaces
FillConsoleOutputCharacter(hStdout, ' ', size, c, &charsWritten);
//set the attribute to current attribute
int attr = getTextAttributes();
FillConsoleOutputAttribute(hStdout, attr, size, c, &charsWritten);
//put the cursor in the upper left corner
gotoXY(0,0);
}
/**
* @brief Solver::PddlStrips::createProblemFile
* @param outFileName
*/
void Solver::PddlStrips::createProblemFile(const std::string& outFileName){
std::fstream data;
uint sizeX(gameField.getField().getSizeX());
uint sizeY(gameField.getField().getSizeY());
data.open(outFileName, std::ios::out);
data << "(define (problem modulo-strips)" << std::endl;
data << " (:domain Modulo-Strips)" << std::endl;
data << " (:objects" << std::endl;
data << " ";
for(const Tile& t: gameField.getTiles()){
data << "Tile" << t.getId() << " ";
}
data << std::endl;
for(const Tile& t: gameField.getTiles()){
data << " ";
for(uint x=0; x<t.getSizeX(); ++x){
for(uint y=0;y<t.getSizeY(); ++y){
if(t.getField(x,y))
data << "Tile" << t.getId() <<"_Pos_X" << x << "_y" << y << " ";
}
}
data << std::endl;
}
data << " ";
for(uint x=0; x<gameField.getField().getSizeX(); ++x){
for(uint y=0; y<gameField.getField().getSizeY(); ++y){
data << "Cell_X" << x << "_Y" << y << " ";
}
}
data << std::endl;
data << " )" << std::endl;
data << " (:init" << std::endl;
// Den Tiles eine Nummer geben
for(const Tile& t1: gameField.getTiles()){
data << " (isTile" << t1.getId() << " Tile" << t1.getId() << ")" << std::endl;
}
// Sagen das die Positionen eine Position haben
for(uint posX=0; posX < gameField.getField().getSizeX(); ++posX){
for(uint posY=0; posY < gameField.getField().getSizeY(); ++posY){
data << " ";
data << "(isPosition_X" << posX << "_Y" << posY;
data << " Cell_X" << posX << "_Y" << posY << ") ";
data << std::endl;
}
}
// Sagen das die Tiles unbenutzt sind
for(const Tile& t1: gameField.getTiles()){
data << " (notUsed" << " Tile" << t1.getId() << ")" << std::endl;
}
// Sagen das die Tiles Positionen unbenutzt sind
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y){
if(t.getField(x,y))
data << " (notUsed Tile" << t.getId() <<"_Pos_X" << x << "_y" << y << ")" << std::endl;
}
//Den Tile Zellen sagen wo sie sind
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y){
if(t.getField(x,y))
data << " (Tile_" << t.getId() << "_Pos_X" << x << "_Y" << y
<< " Tile" << t.getId() << "_Pos_X" << x << "_y" << y << ")" << std::endl;
}
// Den Zellen Farbe geben
for(uint x=0; x<sizeX; ++x)
for(uint y=0; y<sizeY; ++y){
data << " (hasColor" << (int)gameField.getField().getField(x,y) << " Cell_X" << x << "_Y" << y <<")" << std::endl;
}
data << " )" << std::endl;
// Zielzustand
data << " (:goal (and" << std::endl;
//1. Farbe
for(uint x=0; x<sizeX; ++x)
for(uint y=0; y<sizeY; ++y){
data << " (hasColor0 Cell_X" << x << "_Y" << y <<")" << std::endl;
}
// 2. Alle Tilezellen wurden benutzt
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y){
if(t.getField(x,y))
data << " (wasUsed Tile" << t.getId() <<"_Pos_X" << x << "_y" << y << ")" << std::endl;
}
// 3. Alle Tiles wurden benutzt
for(const Tile& t: gameField.getTiles()){
data << " (wasUsed Tile" << t.getId() << ")" << std::endl;
}
data << " ))" << std::endl;
data << ")"<< std::endl;
data.close();
}
/**
* @brief Solver::PddlStrips::createDomainFile
* @param outFileName
*/
void Solver::PddlStrips::createDomainFile(const std::string& domainFileName){
std::fstream data;
uint sizeX(gameField.getField().getSizeX());
uint sizeY(gameField.getField().getSizeY());
data.open(domainFileName, std::ios::out);
data << "(define (domain Modulo-Strips)" << std::endl;
// requirements
data << " (:requirements :strips)" << std::endl;
// Prädikate
data << " (:predicates" << std::endl;
data << " (notUsed ?t)" << std::endl;
data << " (wasUsed ?t)" << std::endl;
// Prädikate für Farben
for(uint i=0; i< gameField.getField().getMod(); ++i){
data << " (hasColor" << i << " ?c)" << std::endl;
}
// Prädikate für Tiles
for(const Tile& t: gameField.getTiles()){
data << " (isTile" << t.getId() << " ?t)" << std::endl;
}
// Prädikate für die Zellen
for(uint posX=0; posX < gameField.getField().getSizeX(); ++posX){
for(uint posY=0; posY < gameField.getField().getSizeY(); ++posY){
data << " (isPosition_X" << posX << "_Y" << posY << " ?c)" << std::endl;
}
}
/*
// Prädikate des Tiles
for(const Tile& t: gameField.getTiles())
for(uint x=0; x<t.getSizeX(); ++x)
for(uint y=0; y<t.getSizeY(); ++y){
data << " (isTilePosition_T" << t.getId() << "_X" << x << "_Y" << y << " ?t)" << std::endl;
}
*/
// Prädikate für das Starten
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
data << " (Tile_" << t.getId() << "_startAtPos_X" << fieldX << "_Y" << fieldY << " ?t)" << std::endl;
}
}
}
// Prädikate für das Starten
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < t.getSizeX(); ++fieldX){
for(uint fieldY = 0; fieldY < t.getSizeY(); ++fieldY){
data << " (Tile_" << t.getId() << "_Pos_X" << fieldX << "_Y" << fieldY << " ?tp)" << std::endl;
}
}
}
// Prädikate für Abgeschlossen
data << " (isTileUncomplete ?t)" << std::endl;
// Prädikate für Setzungen
// Tile_T_isSetTo_X_Y_Cell_X_Y
/*
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
for(uint tileX=0; tileX < t.getSizeX(); ++tileX){
for(uint tileY=0; tileY < t.getSizeY(); ++tileY){
data << " (Tile_T" << t.getId() << "_isSetTo_X" << fieldX << "_Y" << fieldY
<< "_Cell_X" << tileX << "_Y" << tileY << " ?t)" << std::endl;
}
}
}
}
}
*/
data << " )" << std::endl;
/**************
* Actions
* *************/
// 1.Action start
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
data << " (:action setTile_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY << std::endl;
// Create Parameter List
data << " :parameters (?used)" << std::endl;
// Create Precondition List
data << " :precondition (and (isTile" << t.getId() << " ?used)" << std::endl;
data << " (notUsed ?used)" << std::endl;
data << " )" << std::endl;
// Create Effect liste
data << " :effect (and (wasUsed ?used)" << std::endl;
data << " (Tile_" << t.getId() << "_startAtPos_X" << fieldX << "_Y" << fieldY <<" ?used)" << std::endl;
data << " (not (notUsed ?used))" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
// Für jede Farbe
}
}
}
/* 2. Action recolor
*/
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
for(uint tileX=0; tileX < t.getSizeX(); ++tileX){
for(uint tileY=0; tileY < t.getSizeY(); ++tileY){
for(uint color=0; color<gameField.getField().getMod()-1; ++color){
// Action
data << " (:action chanceColor" << color << "_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY
<< "_TX" << tileX << "_TY" << tileY << std::endl;
// Parameter
data << " :parameters( ?tile ?cell ?tileCell)" << std::endl;
// Precondition
// Tile
data << " :precondition (and (isTile" << t.getId() << " ?tile)" << std::endl;
data << " (Tile_" << t.getId() << "_startAtPos_X" << fieldX << "_Y" << fieldY << " ?tile)" << std::endl;
// Cell
data << " (isPosition_X" << tileX + fieldX << "_Y" << fieldY + tileY << " ?cell)" << std::endl;
data << " (hasColor" << color << " ?cell)" << std::endl;
// TileCell
// Tile_1_Pos_X0_Y0
data << " (Tile_" << t.getId() << "_Pos_X" << tileX << "_Y" << tileY << " ?tileCell)" << std::endl;
data << " (notUsed ?tileCell)" << std::endl;
data << " )" << std::endl;
// Effect
data << " :effect (and (not (notUsed ?tileCell))" << std::endl;
data << " (wasUsed ?tileCell)" << std::endl;
data << " (not (hasColor" << color << " ?cell))" << std::endl;
data << " (hasColor" << color +1 << " ?cell)" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
}
}
}
}
}
}
/* 3. Action recolor von n-1 auf 0
*/
uint color = gameField.getField().getMod()-1;
for(const Tile& t: gameField.getTiles()){
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
for(uint tileX=0; tileX < t.getSizeX(); ++tileX){
for(uint tileY=0; tileY < t.getSizeY(); ++tileY){
// Action
data << " (:action chanceColor" << color << "_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY
<< "_TX" << tileX << "_TY" << tileY << std::endl;
// Parameter
data << " :parameters( ?tile ?cell ?tileCell)" << std::endl;
// Precondition
// Tile
data << " :precondition (and (isTile" << t.getId() << " ?tile)" << std::endl;
data << " (Tile_" << t.getId() << "_startAtPos_X" << fieldX << "_Y" << fieldY << " ?tile)" << std::endl;
// Cell
data << " (isPosition_X" << tileX + fieldX << "_Y" << fieldY + tileY << " ?cell)" << std::endl;
data << " (hasColor" << color << " ?cell)" << std::endl;
// TileCell
// Tile_1_Pos_X0_Y0
data << " (Tile_" << t.getId() << "_Pos_X" << tileX << "_Y" << tileY << " ?tileCell)" << std::endl;
data << " (notUsed ?tileCell)" << std::endl;
data << " )" << std::endl;
// Effect
data << " :effect (and (not (notUsed ?tileCell))" << std::endl;
data << " (wasUsed ?tileCell)" << std::endl;
data << " (not (hasColor" << color << " ?cell))" << std::endl;
data << " (hasColor" << 0 << " ?cell)" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
}
}
}
}
}
data << ")" << std::endl;
data.close();
}
void Solver::toSatDebug::createDimacs(const std::string& fileName){
// Exactly One
uint sizeX(gameField.getField().getSizeX());
uint sizeY(gameField.getField().getSizeY());
for(const Tile& t: gameField.getTiles()){
std::set<PosInt> buffer;
for(uint x=0; x<=sizeX - t.getSizeX(); ++x){
for(uint y=0; y<=sizeY - t.getSizeY(); ++y){
buffer.insert(PosInt(x,y,t.getId()));
}
}
getExactlyOne(buffer);
}
// Modulo Contraint
for(uint fieldX = 0; fieldX < sizeX; ++fieldX){
for(uint fieldY = 0; fieldY < sizeY; ++fieldY){
std::vector<Solver::literal> bufferForVar;
for(const Tile& t: gameField.getTiles()){
// Variablen in Buffer Set schreiben
std::multiset<Solver::literal> bufferOr;
for(uint tileX=0; tileX <= fieldX; ++tileX){
if(tileX + t.getSizeX() > sizeX) break;
for(uint tileY=0; tileY<=fieldY; ++tileY){
if(tileY + t.getSizeY() > sizeY) break;
if(t.getField( fieldX - tileX, fieldY - tileY)){
Solver::literal lit;
lit.positiv = true;
lit.varId = varToInt[PosInt(tileX, tileY, t.getId())];
bufferOr.insert(lit);
}
}
}
Solver::literal lit;
lit.varId =createTseitinOr(bufferOr); lit.positiv = true;
bufferForVar.push_back(lit);
// Set start value
}
if(gameField.getField().getField(fieldX,fieldY) != 0){
for(int i=0; i <gameField.getField().getField(fieldX,fieldY); ++i ){
std::cout << "Add: (" << fieldX << ", " << fieldY << ") " << i << " " << (int)gameField.getField().getField(fieldX, fieldY) << std::endl;
Solver::literal lit;
lit.varId =getTrueVar(); lit.positiv = true;
bufferForVar.push_back(lit);
}
}
// generierung der Ausgänge
#if COMMENTSDEBUG == 1
result << "c" << std::endl;
result << "c Decode at Position (" << fieldX << ", " << fieldY << ")" << std::endl;
result << "c" << std::endl;
#endif
createModuloNAdderHalf(bufferForVar, gameField.getField().getMod());
}
}
/**************************************************************************************************
* Debug
*
* ***********************************************************************************************/
uint fieldX = 0;
uint fieldY = 0;
std::vector<Solver::literal> bufferForVar;
for(const Tile& t: gameField.getTiles()){
// Variablen in Buffer Set schreiben
std::multiset<Solver::literal> bufferOr;
for(uint tileX=0; tileX <= fieldX; ++tileX){
if(tileX + t.getSizeX() > sizeX) break;
for(uint tileY=0; tileY<=fieldY; ++tileY){
if(tileY + t.getSizeY() > sizeY) break;
if(t.getField( fieldX - tileX, fieldY - tileY)){
Solver::literal lit;
lit.positiv = true;
lit.varId = varToInt[PosInt(tileX, tileY, t.getId())];
bufferOr.insert(lit);
}
}
}
Solver::literal lit;
lit.varId =createTseitinOr(bufferOr); lit.positiv = true;
bufferForVar.push_back(lit);
// Set start value
}
if(gameField.getField().getField(fieldX,fieldY) != 0){
for(int i=0; i <gameField.getField().getField(fieldX,fieldY); ++i ){
std::cout << "Add: (" << fieldX << ", " << fieldY << ") " << i << " " << (int)gameField.getField().getField(fieldX, fieldY) << std::endl;
Solver::literal lit;
lit.varId =getTrueVar(); lit.positiv = true;
bufferForVar.push_back(lit);
}
}
// generierung der Ausgänge
#if COMMENTSDEBUG == 1
result << "c" << std::endl;
result << "c Decode at Position (" << fieldX << ", " << fieldY << ")" << std::endl;
result << "c" << std::endl;
#endif
createModuloNAdderHalf(bufferForVar, gameField.getField().getMod());
//*/
// write it into file
std::fstream data;
data.open(fileName, std::ios::out);
data << "p cnf " << countVars << " " << countClausel << std::endl;
data << result.str().c_str();
data.close();
}
double Space::getLocalX(double physicalX) const {
return convertSpace(physicalX, 0, physicalWidth, minX, sizeX());
}
void FOV::draw( QPainter &p, float zoomFactor ) {
p.setPen( QColor( color() ) );
p.setBrush( Qt::NoBrush );
p.setRenderHint( QPainter::Antialiasing, Options::useAntialias() );
float pixelSizeX = sizeX() * zoomFactor / 57.3 / 60.0;
float pixelSizeY = sizeY() * zoomFactor / 57.3 / 60.0;
float offsetXPixelSize = offsetX() * zoomFactor / 57.3 / 60.0;
float offsetYPixelSize = offsetY() * zoomFactor / 57.3 / 60.0;
p.save();
p.translate(p.viewport().center());
p.translate(offsetXPixelSize, offsetYPixelSize);
p.rotate(rotation());
QPointF center(0,0);
switch ( shape() )
{
case SQUARE:
p.drawRect( center.x() - pixelSizeX/2, center.y() - pixelSizeY/2, pixelSizeX, pixelSizeY);
break;
case CIRCLE:
p.drawEllipse( center, pixelSizeX/2, pixelSizeY/2 );
break;
case CROSSHAIRS:
//Draw radial lines
p.drawLine(center.x() + 0.5*pixelSizeX, center.y(),
center.x() + 1.5*pixelSizeX, center.y());
p.drawLine(center.x() - 0.5*pixelSizeX, center.y(),
center.x() - 1.5*pixelSizeX, center.y());
p.drawLine(center.x(), center.y() + 0.5*pixelSizeY,
center.x(), center.y() + 1.5*pixelSizeY);
p.drawLine(center.x(), center.y() - 0.5*pixelSizeY,
center.x(), center.y() - 1.5*pixelSizeY);
//Draw circles at 0.5 & 1 degrees
p.drawEllipse( center, 0.5 * pixelSizeX, 0.5 * pixelSizeY);
p.drawEllipse( center, pixelSizeX, pixelSizeY);
break;
case BULLSEYE:
p.drawEllipse(center, 0.5 * pixelSizeX, 0.5 * pixelSizeY);
p.drawEllipse(center, 2.0 * pixelSizeX, 2.0 * pixelSizeY);
p.drawEllipse(center, 4.0 * pixelSizeX, 4.0 * pixelSizeY);
break;
case SOLIDCIRCLE: {
QColor colorAlpha = color();
colorAlpha.setAlpha(127);
p.setBrush( QBrush( colorAlpha ) );
p.drawEllipse(center, pixelSizeX/2, pixelSizeY/2 );
p.setBrush(Qt::NoBrush);
break;
}
default: ;
}
p.restore();
}
/**
* @brief Solver::PddlStripsConst::createDomainFile
* @param outFileName
*/
void Solver::PddlStripsConst::createDomainFile(const std::string& domainFileName) {
std::fstream data;
uint sizeX(gameField.getField().getSizeX());
uint sizeY(gameField.getField().getSizeY());
data.open(domainFileName, std::ios::out);
data << "(define (domain Modulo-Strips-Const)" << std::endl;
// requirements
data << " (:requirements :strips)" << std::endl;
// Prädikate
data << " (:predicates" << std::endl;
data << " (notUsed ?t)" << std::endl;
data << " (wasUsed ?t)" << std::endl;
// Prädikate für Farben
for(uint i=0; i< gameField.getField().getMod(); ++i) {
data << " (hasColor" << i << " ?c)" << std::endl;
}
// Prädikate für das Starte
for(uint fieldX = 0; fieldX < sizeX; ++fieldX) {
for(uint fieldY = 0; fieldY < sizeY; ++fieldY) {
data << " (TileStartAtPos_X" << fieldX << "_Y" << fieldY << " ?t)" << std::endl;
}
}
// Prädikate für Setzungen
// Tile_T_isSetTo_X_Y_Cell_X_Y
data << " )" << std::endl;
/************************************************
* Constants
* *********************************************/
// Gamefield Zellen
data << " (:constants" << std::endl;// Cell_X0_Y0 Cell_X0_Y1 Cell_X1_Y0 Cell_X1_Y1 Tile1)
for(uint fieldX = 0; fieldX < sizeX; ++fieldX) {
for(uint fieldY = 0; fieldY < sizeY; ++fieldY) {
data << " Cell_X" << fieldX << "_Y" << fieldY << std::endl;
}
}
// Tiles
for(const Tile& t: gameField.getTiles()) {
data << " Tile" << t.getId() << std::endl;
}
// Tile Zellen
for(const Tile& t: gameField.getTiles()) {
for(int x=0; x<t.getSizeX(); ++x)
for(int y=0; y<t.getSizeY(); ++y) {
data << " TileCell_T" << t.getId() << "_X" << x << "_Y" << y << std::endl;
}
}
data << " )" << std::endl;
/**************
* Actions
* *************/
// 1.Action start
for(const Tile& t: gameField.getTiles()) {
for(uint fieldX = 0; fieldX < sizeX; ++fieldX) {
for(uint fieldY = 0; fieldY < sizeY; ++fieldY) {
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
data << " (:action setTile_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY << std::endl;
// Create Parameter List
data << " :parameters ()" << std::endl;
// Create Precondition List
data << " :precondition (and (notUsed Tile" << t.getId() << ")" << std::endl;
data << " )" << std::endl;
// Create Effect liste
data << " :effect (and (wasUsed Tile" << t.getId() << ")" << std::endl;
data << " (TileStartAtPos_X" << fieldX << "_Y" << fieldY <<" Tile" << t.getId() <<")" << std::endl;
data << " (not (notUsed Tile" << t.getId() << "))" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
// Für jede Farbe
}
}
}
/* 2. Action recolor
*/
for(const Tile& t: gameField.getTiles()) {
for(uint fieldX = 0; fieldX < sizeX; ++fieldX) {
for(uint fieldY = 0; fieldY < sizeY; ++fieldY) {
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
for(uint tileX=0; tileX < t.getSizeX(); ++tileX) {
for(uint tileY=0; tileY < t.getSizeY(); ++tileY) {
for(uint color=0; color<gameField.getField().getMod()-1; ++color) {
// Action
data << " (:action chanceColor" << color << "_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY
<< "_TX" << tileX << "_TY" << tileY << std::endl;
// Parameter
data << " :parameters()" << std::endl;
// Precondition
// Tile
data << " :precondition (and (TileStartAtPos_X" << fieldX << "_Y" << fieldY << " Tile" << t.getId() << ")" << std::endl;
data << " (hasColor" << color << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << ")" << std::endl;
data << " (notUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << ")" << std::endl;
// TileCell
data << " )" << std::endl;
// Effect
data << " :effect (and (not (notUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << "))" << std::endl;
data << " (wasUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << ")" << std::endl;
data << " (not (hasColor" << color << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << "))" << std::endl;
data << " (hasColor" << color +1 << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << ")" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
}
}
}
}
}
}
/* 3. Action recolor von n-1 auf 0
*/
uint color = gameField.getField().getMod()-1;
for(const Tile& t: gameField.getTiles()) {
for(uint fieldX = 0; fieldX < sizeX; ++fieldX) {
for(uint fieldY = 0; fieldY < sizeY; ++fieldY) {
if(t.getSizeX() + fieldX > sizeX) break;
if(t.getSizeY() + fieldY > sizeY) break;
for(uint tileX=0; tileX < t.getSizeX(); ++tileX) {
for(uint tileY=0; tileY < t.getSizeY(); ++tileY) {
// Action
data << " (:action chanceColor" << color << "_T" << t.getId() << "_X" << fieldX << "_Y" << fieldY
<< "_TX" << tileX << "_TY" << tileY << std::endl;
// Parameter
data << " :parameters()" << std::endl;
// Precondition
// Tile
data << " :precondition (and (TileStartAtPos_X" << fieldX << "_Y" << fieldY << " Tile" << t.getId() << ")" << std::endl;
data << " (hasColor" << color << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << ")" << std::endl;
data << " (notUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << ")" << std::endl;
// TileCell
data << " )" << std::endl;
// Effect
data << " :effect (and (not (notUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << "))" << std::endl;
data << " (wasUsed TileCell_T" << t.getId() << "_X" << tileX << "_Y" << tileY << ")" << std::endl;
data << " (not (hasColor" << color << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << "))" << std::endl;
data << " (hasColor" << 0 << " Cell_X" << tileX + fieldX << "_Y" << fieldY + tileY << ")" << std::endl;
data << " )" << std::endl;
data << " )" << std::endl;
}
}
}
}
}
data << ")" << std::endl;
data.close();
}
void AffineLinearScan::_extendStack()
{
_shared.declaration(_kernel->locals, MAX_WARPS);
reportE(INFO, "Kernel " << _kernel->name << " requires " << _shared.bytes()
<< " bytes of shared memory per warp, total of "
<< MAX_WARPS * _shared.bytes() << '(' << MAX_WARPS << " warps)");
LinearScanRegisterAllocationPass::_extendStack();
reportE(DEBUG, "Writing warp local memory stack access information");
if(_shared.bytes() == 0) return;
/* warpid = (size_x * ( size_y * z + y ) + x) >> 5
* a = size_y
* b = z
* c = y
* a = mad a z c
* b = size_x
* c = x
* a = mad a b c
* a = shr a 5 (>>5 == /32)
* memPosition = memInitialPosition [ warpid * bytesPerWarp ]
*/
analysis::DataflowGraph::iterator block = _dfg().begin();
RegisterId a, b, c;
/* Use a AffineRegister temporary register of type u32 if available */
if(AffineRegister::tempRegisters.count(ir::PTXOperand::DataType::u32) != 0)
{
a = AffineRegister::tempRegisters[ir::PTXOperand::DataType::u32];
}
else
{
a = _dfg().newRegister();
}
b = _dfg().newRegister();
/* If memory size is 32 bits, can use warpPosition variable as temporary */
if(_m->addressSize() == 32)
{
c = AffineRegister::warpPosition;
}
else
{
c = _dfg().newRegister();
}
// size_y = %ntid.y
ir::PTXInstruction sizeY(ir::PTXInstruction::Mov);
sizeY.d = ir::PTXOperand(ir::PTXOperand::Register,
ir::PTXOperand::DataType::u32, a);
sizeY.a = ir::PTXOperand(ir::PTXOperand::ntid,
ir::PTXOperand::iy, ir::PTXOperand::u32);
sizeY.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, sizeY, 0);
// z = %tid.z
ir::PTXInstruction z(ir::PTXInstruction::Mov);
z.d = ir::PTXOperand(ir::PTXOperand::Register,
ir::PTXOperand::DataType::u32, b);
z.a = ir::PTXOperand(ir::PTXOperand::tid,
ir::PTXOperand::iz, ir::PTXOperand::u32);
z.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, z, 1);
// y = %tid.y
ir::PTXInstruction y(ir::PTXInstruction::Mov);
y.d = ir::PTXOperand(ir::PTXOperand::Register,
ir::PTXOperand::DataType::u32, c);
y.a = ir::PTXOperand(ir::PTXOperand::tid,
ir::PTXOperand::iy, ir::PTXOperand::u32);
y.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, y, 2);
ir::PTXInstruction mad1(ir::PTXInstruction::Mad);
mad1.d = sizeY.d;
mad1.a = sizeY.d;
mad1.b = z.d;
mad1.c = y.d;
mad1.type = ir::PTXOperand::DataType::u32;
mad1.modifier = ir::PTXInstruction::Modifier::lo;
_dfg().insert(block, mad1, 3);
// size_x = %ntid.x
ir::PTXInstruction sizeX(ir::PTXInstruction::Mov);
sizeX.d = z.d;
sizeX.a = ir::PTXOperand(ir::PTXOperand::ntid,
ir::PTXOperand::ix, ir::PTXOperand::u32);
sizeX.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, sizeX, 4);
// x = %tid.x
ir::PTXInstruction x(ir::PTXInstruction::Mov);
x.d = y.d;
x.a = ir::PTXOperand(ir::PTXOperand::tid,
ir::PTXOperand::ix, ir::PTXOperand::u32);
x.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, x, 5);
// 1) warpid = size_x * size_y
ir::PTXInstruction mad2(ir::PTXInstruction::Mad);
mad2.d = mad1.d;
mad2.a = mad1.d;
mad2.b = sizeX.d;
mad2.c = x.d;
mad2.type = ir::PTXOperand::DataType::u32;
mad2.modifier = ir::PTXInstruction::Modifier::lo;
_dfg().insert(block, mad2, 6);
// 5) warpid = [size_x * y + size_x * size_y * z + x] >> 5
ir::PTXInstruction shr(ir::PTXInstruction::Shr);
shr.d = mad2.d;
shr.a = mad2.d;
shr.b = ir::PTXOperand(5);
shr.type = ir::PTXOperand::DataType::u32;
_dfg().insert(block, shr, 7);
// 6) position = warpid * stride
ir::PTXInstruction position(ir::PTXInstruction::Mul);
position.d = shr.d;
position.a = shr.d;
position.b = ir::PTXOperand(_shared.bytes());
position.type = ir::PTXOperand::DataType::u32;
position.modifier = ir::PTXInstruction::Modifier::lo;
_dfg().insert(block, position, 8);
//%memoryStart = stack name;
ir::PTXInstruction memoryStart(ir::PTXInstruction::Mov);
memoryStart.a = ir::PTXOperand(_shared.name() +
"[" + position.d.toString() + "]");
if(_m->addressSize() == 32)
{
memoryStart.d = x.d;
memoryStart.type = ir::PTXOperand::DataType::u32;
}
else
{
memoryStart.d = ir::PTXOperand(ir::PTXOperand::Register,
ir::PTXOperand::DataType::u64, AffineRegister::warpPosition);
memoryStart.type = ir::PTXOperand::DataType::u64;
}
_dfg().insert(block, memoryStart, 9);
}
