static void
load_oobp (SNAP_OOB_PEL *src, SPWAW_SNAP_OOB_PELRAW *dst, STRTAB * /*stab*/)
{
memset (dst, 0, sizeof (SPWAW_SNAP_OOB_PELRAW));
getOP (RID); getOP (URID); getOP (x); getOP (y); getOP (seen);
}
//!------------------------------------------
treeElem_t * getSkob()
{
assert(Lexems.data);
assert(cnt_lex <= Lexems.cnt);
if (Lexems.data[cnt_lex].oper[0] == '{')
{
cnt_lex++;
printf("{ is spotted!\n");
printf("before 1st getOP (%d): (%s)\n", cnt_lex, Lexems.data[cnt_lex].oper);
treeElem_t * tree = getOP();
ASSERT_OK(tree);
printf("after 1st getOp: (%s)\n", Lexems.data[cnt_lex].oper);
if (Lexems.data[cnt_lex].oper[0] == '}')
{
printf("} is spotted!\n");
cnt_lex++;
return tree;
}
else
{
printf("ERROR! } is missing!\n");
printf("(%s)\n", Lexems.data[cnt_lex].oper);
exit(11);
}
}
else
return getRav();
}
//!------------------------------------------
treeElem_t * getOP()
{
assert(Lexems.data);
assert(cnt_lex <= Lexems.cnt);
treeElem_t * theOP = ctor(0, NULL, OP, getSkob(), NULL);
SLASHES printf("theOP cnt_lex = %d\n", cnt_lex);
while (Lexems.data[cnt_lex].oper[0] != '\0')
{
treeElem_t * nextOP = getOP();
theOP->right = nextOP;
}
return theOP;
}
//!------------------------------------------
void processTask()
{
FILE * input = NULL;
input = formBuffer(input);
FILE * lex_dump = openFile("lex_dump.txt");
initiateLexemsArr();
formLexems();
dumpLexems(lex_dump);
EMPT SLASHES
puts(buffer);
SLASHES EMPT
treeElem_t * tree = getOP();
ASSERT_OK(tree);
if (Lexems.data[cnt_lex].oper[0] != '\0')
{
printf("SYNTAX ERROR! RECOMPILE YOUR GOPNIK PROG!\n");
printf("cnt_lex = %d\n");
printf("(%s)\n", Lexems.data[cnt_lex].oper);
}
SLASHES printf("Amount of nodes - (%d)\n", node_amount);
FILE *output = openFile("commands.txt");
FILE *dump = openFile("dump.txt");
FILE *viewTree = openFile("tree.txt");
dumpTree(tree, NODEBUG, BEGIN, stdout);
dumpTree(tree, DEBUG, BEGIN, dump);
printNode(tree, output);
FinishWork(input, output, dump, viewTree, lex_dump, buffer, tree);
}
llvm::Value* minipascal::NBinaryOperator::codeGen(CodeGenContext* context)
{
std::cout << "Generating code for " << getOutput() << std::endl;
llvm::Value* L = getLeft()->codeGen(context);
llvm::Value* R = getRight()->codeGen(context);
if(L == NULL || R == NULL) return NULL;
switch(getOP()) {
case minipascal::NBinaryOperator::ADD:
case minipascal::NBinaryOperator::SUB:
case minipascal::NBinaryOperator::MUL:
case minipascal::NBinaryOperator::DIV:
setType(getLeft()->getType());
break;
case minipascal::NBinaryOperator::GT:
case minipascal::NBinaryOperator::GE:
case minipascal::NBinaryOperator::LT:
case minipascal::NBinaryOperator::LE:
case minipascal::NBinaryOperator::EQ:
case minipascal::NBinaryOperator::NE:
setType(new minipascal::BooleanType());
break;
}
// type check
if(!(getLeft()->getFail()))
{
if(!(getLeft()->getType()->compare(getRight()->getType())))
{
showError("Cannot do binary operation");
setFail(true);
context->fail = true;
return NULL;
}
}
std::string name = getStoreReg();
minipascal::IntType temp;
// for integer binary operation
if(getLeft()->getType()->compare(&temp))
{
switch(getOP()){
case minipascal::NBinaryOperator::ADD:
return context->builder->CreateAdd(L, R, name.c_str());
case minipascal::NBinaryOperator::SUB:
return context->builder->CreateSub(L, R, name.c_str());
case minipascal::NBinaryOperator::MUL:
return context->builder->CreateMul(L, R, name.c_str());
case minipascal::NBinaryOperator::DIV:
return context->builder->CreateSDiv(L, R, name.c_str());
case minipascal::NBinaryOperator::LE:
return context->builder->CreateICmpSLE(L, R, name.c_str());
case minipascal::NBinaryOperator::LT:
return context->builder->CreateICmpSLT(L, R, name.c_str());
case minipascal::NBinaryOperator::EQ:
return context->builder->CreateICmpEQ(L, R, name.c_str());
case minipascal::NBinaryOperator::NE:
return context->builder->CreateICmpNE(L, R, name.c_str());
case minipascal::NBinaryOperator::GE:
return context->builder->CreateICmpSGE(L, R, name.c_str());
case minipascal::NBinaryOperator::GT:
return context->builder->CreateICmpSGT(L, R, name.c_str());
}
}
else // for real binary operation
{
switch(getOP()){
case minipascal::NBinaryOperator::ADD:
return context->builder->CreateFAdd(L, R, name.c_str());
case minipascal::NBinaryOperator::SUB:
return context->builder->CreateFSub(L, R, name.c_str());
case minipascal::NBinaryOperator::MUL:
return context->builder->CreateFMul(L, R, name.c_str());
case minipascal::NBinaryOperator::DIV:
return context->builder->CreateFDiv(L, R, name.c_str());
case minipascal::NBinaryOperator::LE:
return context->builder->CreateFCmpOLE(L, R, name.c_str());
case minipascal::NBinaryOperator::LT:
return context->builder->CreateFCmpOLT(L, R, name.c_str());
case minipascal::NBinaryOperator::EQ:
return context->builder->CreateFCmpOEQ(L, R, name.c_str());
case minipascal::NBinaryOperator::NE:
return context->builder->CreateFCmpONE(L, R, name.c_str());
case minipascal::NBinaryOperator::GE:
return context->builder->CreateFCmpOGE(L, R, name.c_str());
case minipascal::NBinaryOperator::GT:
return context->builder->CreateFCmpOGT(L, R, name.c_str());
}
}
}
void overmind(gameMap_t * self,
sf::RenderWindow & window,
selection_t * cUnit,sf::Sprite & aCell,
sf::Sprite & aEnemy,
cursor_t * gCur,
sf::Sprite & gameBackground,
sf::Sprite & gameInterface,
sf::Sprite & gameMenu,
sf::Sprite & gameEndTurn,
int player,
sf::Sprite & cTc,
player_t*pl,
sf::Sprite & cBc){
resources_t r;
r.count = 0;
r.optimal = 0;
int tCost=200;
int bCost=150;
int ran;
if(pl->resourcesPlayer2>=bCost){
if(pl->resourcesPlayer2>=tCost){
createUnit(self,pl,1,3,window,cUnit,gameBackground,gameInterface,gameMenu,gameEndTurn,cTc,cBc);
}else{
createUnit(self,pl,1,4,window,cUnit,gameBackground,gameInterface,gameMenu,gameEndTurn,cTc,cBc);
}
}
for(int i = 0;i<cellNumX*cellNumY;i++){
r.op[i] = NULL;
}
for(int i = 0;i<cellNumX;i++){
for(int j = 0;j<cellNumY;j++){
if(self->cell[i][j].object!=NULL&&self->cell[i][j].obj_un_null==1&&self->cell[i][j].object->type==0){
r.op[r.count] = &self->cell[i][j];
r.count++;
}
}
}
for(int i = 0;i<cellNumX;i++){
for(int j = 0;j<cellNumY;j++){
if (self->cell[i][j].unit!=NULL&&self->cell[i][j].obj_un_null==1) {
if(self->cell[i][j].unit->player == 1){
selection_t tSel;
setSelect(&self->cell[i][j],&tSel);
while(tSel.cell->unit->cPoints>0){
if(overmindAttack(self,window,&tSel,aCell,aEnemy,gCur,gameBackground,gameInterface,gameMenu,gameEndTurn,1,cTc,pl,cBc)==1){
continue;
}
if(overmindFoundResources(self,window,&tSel,aCell,aEnemy,gCur,gameBackground,gameInterface,gameMenu,gameEndTurn,1,cTc,pl,cBc,i,j,&r)==1){
continue;
}
tSel.cell->unit->cPoints-=1;
}
}
}
}
}
getOP(self,pl);
getResources(self,1,pl);
}
int OPCodes::getOPSize(string oper)
{
return getOP(oper).size;
}
int OPCodes::getOPCode(string oper)
{
return getOP(oper).opCode;
}
void gameClient(sf::RenderWindow & window,char * mapName){
int i,/*displacementX=0,displacementY=0,*/ menu=0;
gameMap_t map;
// int redrawMMAP = 1;
cursor_t gCur;
gCur.status = 0;
gCur.cell = NULL;
player_t players;
players.resourcesPlayer1 = 400;
players.resourcesPlayer2 = 400;
// player_t player2;
unsigned int currentPlayerTurn=0;
selection_t select;
select.status=0;
select.cell=NULL;
createMap(&map);
/*
Set textures.
*/
sf::Texture background, interface_image,menu1,menu2,grind,cursor,pCourse,endTurn1,endTurn2,sel,enemy,fpT,spT,cT1,cT2,cB1,cB2;
sf::Sprite gameBackground,gameInterface,gameMenu,gameGrind,gameCursor,aCell,gameEndTurn,cSel,cEnemy,cpT,cTc,cBc;
menu1.loadFromFile("gameInterface/menu.png");
fpT.loadFromFile("gameInterface/fpTurn.png");
spT.loadFromFile("gameInterface/spTurn.png");
enemy.loadFromFile("gameInterface/enemyCell.png");
sel.loadFromFile("gameInterface/selected.png");
menu2.loadFromFile("gameInterface/menuConfirmed.png");
grind.loadFromFile("maps/grind.png");
endTurn1.loadFromFile("gameInterface/endTurn.png");
endTurn2.loadFromFile("gameInterface/endTurnConfirmed.png");
cT1.loadFromFile("gameInterface/cTank.png");
cT2.loadFromFile("gameInterface/cTankC.png");
cB1.loadFromFile("gameInterface/cBuggy.png");
cB2.loadFromFile("gameInterface/cBuggyC.png");
//test
addUnit(&map,window,0,TANK,15,0);
addUnit(&map,window,0,BUGGY,12,0);
addUnit(&map,window,0,TANK,9,0);
addUnit(&map,window,1,TANK,27,18);
addUnit(&map,window,1,BUGGY,30,18);
addUnit(&map,window,1,TANK,33,18);
addObject(&map,window,0,20,12);
addObject(&map,window,0,10,10);
addObject(&map,window,0,30,8);
cpT.setPosition(130,0);
cursor.loadFromFile("gameInterface/setCell.png");
pCourse.loadFromFile("gameInterface/availableCell.png");
background.loadFromFile(mapName);
interface_image.loadFromFile("gameInterface/mainInterface.png");
gameBackground.setTexture(background);
cSel.setTexture(sel);
aCell.setTexture(pCourse);
gameGrind.setTexture(grind);
gameInterface.setTexture(interface_image);
cEnemy.setTexture(enemy);
gameCursor.setTexture(cursor);
drawMinMap(window,currentPlayerTurn,&map);
while (window.isOpen()){
cameraMouseMove(window,&map);
mouseEvents(window,&map);
menu=gameSelection(window,gameMenu,menu1,menu2,gameEndTurn,endTurn1,endTurn2,cTc,cT1,cT2,cBc,cB1,cB2);
gameBackground.setPosition(map.displacementX,map.displacementY);
gameInterface.setPosition(-1,-1);
gameMenu.setPosition(1700,0);
gameEndTurn.setPosition(1500,5);
cTc.setPosition(1680,750);
cBc.setPosition(1680,890);
selectUnit(&map,window,cSel,&select,currentPlayerTurn);
if(select.status==1){
cSel.setPosition(select.cell->X,select.cell->Y);
}
sf::Event event;
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)&&menu==1){
if(pauseMenu(window)==0){
break;
}
}
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)&&menu>=3){
createUnit(&map,&players,currentPlayerTurn,menu,window,&select,gameBackground,gameInterface,gameMenu,gameEndTurn,cTc,cBc);
}
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)&&menu==2){
isEnd(&map,window,endFn);
getOP(&map,&players);
getResources(&map,currentPlayerTurn,&players);
deleteSelect(&select);
overmind(&map,window,&select,aCell,cEnemy,&gCur,gameBackground,gameInterface,gameMenu,gameEndTurn,currentPlayerTurn,cTc,&players,cBc);
endTurn(&map);
Sleep(500);
}
if (sf::Mouse::isButtonPressed(sf::Mouse::Right)){
deleteSelect(&select);
}
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
{
window.close();
}
}
window.clear(sf::Color::Black);
window.draw(gameBackground);
drawUnits(&map,window);
if(cursorConfirm(window,&map,gameCursor,&gCur)==1){
window.draw(gameCursor);
}
if(select.status==1){
window.draw(cSel);
findWay(&map,window,&select,aCell,cEnemy,&gCur,gameBackground,gameInterface,gameMenu,gameEndTurn,currentPlayerTurn,cTc,&players,cBc);
}
window.draw(gameInterface);
if(select.status==1){
pData(window,&select);
}
window.draw(gameMenu);
window.draw(gameEndTurn);
drawMinMap(window,currentPlayerTurn,&map);
drawPlayer(window,currentPlayerTurn,&players);
window.draw(cTc);
window.draw(cBc);
window.display();
}
}
