Automaton build(int lo, int hi) {
int firstClose = -1;
int level = 0;
for (int i = lo; i <= hi; ++i) {
if (isOpen(i)) ++level;
if (isClose(i)) --level;
if (isClose(i) && firstClose == -1 && level == 0) firstClose = i;
if (isOr(i) && level == 0)
return autoOr(build(lo, i - 1), build(i + 1, hi));
}
int mid = lo+1;
if (isOpen(lo)) mid = firstClose + 1;
bool star = false;
if (mid <= hi && isStar(mid)) {
++mid;
star = true;
}
Automaton A = isOpen(lo) ? build(lo + 1, firstClose - 1) : autoChar(regex[lo]);
if (star) A = autoStar(A);
if (mid > hi) return A;
return autoSeq(A, build(mid, hi));
}
void PolyDDV::computeHull(PolyDDV& ddv)
{
if (ddv.getSize() != _types.size())
return;
int i;
for (i = 0; i < ddv.getSize(); ++i)
{
if (ddv.isPlus(i))
{
if (isEq(i) || isScalar(i))
setPlus(i);
else if (isMinus(i))
setStar(i);
}
else if (ddv.isMinus(i))
{
if (isEq(i) || isScalar(i))
setMinus(i);
else if (isPlus(i))
setStar(i);
}
else if (ddv.isStar(i))
setStar(i);
else if (ddv.isScalar(i) && ! isStar(i))
{
int s1 = ddv.getScalar(i);
if (isScalar(i) || isEq(i))
{
int s2 = 0;
if (isScalar(i))
s2 = getScalar(i);
if (s1 > 0 && s2 < 0 || s1 < 0 && s2 > 0)
setStar(i);
else if (s1 > 0 && s1 != s2)
setPlus(i);
else if (s1 < 0 && s1 != s2)
setMinus(i);
}
else
{
if (s1 > 0 && isMinus(i) || s1 < 0 && isPlus(i))
setStar(i);
}
}
}
}
void ExportAsciiDialog::createEnglishAscii(){
QFont f("Consolas,Courier,monospace", 8);
m_ui->asciiTextEdit->setFont(f);
QByteArray s;
s.reserve(boardBuffer.size() + 2 * boardBuffer[0].size() * 3);
s.append(" ");
for (int i=0; i<boardBuffer[0].size(); ++i){
s.push_back(' ');
s.push_back( 'A' + (i > 7 ? i+1 : i) );
}
s.push_back('\n');
for (int y=0; y<boardBuffer.size(); ++y){
s.append( QString("%1").arg(boardBuffer.size() - y, 2) );
for (int x=0; x<boardBuffer[y].size(); ++x){
if (boardBuffer[y][x].black())
s.append(" #");
else if (boardBuffer[y][x].white())
s.append(" O");
else if (isStar(x, y))
s.append(" +");
else
s.append(" .");
}
s.append( QString(" %1\n").arg(boardBuffer.size() - y, 2) );
}
s.append(" ");
for (int i=0; i<boardBuffer[0].size(); ++i){
s.push_back(' ');
s.push_back( 'A' + (i > 7 ? i+1 : i) );
}
m_ui->asciiTextEdit->setPlainText(s);
}
bool PolyDDV::isIdenticalVector(PolyDDV& ddv)
{
if (ddv.getSize() != _types.size())
return false;
int i;
for (i = 0; i < ddv.getSize(); ++i)
{
if (ddv.isPlus(i) && ! isPlus(i))
return false;
else if (ddv.isMinus(i) && ! isMinus(i))
return false;
else if (ddv.isStar(i) && ! isStar(i))
return false;
else if (ddv.isEq(i) && ! isEq(i))
return false;
else if (ddv.isScalar(i))
{
if (! isScalar(i) || getScalar(i) != ddv.getScalar(i))
return false;
}
}
return true;
}
NABoolean ColRefName::operator==(const ColRefName& other) const
{
return (isStar() == other.isStar() &&
getColName() == other.getColName() &&
getCorrNameObj().isEqualWithPartnClauseSkipped(other.getCorrNameObj()));
}
void ExportAsciiDialog::createJapaneseAscii(bool isMono){
#ifdef Q_WS_WIN
const char* monospace = "\xef\xbc\xad\xef\xbc\xb3\x20\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf"; // ms gothic
const char* propotional = "\xef\xbc\xad\xef\xbc\xb3\x20\xef\xbc\xb0\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf"; // ms p-gothic
#elif defined(Q_WS_MAC)
const char* monospace = "Osaka\342\210\222\347\255\211\345\271\205"; // Osaka-tohaba
const char* propotional = "Osaka"; // Osaka
#else
const char* monospace = "monospace";
const char* propotional = "Takao Pゴシック";
#endif
QFont f(isMono ? monospace : propotional, 8);
m_ui->asciiTextEdit->setFont(f);
qDebug() << f.family();
QByteArray s;
s.reserve(boardBuffer.size() + 2 * boardBuffer[0].size() * 3);
const char* top[] = {"\xe2\x94\x8f","\xe2\x94\xaf","\xe2\x94\x93"};
const char* center[] = {"\xe2\x94\xa0","\xe2\x94\xbc","\xe2\x94\xa8"};
const char* bottom[] = {"\xe2\x94\x97","\xe2\x94\xb7","\xe2\x94\x9b"};
const char* header[] = {"\xef\xbc\xa1","\xef\xbc\xa2","\xef\xbc\xa3","\xef\xbc\xa4","\xef\xbc\xa5","\xef\xbc\xa6","\xef\xbc\xa7","\xef\xbc\xa8","\xef\xbc\xaa","\xef\xbc\xab","\xef\xbc\xac","\xef\xbc\xad","\xef\xbc\xae","\xef\xbc\xaf","\xef\xbc\xb0","\xef\xbc\xb1","\xef\xbc\xb2","\xef\xbc\xb3","\xef\xbc\xb4","\xef\xbc\xb5","\xef\xbc\xb6","\xef\xbc\xb7","\xef\xbc\xb8","\xef\xbc\xb9","\xef\xbc\xba"};
int headerNum = sizeof(header)/sizeof(header[0]);
// 2byte space
if (isMono)
s.append("\xe3\x80\x80");
else
s.append("\xef\xbc\xbf");
for (int i=0, j=0; i<boardBuffer[0].size(); ++i, ++j){
if (j >= headerNum)
j = 0;
s.push_back( header[j] );
if (isMono == false && j != 12 && j != 16)
s.push_back(' ');
}
s.push_back('\n');
for (int y=0; y<boardBuffer.size(); ++y){
if (isMono)
s.append( QString().sprintf("%2d", boardBuffer.size() - y) );
else
s.append( QString().sprintf("%02d", boardBuffer.size() - y) );
const char** b = y == 0 ? top : y == boardBuffer.size() - 1 ? bottom : center;
for (int x=0; x<boardBuffer[y].size(); ++x){
if (boardBuffer[y][x].black())
s.append("\xe2\x97\x8f");
else if (boardBuffer[y][x].white())
s.append("\xe2\x97\x8b");
else{
if (x == 0)
s.append(b[0]);
else if (x == boardBuffer[y].size() - 1)
s.append(b[2]);
else if (isStar(x, y))
s.append("\xe2\x95\x8b");
else
s.append(b[1]);
}
}
if (isMono)
s.append( QString().sprintf("%2d\n", boardBuffer.size() - y) );
else
s.append( QString().sprintf("%02d\n", boardBuffer.size() - y) );
}
// 2byte space
if (isMono)
s.append("\xe3\x80\x80");
else
s.append("\xef\xbc\xbf");
for (int i=0, j=0; i<boardBuffer[0].size(); ++i, ++j){
if (j >= headerNum)
j = 0;
s.push_back( header[j] );
if (isMono == false && j != 12 && j != 16)
s.push_back(' ');
}
m_ui->asciiTextEdit->setPlainText(s);
}
void game::movePiece(int relative_piece){
int fixed_piece = rel_to_fixed(relative_piece); //index of the piece in player_positions
int modifier = color * 13;
int relative_pos = player_positions[fixed_piece];
int target_pos = 0;
if(player_positions[fixed_piece] == -1){ //if the selected piece is in the safe house, try to move it to start
move_start(fixed_piece);
} else {
//convert to relative position
if(relative_pos == 99){
std::cout << "I tought this would be it ";
}else if(relative_pos == 51 && color != 0){
int tmp_abs = relative_pos - 52;
relative_pos = (tmp_abs - modifier); //Alien attack prevention
}else if(relative_pos < modifier) {
relative_pos = relative_pos + 52 - modifier;
} else if( relative_pos > 50) {
relative_pos = relative_pos - color * 5 - 1;
} else {//if(relative >= modifier)
relative_pos = relative_pos - modifier;
}
if(DEBUG) std::cout << "color: " << color << " pos: " << relative_pos << " + " << dice_result << " = " << relative_pos + dice_result;
//add dice roll
relative_pos += dice_result; //this is relative position of the selected token + the dice number
int jump = isStar(relative_pos); //return 0 | 6 | 7
if(jump){
if(jump + relative_pos == 57){
relative_pos = 56;
} else {
relative_pos += jump;
}
}
//special case checks
if(relative_pos > 56 && relative_pos < 72){ // go back
target_pos = 56-(relative_pos-56) + color * 5 + 1; //If the player moves over the goal, it should move backwards
}else if(relative_pos == 56 || relative_pos >= 99){
target_pos = 99;
}else if(relative_pos > 50){ // goal stretch
target_pos = relative_pos + color * 5 + 1;
} else {
int new_pos = relative_pos + color * 13;
if(new_pos < 52){
target_pos = new_pos;
} else { //wrap around
target_pos = new_pos - 52; //this is the global position wrap around at the green entry point
}
}
//check for game stuff
if(isOccupied(target_pos)){
if(isGlobe(target_pos)){
target_pos = -1; //send me home
} else {
send_them_home(target_pos);
}
}
if(DEBUG) std::cout << " => " << target_pos << std::endl;
player_positions[fixed_piece] = target_pos;
}
std::vector<int> new_relative = relativePosition();
switch(color){
case 0:
emit player1_end(new_relative);
break;
case 1:
emit player2_end(new_relative);
break;
case 2:
emit player3_end(new_relative);
break;
case 3:
emit player4_end(new_relative);
default:
break;
}
emit update_graphics(player_positions);
}
// Do actually the computation
set<Assignment> SPGParser::computeReductible(int i, int j)
{
set<Assignment> as;
// Base case
if(i == j && isType(i))
{
if(isUnit(i))
as.insert(Assignment::singleton(headType[i]));
return as;
}
if(j == i+1)
{
if(isType(i) && isType(j) && gcon(i,j))
{
as.insert(Assignment::singleton(headType[i]));
// we could add j but headType[i] == headType[j] so it's no use
}
return as;
}
if(isType(i) && isType(j) &&
isStar(i+1) &&
isStar(j-1) &&
widx[j] == widx[i]+1 &&
gcon(i,j))
{
Assignment a = Assignment::singleton(headType[i]);
a.insert(headType[j]);
as.insert(a);
return as;
}
if(isType(i) && isType(j))
{
// A1a
for(int k = i+1; k < j-1; k++)
if(isType(k) && reductible(i,k) && reductible(k+1,j))
as = as + product(assignments[i][k], assignments[k+1][j]);
// A1b
for(int k = i+1; k < j-1; k++)
if(isRB(k) && isLB(k+1) && reductible(i,k) && reductible(k+1,j))
as = as + product(assignments[i][k], assignments[k+1][j]);
// A2
if(gcon(i,j) && reductible(i+1,j-1))
{
set<Assignment> a = assignments[i+1][j-1];
Assignment rhs;
rhs.insert(headType[i]);
rhs.insert(headType[j]);
set<Assignment> b;
b.insert(rhs);
as = as + product(a, b);
}
}
// A3a
if(isLB(i) && isType(j))
{
for(int k = i+1; k < j && widx[k] == widx[i]; k++)
if(isStar(k) && reductible(k+1, j))
as = as + assignments[k+1][j];
}
// A3b
if(isRB(j) && isType(i))
{
for(int k = j-1; k > i && widx[k] == widx[j]; k--)
if(isStar(k) && reductible(i,k-1))
as = as + assignments[i][k-1];
}
// A4a
if(isType(i) && isType(j) && isStar(i+1) && gcon(i,j)
&& widx[i] != widx[j])
{
for(int k = i+1; k < j && widx[k] == widx[i]; k++)
if(isLB(k+1) && reductible(k+1,j-1))
as = as + assignments[k+1][j-1];
}
// A4b
if(isType(i) && isType(j) && isStar(j-1) && gcon(i,j)
&& widx[i] != widx[j])
{
for(int k = j-1; k > i && widx[k] == widx[j]; k--)
if(isRB(k-1) && reductible(i+1,k-1))
as = as + assignments[i+1][k-1];
}
// A4c
if(isType(i) && isType(j) &&
isStar(i+1) && isStar(j-1) &&
1 + widx[i] < widx[j] &&
gcon(i,j))
{
int k1, k2;
for(k1 = i+1; k1 < j && !isRB(k1); k1++);
for(k2 = j-1; k2 > i && !isLB(k2); k2--);
if(reductible(k1,k2))
as = as + assignments[k1][k2];
}
// A5
if(isLB(i) && isRB(j))
{
float totalProb = 0;
for(int k1 = i+1; k1 < j && !isRB(k1); k1++)
{
if(isType(k1) && isStar(k1-1))
{
for(int k2 = j-2; k2 > i && !isLB(k2); k2--)
{
if(isType(k2) && isStar(k2+1) && reductible(k1,k2))
as = as + assignments[k1][k2];
}
}
}
}
return as;
}
