void Viewport::setZoomLevel(const types::Point& pos, int level)
{
if (m_zoomLevel == level)
return;
Point oldPos = pos / m_zoomFactor;
m_zoomLevel = level;
m_zoomFactor = (100 - m_zoomLevel) / 100.f;
moveView(pos / m_zoomFactor - oldPos);
}
void Viewport::setZoom(const types::Point& pos, float factor)
{
if (m_zoomFactor == factor)
return;
Point oldPos = pos / m_zoomFactor;
m_zoomFactor = factor;
m_zoomLevel = static_cast<int>(100.0 * (1.f - m_zoomFactor));
moveView(pos / m_zoomFactor - oldPos);
}
void Viewport::showAll()
{
if(!m_objectsRect.empty())
{
float factorW = m_viewSize.x / (m_objectsRect.width() + 40);
float factorH = m_viewSize.y / (m_objectsRect.height() + 40);
m_zoomFactor = helper::bound(0.1f, std::min(factorW, factorH), 1.0f);
m_zoomLevel = static_cast<int>(100 * (1.f - m_zoomFactor));
moveView(m_viewSize / 2 / m_zoomFactor - m_objectsRect.center() + m_viewDelta);
}
}
void Viewport::zoomReset()
{
if(m_zoomLevel != 1)
{
const auto center = m_viewSize / 2;
auto oldPos = center / m_zoomFactor;
m_zoomLevel = 1;
m_zoomFactor = 1.f;
moveView(center / m_zoomFactor - oldPos);
}
}
void Viewport::zoomOut()
{
if(m_zoomLevel < 90)
{
const auto center = m_viewSize / 2;
auto oldPos = center / m_zoomFactor;
m_zoomLevel = std::min(m_zoomLevel + 10, 90);
m_zoomFactor = (100 - m_zoomLevel) / 100.f;
moveView(center / m_zoomFactor - oldPos);
}
}
void Viewport::zoomIn()
{
if(m_zoomLevel > 0)
{
const auto center = m_viewSize / 2;
auto oldPos = center / m_zoomFactor;
m_zoomLevel = std::max(m_zoomLevel - 10, 0);
m_zoomFactor = (100 - m_zoomLevel) / 100.f;
moveView(center / m_zoomFactor - oldPos);
}
}
void
ZoomWidget::centerView( const QPointF & pmap )
{
QPointF pwin, pctr;
// current WIN position of the point to be centered
pwin = pmap * wm_;
pctr = QPointF( width()/2.0, height()/2.0 );
moveView( pctr - pwin );
// current center of the window (in WIN cs)
}
static void updateSubviewsGeom(WMSplitView * sPtr)
{
int i, count;
W_SplitViewSubview *p;
count = _GetSubviewsCount();
for (i = 0; i < count; i++) {
p = _GetPSubviewStructAt(i);
resizeView(sPtr, p->view, p->size);
moveView(sPtr, p->view, p->pos);
}
}
void Viewport::setViewport(const types::Rect& globalArea)
{
Rect zoomRect = Rect(globalArea.topLeft() / m_zoomFactor, globalArea.bottomRight() / m_zoomFactor)
.translated(m_viewDelta)
.canonicalized();
if (zoomRect.area() > 1000)
{
float factorW = m_viewSize.x / (zoomRect.width() + 40);
float factorH = m_viewSize.y / (zoomRect.height() + 40);
m_zoomFactor = helper::bound(0.1f, std::min(factorW, factorH), 1.0f);
m_zoomLevel = static_cast<int>(100 * (1.f - m_zoomFactor));
moveView(m_viewSize / 2 / m_zoomFactor - zoomRect.center() + m_viewDelta);
}
}
void
GLWidget::mouseMoveEvent(QMouseEvent *event)
{
if (event->buttons() != Qt::NoButton) {
slotUnlockView();
QPoint delta = event->pos() - _lastMovePos;
if (event->buttons() & Qt::LeftButton) {
moveView(delta);
} else if (event->buttons() & Qt::MiddleButton ||
event->buttons() & Qt::RightButton)
{
mouseDragZoom(delta);
}
_lastMovePos = event->pos();
}
event->accept();
}
void Viewport::showAllSelected()
{
if(!m_view.selection().get().empty())
{
Rect selectedArea;
for (const auto& obj : m_view.selection().get())
{
auto objRnd = m_view.objectRenderers().get(obj);
if(objRnd)
selectedArea |= objRnd->getVisualArea();
}
float factorW = m_viewSize.x / (selectedArea.width() + 40);
float factorH = m_viewSize.y / (selectedArea.height() + 40);
m_zoomFactor = helper::bound(0.1f, std::min(factorW, factorH), 1.0f);
m_zoomLevel = static_cast<int>(100 * (1.f - m_zoomFactor));
moveView(m_viewSize / 2 / m_zoomFactor - selectedArea.center() + m_viewDelta);
}
}
void editLevelStateClass::zoomView(int delta)
{
float newZoom = 1;
if(delta > 0)
{
newZoom = (1 / static_cast<double>(delta * 1.5));
}
else
{
newZoom = (-delta * 1.5);
}
zoomLevel *= newZoom;
view.zoom(newZoom);
if(view.getSize().x > WIDTH_SCREEN)
{
view.setSize(WIDTH_SCREEN, HEIGHT_SCREEN);
zoomLevel = 1;
}
moveView(0, 0);
}
void RoutingGame::update()
{
sf::Event eve;
while(m_win.pollEvent(eve))
{
if(eve.type == sf::Event::Closed)
m_win.close();
if(!m_won && eve.type == sf::Event::MouseButtonPressed && eve.mouseButton.button == sf::Mouse::Left)
{
const sf::Vector2f mpos = m_win.mapPixelToCoords(sf::Vector2i(eve.mouseButton.x, eve.mouseButton.y));
const unsigned x = mpos.x / kTileSize;
const unsigned y = mpos.y / kTileSize;
m_map.rotateTileRight(x, y);
if(m_map.getEnergizedTiles() == m_map.getTotalTiles())
m_won = true;
setTitle();
}
if(eve.type == sf::Event::KeyPressed)
{
switch(eve.key.code)
{
case sf::Keyboard::F1:
newGame(5u, 5u);
break;
case sf::Keyboard::F2:
newGame(10u, 15u);
break;
case sf::Keyboard::F3:
newGame(20u, 30u);
break;
case sf::Keyboard::F4:
newGame(40u, 60u);
break;
case sf::Keyboard::F5:
newGame(50u, 100u);
break;
case sf::Keyboard::W:
moveView(m_win, sf::Vector2f(0.f, -75.f));
break;
case sf::Keyboard::S:
moveView(m_win, sf::Vector2f(0.f, 75.f));
break;
case sf::Keyboard::A:
moveView(m_win, sf::Vector2f(-75.f, 0.f));
break;
case sf::Keyboard::D:
moveView(m_win, sf::Vector2f(75.f, 0.f));
break;
case sf::Keyboard::Space:
if(!m_won)
{
m_map.randomlyRotate(static_cast<unsigned>(std::time(NULL)));
setTitle();
}
break;
}//switch eve key code
}
if(eve.type == sf::Event::Resized)
{
sf::View v = m_win.getView();
v.setSize(sf::Vector2f(eve.size.width, eve.size.height));
m_win.setView(v);
}
}//while win poll event eve
}
void PlayViewZone::Draw()
{
//
// Vemos si el mouse esta en la zona de movimiento.
//
if ( m_move ) moveView( moveX,
moveY );
//
// Dibujamos la parte del zone.
//
m_interface_.screen().getGraphics()->pushClipArea( m_pos );
/*
* Actualizar el campo isometrico.
*
* 1.- Calcular los tiles que hemos de dibujar.
* 2.- Dibujar por orden:
* Terreno
* Buildings
* Actores
*
* Empezamos a dibujar el Terrain, despues los buildings y despues los actores.
* Ya veremos como planteamos el movimiento de los actores, cambios de tile,etc.
* o bien para elementos como minas, etc.. la creacion y destruccion de los mismos,
* un pelin de foll�n....
*
*/
// std::vector < gcn::Point >& allPoints = m_scroller->getPointPaint(); // Obtener los puntos isometricos a dibujar.
//
// Dibujamos el Terrain.
//
std::for_each( ptScroller->begin(),
ptScroller->end(),
boost::bind( &PlayViewZone::PaintAllTerrain,
this,
_1 ) );
//
// Visualizar las ayudas de render.
//
this->Render();
//
// Visualizar resto de elementos.
//
std::for_each( ptScroller->begin(),
ptScroller->end(),
boost::bind( &PlayViewZone::PaintAll,
this,
_1 ) );
/*
//
// Dibujamos los Buildings.
//
std::for_each(ptScroller->begin(), ptScroller->end(), boost::bind(
&PlayViewZone::PaintAllBuilding, this, _1));
//
// Dibujamos los Resource.
//
std::for_each(ptScroller->begin(), ptScroller->end(), boost::bind(
&PlayViewZone::PaintAllResource, this, _1));
//
// Dibujamos los Actores.
//
std::for_each(ptScroller->begin(), ptScroller->end(), boost::bind(
&PlayViewZone::PaintAllActor, this, _1));
*/
//
// Si tenemos activada el area de seleccion es hora de pintarla.
//
if ( m_selection ) {
m_interface_.screen().getGraphics()->setColor( gcn::Color::White ); // The colour to be used when drawing. From here on, white will be used.
m_interface_.screen().getGraphics()->drawRectangle( m_selectarea );
}
m_interface_.screen().getGraphics()->popClipArea();
}
void PlaneViewer::mouseMoveEvent(QMouseEvent *event) {
if (event->buttons() & Qt::MidButton)
moveView(event->x() - m_xpos, height() - event->y() - m_ypos);
m_xpos = event->x(), m_ypos = height() - event->y();
}
void Viewport::centerView()
{
const auto center = m_viewSize / 2;
if(!m_objectsRect.empty())
moveView(center / m_zoomFactor - m_objectsRect.center() + m_viewDelta);
}
static void dragDivider(WMSplitView * sPtr, int clickX, int clickY)
{
int divider, pos, ofs, done, dragging;
int i, count;
XEvent ev;
WMScreen *scr;
int minCoord, maxCoord, coord;
if (sPtr->constrainProc) {
updateConstraints(sPtr);
checkSizes(sPtr);
distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
checkPositions(sPtr);
updateSubviewsGeom(sPtr);
}
scr = sPtr->view->screen;
divider = ofs = pos = done = 0;
coord = (sPtr->flags.vertical) ? clickX : clickY;
count = _GetSubviewsCount();
if (count < 2)
return;
for (i = 0; i < count - 1; i++) {
pos += _GetSizeAt(i) + DIVIDER_THICKNESS;
if (coord < pos) {
ofs = coord - pos + DIVIDER_THICKNESS;
done = 1;
break;
}
divider++;
}
if (!done)
return;
getMinMaxDividerCoord(sPtr, divider, &minCoord, &maxCoord);
done = 0;
dragging = 0;
while (!done) {
WMMaskEvent(scr->display, ButtonMotionMask | ButtonReleaseMask | ExposureMask, &ev);
coord = (sPtr->flags.vertical) ? ev.xmotion.x : ev.xmotion.y;
switch (ev.type) {
case ButtonRelease:
done = 1;
if (dragging)
drawDragingRectangle(sPtr, pos);
break;
case MotionNotify:
if (dragging)
drawDragingRectangle(sPtr, pos);
if (coord - ofs < minCoord)
pos = minCoord;
else if (coord - ofs > maxCoord)
pos = maxCoord;
else
pos = coord - ofs;
drawDragingRectangle(sPtr, pos);
dragging = 1;
break;
default:
WMHandleEvent(&ev);
break;
}
}
if (dragging) {
W_SplitViewSubview *p1, *p2;
int totSize;
p1 = _GetPSubviewStructAt(divider);
p2 = _GetPSubviewStructAt(divider + 1);
totSize = p1->size + DIVIDER_THICKNESS + p2->size;
p1->size = pos - p1->pos;
p2->size = totSize - p1->size - DIVIDER_THICKNESS;
p2->pos = p1->pos + p1->size + DIVIDER_THICKNESS;
resizeView(sPtr, p1->view, p1->size);
moveView(sPtr, p2->view, p2->pos);
resizeView(sPtr, p2->view, p2->size);
sPtr->flags.subviewsWereManuallyMoved = 1;
}
}
void editLevelStateClass::update(sf::RenderWindow& window)
{
sf::Event event;
while(window.pollEvent(event))
{
if(event.type == sf::Event::Closed)
{
window.close();
}
else if(event.type == sf::Event::KeyPressed)
{
switch(event.key.code)
{
case sf::Keyboard::Escape:
{
setNoMode();
break;
}
case sf::Keyboard::A:
{
drawAllFloor = !drawAllFloor;
break;
}
case sf::Keyboard::F:
{
setAddFloorMode();
break;
}
case sf::Keyboard::W:
{
setAddWallMode("WALL");
break;
}
case sf::Keyboard::X:
{
setAddWallMode("STICKMAN_WALL");
break;
}
case sf::Keyboard::P:
{
currentMode = PLACE_PLAYER;
break;
}
case sf::Keyboard::Return:
{
returnPressed();
break;
}
case sf::Keyboard::BackSpace:
{
backspacePressed();
break;
}
case sf::Keyboard::Delete:
{
deletePressed();
break;
}
case sf::Keyboard::LShift:
{
speedFactor = 5;
break;
}
case sf::Keyboard::O:
{
saveLevel();
break;
}
case sf::Keyboard::I:
{
loadLevel();
break;
}
case sf::Keyboard::H:
{
moveAllLevel(-1, 0);
break;
}
case sf::Keyboard::J:
{
moveAllLevel(0, 1);
break;
}
case sf::Keyboard::K:
{
moveAllLevel(0, -1);
break;
}
case sf::Keyboard::L:
{
moveAllLevel(1, 0);
break;
}
case sf::Keyboard::F10:
{
global::activeGameStateStack->set(new mainMenuStateClass());
return;
}
case sf::Keyboard::Add:
{
if(static_cast<unsigned int>(currentFloor - 1) < listOfFloor.size())
{
++currentFloor;
}
break;
}
case sf::Keyboard::Subtract:
{
if(currentFloor > 0)
{
--currentFloor;
}
break;
}
case sf::Keyboard::B:
{
if(chooseNameOfLevel == false)
{
chooseNameOfLevel = true;
tmpIndexOfLevel = currentIndexOfLevel;
}
else
{
--tmpIndexOfLevel;
if(tmpIndexOfLevel < 0)
{
tmpIndexOfLevel = listOfLevel.size() - 1;
}
}
nameOfLevelTextHasChanged();
break;
}
case sf::Keyboard::N:
{
if(chooseNameOfLevel == false)
{
chooseNameOfLevel = true;
tmpIndexOfLevel = currentIndexOfLevel;
}
else
{
++tmpIndexOfLevel;
if(static_cast<unsigned int>(tmpIndexOfLevel) >= listOfLevel.size())
{
tmpIndexOfLevel = 0;
}
}
nameOfLevelTextHasChanged();
break;
}
case sf::Keyboard::M:
{
if(chooseNameOfLevel == true)
{
chooseNameOfLevel = false;
currentIndexOfLevel = tmpIndexOfLevel;
loadThisLevel(listOfLevel[currentIndexOfLevel]);
}
break;
}
default:
{
break;
}
}
}
else if(event.type == sf::Event::KeyReleased)
{
if(event.key.code == sf::Keyboard::LShift)
{
speedFactor = 1;
}
}
else if(event.type == sf::Event::MouseButtonPressed)
{
if(event.mouseButton.button == sf::Mouse::Left)
{
leftClick(view.getCenter().x - ((WIDTH_SCREEN / 2) * zoomLevel) + event.mouseButton.x * zoomLevel,
view.getCenter().y - ((HEIGHT_SCREEN / 2) * zoomLevel) + event.mouseButton.y * zoomLevel);
}
else if(event.mouseButton.button == sf::Mouse::Right)
{
rightClick(view.getCenter().x - ((WIDTH_SCREEN / 2) * zoomLevel) + event.mouseButton.x * zoomLevel,
view.getCenter().y - ((HEIGHT_SCREEN / 2) * zoomLevel) + event.mouseButton.y * zoomLevel);
}
}
else if(event.type == sf::Event::MouseWheelMoved)
{
zoomView(event.mouseWheel.delta);
}
if(event.type == sf::Event::TextEntered)
{
char character = static_cast<char>(event.text.unicode);
if(character >= 48 && character <= 57 && currentMode == NO_MODE)
{
if(character - 48 < static_cast<char>(listOfFloor.size()))
{
currentFloor = character - 48;
}
}
}
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Q))
{
moveView(-speedView * zoomLevel - 1, 0);
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
moveView(speedView * zoomLevel + 1, 0);
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Z))
{
moveView(0, -speedView * zoomLevel - 1);
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::S))
{
moveView(0, speedView * zoomLevel + 1);
}
if(chooseNameOfLevel == true)
{
updateNameOfLevelText();
}
}
