Exemple #1
0
void Texture::bindAny()
{
    if (_boundUnit != -1) {
        markAsUsed(_boundUnit);
        selectUnit(_boundUnit);
        return;
    } else
        bind(selectVictimUnit());
}
Exemple #2
0
void Texture::bind(int unit)
{
    if (_units[unit])
        _units[unit]->_boundUnit = -1;

    markAsUsed(unit);
    selectUnit(unit);

    if (_boundUnit == unit)
        return;

    _units[unit] = this;
    glf->glBindTexture(_glType, _glName);
    _boundUnit = unit;
}
Exemple #3
0
void GameSessionInput::onFrame(float elapsedTime)
{
    Camera* cam = Root::shared().getScene()->getCamera();

    specMovement*=pow(.002f,elapsedTime);

    if(cam != 0)
    {
        cam->setTargetLocation(specPos, false);

        if( rotatingLeft && !rotatingRight )
            cam->rotateCamera(90.0f * elapsedTime, 0.0f);
        else if( rotatingRight && !rotatingLeft )
            cam->rotateCamera(-90.0f * elapsedTime, 0.0f);

        vec3 force = forceDirection;
        force = glm::rotateY(force, cam->getYaw());
        float speedFactor = 4000.0f;
        if(slowMode) speedFactor *= 0.125f;
		float zoomSpeedFactor = cam->getZoom()/300.0f;
        specMovement += force * speedFactor * zoomSpeedFactor * elapsedTime;
    }

    specPos += specMovement * elapsedTime;

    if(unitMovementNextFrame)
        moveSelectedUnits();
    unitMovementNextFrame = false;

    if(unitSelectionNextFrame)
        selectUnit();
    unitSelectionNextFrame = false;

    if(buildingPlacementNextFrame)
        placeBuilding();
    buildingPlacementNextFrame = false;

    return;
}
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();







}

}
Exemple #5
0
bool Game::init() {
  if (!terrain.loadFromFile("graphics/terrain.png")) {
    std::cout << "Failed to read graphics/terrain.png data" << std::endl;
    return false;
  }

  sf::Image temp;
  if (!temp.loadFromFile("graphics/shroud_edges.bmp")) {
    std::cout << "Failed to read graphics/shroud_edges.bmp data" << std::endl;
    return false;
  }

  temp.createMaskFromColor(sf::Color(255, 0, 255));
  shroudEdges.loadFromImage(temp);

  map.reset(new Map(terrain, shroudEdges, messages));
  map->load("maps/4PL_Mountains.ini");

  camera.reset({0,0,800,600});
  screen.setView(camera);

  //init two players
  int idCount = 0;
  players.emplace_back(House::Sardaukar, idCount++);
  players.emplace_back(House::Harkonnen, idCount++);

  messages.triggerEvent(CreateUnitMessage(Unit::Type::Trike     , players[0], {256, 256}));
  messages.triggerEvent(CreateUnitMessage(Unit::Type::Quad      , players[1], {300, 300}));
  messages.triggerEvent(CreateUnitMessage(Unit::Type::Soldier   , players[0], {400, 500}));
  messages.triggerEvent(CreateUnitMessage(Unit::Type::Soldier   , players[0], {220, 500}));
  messages.triggerEvent(CreateUnitMessage(Unit::Type::Devastator, players[1], {500, 200}));

  //register listeners
  typedef thor::ActionContext<std::string> actionContext;

  actions.connect("close", [this](actionContext){playing = false;});

  actions.connect("boxRelease", [this](actionContext){
    for (auto& unit : units){
      if (box.intersects(unit.getBounds())){
        selectUnit(unit);
      }
    }
    box.clear();
  });

  actions.connect("boxStart", [this](actionContext context) {
    if (mouse.getType() != Mouse::Type::Default) {
      return;
    }
    sf::Vector2f toSet = screen.mapPixelToCoords(mouse.getHotspot(*context.event), camera);
    box.setTopLeft(toSet);
  });

  actions.connect("singleSelect", [this](actionContext context){
    sf::Vector2f toCheck = screen.mapPixelToCoords(mouse.getHotspot(*context.event), camera);
    for (auto& unit : units){
      if (unit.getBounds().contains(toCheck))
        selectUnit(unit);
    }
  });

  actions.connect("deselectAll", [this](actionContext){
    actions.disconnect("orderMove");
    mouse.setType(Mouse::Type::Default);
    for (auto& unit : units)
      unit.unselect();
  });

  actions.connect("boxDrag", [this](actionContext){
    box.setBottomRight(screen.mapPixelToCoords(sf::Mouse::getPosition(screen), camera));
  });

  const float cameraSpeed = 15.f;

  actions.connect("cameraLeft", [this, cameraSpeed](actionContext) {camera.move(-cameraSpeed, 0.f);});
  actions.connect("cameraRight", [this, cameraSpeed](actionContext){camera.move(cameraSpeed, 0.f); });
  actions.connect("cameraUp", [this, cameraSpeed](actionContext)   {camera.move(0.f, -cameraSpeed);});
  actions.connect("cameraDown", [this, cameraSpeed](actionContext) {camera.move(0.f, cameraSpeed); });

  actions.connect("toggleConsole", std::bind(&Console::toggle, &console));

  return true;
}