E:/Eigene Dateien/Eigene Projekte/c0re/DAEffect.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "DAEffect.h"

#include "system.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>

#include "Level.h"

DAEffect::DAEffect(Vector3i p_origin, Vector3i p_destination, int p_valOrig, int p_valDest, Level* p_level)
{
        origin = p_origin;
        destination = p_destination;
        valOrig = p_valOrig;
        valDest = p_valDest;
        level = p_level;
}

DAEffect::~DAEffect()
{
}

int DAEffect::render()
{
        int ret = 0;
        ratio = 2.0;
        Vector3d ori, dest;
        //get the global coordinates from the origin
        ori.x = origin.x * 0.75;
        ori.y = origin.y * 0.87;
        if (origin.x % 2 == 1)
        {
                ori.y += 0.44;
        }
        //get the global coordinates from the destination
        dest.x = destination.x * 0.75;
        dest.y = destination.y * 0.87;
        if (destination.x % 2 == 1)
        {
                dest.y += 0.44;
        }
        //now compute the angle
        Vector3d delta = dest - ori;
        double size = delta.length();
        ratio *= size;
        double angle = 0.0;
        if (origin.x == destination.x)
        {
                if (origin.y > destination.y)
                        angle = 270.0;
                else
                        angle = 90.0;
        }
        else
        {
                angle = (atan(delta.y / delta.x)* 57.3);
                if (ori.x < dest.x)
                {
                        angle = 360 + angle;
                }
                else
                {
                        angle = 180 + angle;
                }
        }
        
        glPushMatrix();
        //this is needed as the tile is only using 0.87 of the y-size of the square
        glTranslated(0.0, 0.065, 0.0);
        delta /= 2.0;
        delta += ori;
        glTranslated(delta.x, delta.y, delta.z);
        glRotated(angle, 0.0, 0.0, 1.0);
        glScaled(size, size, size);
        Texture::render();
        glPopMatrix();

        //now the combat values:
        Vector3d origColor, destColor;
        if ((valOrig < valDest) && (valDest != 99))
        {
                origColor.x = 1.0;
                destColor.y = 1.0;
        }
        else
        {
                destColor.x = 1.0;              
                origColor.y = 1.0;
        }
        glPushMatrix();
        //this is needed as the tile is only using 0.87 of the y-size of the square
        glTranslated(0.0, 0.065, 0.0);
        glColor4d(origColor.x, origColor.y, origColor.z, 1.0);
        level->glPrint2d(ori.x, ori.y, "%i", valOrig);
        glColor4d(destColor.x, destColor.y, destColor.z, 1.0);
        if (valDest != 99)
                level->glPrint2d(dest.x, dest.y, "%i", valDest);
        else
                level->glPrint2d(dest.x, dest.y, "E");
        glPopMatrix();
        return ret;
}

---