force use of template version of std::min/max

src/client/creature.cpp

@@ -70,13 +70,13 @@ void Creature::draw(const Point& dest, float scaleFactor, bool animate, LightVie
 
     if(m_showTimedSquare && animate) {
         g_painter->setColor(m_timedSquareColor);
-        g_painter->drawBoundingRect(Rect(dest + (animationOffset - getDisplacement() + 2)*scaleFactor, Size(28, 28)*scaleFactor), std::max((int)(2*scaleFactor), 1));
+        g_painter->drawBoundingRect(Rect(dest + (animationOffset - getDisplacement() + 2)*scaleFactor, Size(28, 28)*scaleFactor), std::max<int>((int)(2*scaleFactor), 1));
         g_painter->setColor(Color::white);
     }
 
     if(m_showStaticSquare && animate) {
         g_painter->setColor(m_staticSquareColor);
-        g_painter->drawBoundingRect(Rect(dest + (animationOffset - getDisplacement())*scaleFactor, Size(Otc::TILE_PIXELS, Otc::TILE_PIXELS)*scaleFactor), std::max((int)(2*scaleFactor), 1));
+        g_painter->drawBoundingRect(Rect(dest + (animationOffset - getDisplacement())*scaleFactor, Size(Otc::TILE_PIXELS, Otc::TILE_PIXELS)*scaleFactor), std::max<int>((int)(2*scaleFactor), 1));
         g_painter->setColor(Color::white);
     }
 
@@ -171,7 +171,7 @@ void Creature::internalDrawOutfit(Point dest, float scaleFactor, bool animateWal
         // when creature is an effect we cant render the first and last animation phase,
         // instead we should loop in the phases between
         if(m_outfit.getCategory() == ThingCategoryEffect) {
-            animationPhases = std::max(1, animationPhases-2);
+            animationPhases = std::max<int>(1, animationPhases-2);
             animateTicks = Otc::INVISIBLE_TICKS_PER_FRAME;
         }
 
@@ -372,7 +372,7 @@ void Creature::updateJump()
 
         int nextT, i = 1;
         do {
-            nextT = stdext::round((-b + std::sqrt(std::max(b*b + 4*a*(roundHeight+diff*i), 0.0)) * diff) / (2*a));
+            nextT = stdext::round((-b + std::sqrt(std::max<int>(b*b + 4*a*(roundHeight+diff*i), 0.0)) * diff) / (2*a));
             ++i;
 
             if(nextT < halfJumpDuration)
@@ -556,7 +556,7 @@ void Creature::updateWalk()
     int totalPixelsWalked = std::min(m_walkTimer.ticksElapsed() / walkTicksPerPixel, 32.0f);
 
     // needed for paralyze effect
-    m_walkedPixels = std::max(m_walkedPixels, totalPixelsWalked);
+    m_walkedPixels = std::max<int>(m_walkedPixels, totalPixelsWalked);
 
     // update walk animation and offsets
     updateWalkAnimation(totalPixelsWalked);
@@ -820,7 +820,7 @@ int Creature::getStepDuration(bool ignoreDiagonal, Otc::Direction dir)
     if(g_game.getFeature(Otc::GameNewSpeedLaw) && hasSpeedFormula()) {
         int formulatedSpeed = 1;
         if(speed > -m_speedFormula[Otc::SpeedFormulaB]) {
-            formulatedSpeed = std::max(1, (int)floor((m_speedFormula[Otc::SpeedFormulaA] * log((speed / 2)
+            formulatedSpeed = std::max<int>(1, (int)floor((m_speedFormula[Otc::SpeedFormulaA] * log((speed / 2)
                  + m_speedFormula[Otc::SpeedFormulaB]) + m_speedFormula[Otc::SpeedFormulaC]) + 0.5));
         }
         interval = std::floor(interval / (double)formulatedSpeed);
@@ -835,7 +835,7 @@ int Creature::getStepDuration(bool ignoreDiagonal, Otc::Direction dir)
     if(g_game.getProtocolVersion() <= 810)
         factor = 2;
 
-    interval = std::max(interval, g_game.getServerBeat());
+    interval = std::max<int>(interval, g_game.getServerBeat());
 
     if(!ignoreDiagonal && (m_lastStepDirection == Otc::NorthWest || m_lastStepDirection == Otc::NorthEast ||
        m_lastStepDirection == Otc::SouthWest || m_lastStepDirection == Otc::SouthEast))
@@ -887,7 +887,7 @@ int Creature::getExactSize(int layer, int xPattern, int yPattern, int zPattern,
             continue;
 
         for(layer = 0; layer < getLayers(); ++layer)
-            exactSize = std::max(exactSize, Thing::getExactSize(layer, xPattern, yPattern, zPattern, animationPhase));
+            exactSize = std::max<int>(exactSize, Thing::getExactSize(layer, xPattern, yPattern, zPattern, animationPhase));
     }
 
     return exactSize;

src/client/effect.cpp

@@ -31,7 +31,7 @@ void Effect::draw(const Point& dest, float scaleFactor, bool animate, LightView
 
     int animationPhase = 0;
     if(animate)
-        animationPhase = std::min((int)(m_animationTimer.ticksElapsed() / m_phaseDuration), getAnimationPhases() - 1);
+        animationPhase = std::min<int>((int)(m_animationTimer.ticksElapsed() / m_phaseDuration), getAnimationPhases() - 1);
     rawGetThingType()->draw(dest, scaleFactor, 0, 0, 0, 0, animationPhase, lightView);
 }
 

src/client/game.h

@@ -287,7 +287,7 @@ public:
     bool isFollowing() { return !!m_followingCreature; }
     bool isConnectionOk() { return m_protocolGame && m_protocolGame->getElapsedTicksSinceLastRead() < 5000; }
 
-    int getPing() { return m_ping >= 0 ? std::max(m_ping, m_pingTimer.elapsed_millis()) : -1; }
+    int getPing() { return m_ping >= 0 ? std::max<int>(m_ping, m_pingTimer.elapsed_millis()) : -1; }
     ContainerPtr getContainer(int index) { return m_containers[index]; }
     std::map<int, ContainerPtr> getContainers() { return m_containers; }
     std::map<int, Vip> getVips() { return m_vips; }

src/client/lightview.cpp

@@ -50,7 +50,7 @@ TexturePtr LightView::generateLightBubble(float centerFactor)
     for(int x = 0; x < bubbleDiameter; x++) {
         for(int y = 0; y < bubbleDiameter; y++) {
             float radius = std::sqrt((bubbleRadius - x)*(bubbleRadius - x) + (bubbleRadius - y)*(bubbleRadius - y));
-            float intensity = std::max(std::min((bubbleRadius-radius)/(float)(bubbleRadius-centerRadius), 1.0f), 0.0f);
+            float intensity = std::max<float>(std::min<float>((bubbleRadius-radius)/(float)(bubbleRadius-centerRadius), 1.0f), 0.0f);
 
             // light intensity varies inversely with the square of the distance
             intensity = intensity * intensity;

src/client/localplayer.cpp

@@ -58,7 +58,7 @@ LocalPlayer::LocalPlayer()
 
 void LocalPlayer::lockWalk(int millis)
 {
-    m_walkLockExpiration = std::max(m_walkLockExpiration, (ticks_t) g_clock.millis() + millis);
+    m_walkLockExpiration = std::max<int>(m_walkLockExpiration, (ticks_t) g_clock.millis() + millis);
 }
 
 bool LocalPlayer::canWalk(Otc::Direction direction)
@@ -263,7 +263,7 @@ void LocalPlayer::updateWalk()
 {
     int stepDuration = getStepDuration();
     float walkTicksPerPixel = getStepDuration(true) / 32.0f;
-    int totalPixelsWalked = std::min(m_walkTimer.ticksElapsed() / walkTicksPerPixel, 32.0f);
+    int totalPixelsWalked = std::min<int>(m_walkTimer.ticksElapsed() / walkTicksPerPixel, 32.0f);
 
     // update walk animation and offsets
     updateWalkAnimation(totalPixelsWalked);

src/client/map.cpp

@@ -138,7 +138,7 @@ void Map::addThing(const ThingPtr& thing, const Position& pos, int stackPos)
                         int y = 12 - 48 * t / (float)Otc::ANIMATED_TEXT_DURATION;
                         offset += Point(0, y);
                     }
-                    offset.y = std::min(offset.y, 12);
+                    offset.y = std::min<int>(offset.y, 12);
                     animatedText->setOffset(offset);
                 }
                 m_animatedTexts.push_back(animatedText);
@@ -615,7 +615,7 @@ int Map::getFirstAwareFloor()
 int Map::getLastAwareFloor()
 {
     if(m_centralPosition.z > Otc::SEA_FLOOR)
-        return std::min(m_centralPosition.z+Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::MAX_Z);
+        return std::min<int>(m_centralPosition.z+Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::MAX_Z);
     else
         return Otc::SEA_FLOOR;
 }

src/client/mapview.cpp

@@ -159,7 +159,7 @@ void MapView::draw(const Rect& rect)
     }
 
     if(m_shaderSwitchDone && m_shader && m_fadeInTime > 0)
-        fadeOpacity = std::min(m_fadeTimer.timeElapsed() / m_fadeInTime, 1.0f);
+        fadeOpacity = std::min<float>(m_fadeTimer.timeElapsed() / m_fadeInTime, 1.0f);
 
     Rect srcRect = calcFramebufferSource(rect.size());
     Point drawOffset = srcRect.topLeft();
@@ -311,7 +311,7 @@ void MapView::updateVisibleTilesCache(int start)
             // loop through / diagonals beginning at top left and going to top right
             for(int diagonal = 0; diagonal < numDiagonals && !stop; ++diagonal) {
                 // loop current diagonal tiles
-                int advance = std::max(diagonal - m_drawDimension.height(), 0);
+                int advance = std::max<int>(diagonal - m_drawDimension.height(), 0);
                 for(int iy = diagonal - advance, ix = advance; iy >= 0 && ix < m_drawDimension.width() && !stop; --iy, ++ix) {
                     // only start really looking tiles in the desired start
                     if(m_updateTilesPos < start) {
@@ -364,10 +364,10 @@ void MapView::updateVisibleTilesCache(int start)
                     };
 
                     for(int i=0;i<4;++i) {
-                        int sx = std::max(lines[i].left(), area.left());
+                        int sx = std::max<int>(lines[i].left(), area.left());
-                        int ex = std::min(lines[i].right(), area.right());
+                        int ex = std::min<int>(lines[i].right(), area.right());
-                        int sy = std::max(lines[i].top(), area.top());
+                        int sy = std::max<int>(lines[i].top(), area.top());
-                        int ey = std::min(lines[i].bottom(), area.bottom());
+                        int ey = std::min<int>(lines[i].bottom(), area.bottom());
                         for(int qx=sx;qx<=ex;++qx)
                             for(int qy=sy;qy<=ey;++qy)
                                 m_spiral[count++] = Point(qx, qy);
@@ -608,7 +608,7 @@ int MapView::calcFirstVisibleFloor()
 
                 // limits to underground floors while under sea level
                 if(cameraPosition.z > Otc::SEA_FLOOR)
-                    firstFloor = std::max(cameraPosition.z - Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::UNDERGROUND_FLOOR);
+                    firstFloor = std::max<int>(cameraPosition.z - Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::UNDERGROUND_FLOOR);
 
                 // loop in 3x3 tiles around the camera
                 for(int ix = -1; ix <= 1 && firstFloor < cameraPosition.z; ++ix) {
@@ -644,7 +644,7 @@ int MapView::calcFirstVisibleFloor()
     }
 
     // just ensure the that the floor is in the valid range
-    z = std::min(std::max(z, 0), (int)Otc::MAX_Z);
+    z = std::min<int>(std::max<int>(z, 0), (int)Otc::MAX_Z);
     return z;
 }
 
@@ -666,10 +666,10 @@ int MapView::calcLastVisibleFloor()
     }
 
     if(m_lockedFirstVisibleFloor != -1)
-        z = std::max(m_lockedFirstVisibleFloor, z);
+        z = std::max<int>(m_lockedFirstVisibleFloor, z);
 
     // just ensure the that the floor is in the valid range
-    z = std::min(std::max(z, 0), (int)Otc::MAX_Z);
+    z = std::min<int>(std::max<int>(z, 0), (int)Otc::MAX_Z);
     return z;
 }
 

src/client/minimap.cpp

@@ -200,7 +200,7 @@ void Minimap::updateTile(const Position& pos, const TilePtr& tile)
             minimapTile.flags |= MinimapTileNotWalkable;
         if(!tile->isPathable())
             minimapTile.flags |= MinimapTileNotPathable;
-        minimapTile.speed = std::min((int)std::ceil(tile->getGroundSpeed() / 10.0f), 255);
+        minimapTile.speed = std::min<int>((int)std::ceil(tile->getGroundSpeed() / 10.0f), 255);
     }
 
     if(minimapTile != MinimapTile()) {

src/client/protocolgameparse.cpp

@@ -1701,7 +1701,7 @@ void ProtocolGame::setMapDescription(const InputMessagePtr& msg, int x, int y, i
 
     if(z > Otc::SEA_FLOOR) {
         startz = z - Otc::AWARE_UNDEGROUND_FLOOR_RANGE;
-        endz = std::min(z + Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::MAX_Z);
+        endz = std::min<int>(z + Otc::AWARE_UNDEGROUND_FLOOR_RANGE, (int)Otc::MAX_Z);
         zstep = 1;
     }
     else {

src/client/thingtype.cpp

@@ -129,7 +129,7 @@ void ThingType::unserialize(uint16 clientId, ThingCategory category, const FileS
     uint8 width = fin->getU8();
     uint8 height = fin->getU8();
     m_size = Size(width, height);
-    m_exactSize = (width > 1 || height > 1) ? std::min((int)fin->getU8(), std::max(width * 32, height * 32)) : 32;
+    m_exactSize = (width > 1 || height > 1) ? std::min<int>((int)fin->getU8(), std::max<int>(width * 32, height * 32)) : 32;
     m_layers = fin->getU8();
     m_numPatternX = fin->getU8();
     m_numPatternY = fin->getU8();
@@ -280,10 +280,10 @@ const TexturePtr& ThingType::getTexture(int animationPhase)
                             for(int y = framePos.y; y < framePos.y + m_size.height() * Otc::TILE_PIXELS; ++y) {
                                 uint8 *p = fullImage->getPixel(x,y);
                                 if(p[3] != 0x00) {
-                                    drawRect.setTop   (std::min(y, (int)drawRect.top()));
+                                    drawRect.setTop   (std::min<int>(y, (int)drawRect.top()));
-                                    drawRect.setLeft  (std::min(x, (int)drawRect.left()));
+                                    drawRect.setLeft  (std::min<int>(x, (int)drawRect.left()));
-                                    drawRect.setBottom(std::max(y, (int)drawRect.bottom()));
+                                    drawRect.setBottom(std::max<int>(y, (int)drawRect.bottom()));
-                                    drawRect.setRight (std::max(x, (int)drawRect.right()));
+                                    drawRect.setRight (std::max<int>(x, (int)drawRect.right()));
                                 }
                             }
                         }
@@ -362,5 +362,5 @@ int ThingType::getExactSize(int layer, int xPattern, int yPattern, int zPattern,
     getTexture(animationPhase); // we must calculate it anyway.
     int frameIndex = getTextureIndex(layer, xPattern, yPattern, zPattern);
     Size size = m_texturesFramesOriginRects[animationPhase][frameIndex].size() - m_texturesFramesOffsets[animationPhase][frameIndex].toSize();
-    return std::max(size.width(), size.height());
+    return std::max<int>(size.width(), size.height());
 }

src/client/tile.cpp

@@ -101,8 +101,8 @@ void Tile::draw(const Point& dest, float scaleFactor, int drawFlags, LightView *
             thing->draw(dest - m_drawElevation*scaleFactor, scaleFactor, animate, lightView);
 
             if(thing->isLyingCorpse()) {
-                redrawPreviousTopW = std::max(thing->getWidth(), redrawPreviousTopW);
+                redrawPreviousTopW = std::max<int>(thing->getWidth(), redrawPreviousTopW);
-                redrawPreviousTopH = std::max(thing->getHeight(), redrawPreviousTopH);
+                redrawPreviousTopH = std::max<int>(thing->getHeight(), redrawPreviousTopH);
             }
 
             m_drawElevation += thing->getElevation();

src/client/uiitem.cpp

@@ -48,11 +48,11 @@ void UIItem::drawSelf(Fw::DrawPane drawPane)
         Rect drawRect = getPaddingRect();
         Point dest = drawRect.bottomRight() + Point(1,1);
 
-        int exactSize = std::max(32, m_item->getExactSize());
+        int exactSize = std::max<int>(32, m_item->getExactSize());
         if(exactSize == 0)
             return;
 
-        float scaleFactor = std::min(drawRect.width() / (float)exactSize, drawRect.height() / (float)exactSize);
+        float scaleFactor = std::min<float>(drawRect.width() / (float)exactSize, drawRect.height() / (float)exactSize);
         dest += (m_item->getDisplacement() - Point(32,32)) * scaleFactor;
 
         g_painter->setColor(m_color);

src/client/uimap.cpp

@@ -77,7 +77,7 @@ void UIMap::movePixels(int x, int y)
 
 bool UIMap::setZoom(int zoom)
 {
-    m_zoom = std::min(std::max(zoom, m_maxZoomIn), m_maxZoomOut);
+    m_zoom = std::min<int>(std::max<int>(zoom, m_maxZoomIn), m_maxZoomOut);
     updateVisibleDimension();
     return false;
 }

src/client/uiprogressrect.cpp

@@ -44,35 +44,35 @@ void UIProgressRect::drawSelf(Fw::DrawPane drawPane)
     // 0% - 12.5% (12.5)
     // triangle from top center, to top right (var x)
     if(m_percent < 12.5) {
-        Point var = Point(std::max(m_percent - 0.0, 0.0) * (drawRect.right() - drawRect.horizontalCenter()) / 12.5, 0);
+        Point var = Point(std::max<int>(m_percent - 0.0, 0.0) * (drawRect.right() - drawRect.horizontalCenter()) / 12.5, 0);
         g_painter->drawFilledTriangle(drawRect.center(), drawRect.topRight() + Point(1,0), drawRect.topCenter() + var);
     }
 
     // 12.5% - 37.5% (25)
     // triangle from top right to bottom right (var y)
     if(m_percent < 37.5) {
-        Point var = Point(0, std::max(m_percent - 12.5, 0.0) * (drawRect.bottom() - drawRect.top()) / 25.0);
+        Point var = Point(0, std::max<int>(m_percent - 12.5, 0.0) * (drawRect.bottom() - drawRect.top()) / 25.0);
         g_painter->drawFilledTriangle(drawRect.center(), drawRect.bottomRight() + Point(1,1), drawRect.topRight() + var + Point(1,0));
     }
 
     // 37.5% - 62.5% (25)
     // triangle from bottom right to bottom left (var x)
     if(m_percent < 62.5) {
-        Point var = Point(std::max(m_percent - 37.5, 0.0) * (drawRect.right() - drawRect.left()) / 25.0, 0);
+        Point var = Point(std::max<int>(m_percent - 37.5, 0.0) * (drawRect.right() - drawRect.left()) / 25.0, 0);
         g_painter->drawFilledTriangle(drawRect.center(), drawRect.bottomLeft() + Point(0,1), drawRect.bottomRight() - var + Point(1,1));
     }
 
     // 62.5% - 87.5% (25)
     // triangle from bottom left to top left
     if(m_percent < 87.5) {
-        Point var = Point(0, std::max(m_percent - 62.5, 0.0) * (drawRect.bottom() - drawRect.top()) / 25.0);
+        Point var = Point(0, std::max<int>(m_percent - 62.5, 0.0) * (drawRect.bottom() - drawRect.top()) / 25.0);
         g_painter->drawFilledTriangle(drawRect.center(), drawRect.topLeft(), drawRect.bottomLeft() - var + Point(0,1));
     }
 
     // 87.5% - 100% (12.5)
     // triangle from top left to top center
     if(m_percent < 100) {
-        Point var = Point(std::max(m_percent - 87.5, 0.0) * (drawRect.horizontalCenter() - drawRect.left()) / 12.5, 0);
+        Point var = Point(std::max<int>(m_percent - 87.5, 0.0) * (drawRect.horizontalCenter() - drawRect.left()) / 12.5, 0);
         g_painter->drawFilledTriangle(drawRect.center(), drawRect.topCenter(), drawRect.topLeft() + var);
     }
 
@@ -84,7 +84,7 @@ void UIProgressRect::drawSelf(Fw::DrawPane drawPane)
 
 void UIProgressRect::setPercent(float percent)
 {
-    m_percent = std::max(std::min((double)percent, 100.0), 0.0);
+    m_percent = std::max<float>(std::min<float>((double)percent, 100.0), 0.0);
 }
 
 void UIProgressRect::onStyleApply(const std::string& styleName, const OTMLNodePtr& styleNode)

src/framework/core/adaptativeframecounter.cpp

@@ -89,7 +89,7 @@ bool AdaptativeFrameCounter::update()
 
 void AdaptativeFrameCounter::setMaxFps(int maxFps)
 {
-    maxFps = std::max(std::min(maxFps, 1000), 0);
+    maxFps = std::max<int>(std::min<int>(maxFps, 1000), 0);
 
     if(maxFps != 0) {
         m_bestFrameDelay = 1000000 / maxFps;

src/framework/graphics/bitmapfont.cpp

@@ -209,7 +209,7 @@ const std::vector<Point>& BitmapFont::calculateGlyphsPositions(const std::string
                 lineWidths[lines] += m_glyphsSize[glyph].width() ;
                 if((i+1 != textLength && text[i+1] != '\n')) // only add space if letter is not the last or before a \n.
                     lineWidths[lines] += m_glyphSpacing.width();
-                maxLineWidth = std::max(maxLineWidth, lineWidths[lines]);
+                maxLineWidth = std::max<int>(maxLineWidth, lineWidths[lines]);
             }
         }
     }

src/framework/graphics/framebuffer.cpp

@@ -149,8 +149,8 @@ Size FrameBuffer::getSize()
 {
     if(m_fbo == 0) {
         // the buffer size is limited by the window size
-        return Size(std::min(m_texture->getWidth(), g_window.getWidth()),
+        return Size(std::min<int>(m_texture->getWidth(), g_window.getWidth()),
-                    std::min(m_texture->getHeight(), g_window.getHeight()));
+                    std::min<int>(m_texture->getHeight(), g_window.getHeight()));
     }
     return m_texture->getSize();
 }