Some shit

#pragma once

#include "cscreen.h"

#define SET_OWNER_COLOR glColor3d( 0, 255, 0 )
#define SET_OPPO_COLOR glColor3d( 255, 0, 0 )

namespace Game
{
    float CScreen::fHypo;

    void CScreen::Set2DMode( )
    {
        glDisable( GL_DEPTH_TEST );
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity( );
        gluOrtho2D( 0, ScreenWidth, ScreenHeigth, 0 );
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity( );
    }

    void CScreen::DrawPoint( int x, int y )
    {
        glVertex2d( x, y );
    }

    void CScreen::DrawLine( int x, int y, int x1, int x2 )
    {
        glPointSize( 1.0 );

        glVertex2d( x, y );

        glVertex2d( x1, x2 );
    }

    void CScreen::DrawMesh( )
    {
        Set2DMode( );
        glPushMatrix( );
        glColor3d( 0, 0, 0 );
        glBegin( GL_LINES );

        for( int i = CellSize; i < ScreenWidth; i += CellSize )
        {
            DrawLine( i, ScreenHeigth, i, -ScreenWidth );
        }

        for( int i = CellSize; i < ScreenHeigth; i += CellSize )
        {
            DrawLine( -ScreenHeigth, i, ScreenWidth, i );
        }

        glEnd( );
        glPopMatrix( );
    }

    void CScreen::DrawPlayersPoints( )
    {
        Set2DMode( );
        glPushMatrix( );
        glPointSize( ( float )CellSize * 0.4 );
        for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
        {
            if( it->IsOppo( &CGlobals::m_LocalPlayer ) )
            {
                glColor3d( 255, 0, 0 );
            }
            else
            {
                glColor3d( 0, 255, 0 );
            }

            glBegin( GL_POINTS );

            cml::vector2i nearest = CScreen::GetNearestPoint( it->GetPoint( )->To2DVector( ) );

            CScreen::DrawPoint( nearest[ 0 ], nearest[ 1 ] );

            glEnd( );
        }

        glPopMatrix(  );
    }

    void CScreen::DrawAreas( )
    {
        Set2DMode( );
        glPushMatrix( );
        glPointSize( 1.0 );

        PointInfoList vecPoints;

        for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
        {
            vecPoints.push_back( *it );

            CScreen::JoinNearestPoints( *it, vecPoints );
        }

        glPopMatrix( );
    }

    void CScreen::JoinNearestPoints( CPointInfo pointInfo, PointInfoList vecRealPoints )
    {
        cml::vector2i currentPoint = pointInfo.GetPoint()->To2DVector();

        for( auto it = vecRealPoints.begin( ); it < vecRealPoints.end( ); it++ )
        {
            Vector2DI nextPoint = it->GetPoint()->To2DVector( );

            if( currentPoint == nextPoint )
            {
                continue;
            }

            if( pointInfo.IsOppo( it->GetOwner( ) ) )
            {
                continue;
            }

            if( pointInfo.GetOwner( )->GetPlayerName( ) == CGlobals::m_LocalPlayer.GetPlayerName( ) )
            {
                SET_OWNER_COLOR;
            }
            else
            {
                SET_OPPO_COLOR;
            }

            glBegin( GL_LINES );

            float fDistance = Vector2DI( currentPoint - nextPoint ).length( );

            if( fDistance <= fHypo ) // PYTHAGORAAAAAAAAAAAAARTA
            {
                if( fDistance == fHypo )
                {
                    Vector2dList vecPoints = CScreen::GetNearestOppoCoords( pointInfo, vecRealPoints );

                    if( CScreen::GetNearestPointsCount( nextPoint, vecPoints ) == 2 )
                    {
                        continue;
                    }
                }

                DrawLine( currentPoint[0], currentPoint[1], nextPoint[0], nextPoint[1] );
            }

            glEnd( );
        }
    }

    int CScreen::GetNearestPointsCount( Vector2DI point, Vector2dList vecNearestPoints )
    {
        int count;

        for( auto it = vecNearestPoints.begin(); it < vecNearestPoints.end(); it++ )
        {
            if( Vector2F( point - *it ).length( ) < fHypo )
            {
                count++;
            }
        }

        return count;
    }

    Vector2dList CScreen::GetNearestOppoCoords( CPointInfo pointInfo, PointInfoList vecPointInfo )
    {
        Vector2dList vecPoints;

        cml::vector2i currentPoint = pointInfo.GetPoint()->To2DVector();

        for( auto it = vecPointInfo.begin( ); it < vecPointInfo.end( ); it++ )
        {
            if( pointInfo.IsOppo( it->GetOwner( ) ) )
            {
                cml::vector2i nextPoint = it->GetPoint( )->To2DVector( );

                if( cml::vector2d( currentPoint - nextPoint ).length( ) <= fHypo )
                {
                    vecPoints.push_back( nextPoint );
                }

                continue;
            }
        }

        return vecPoints;
    }

    void CScreen::RenderScene( )
    {
        glClear( GL_COLOR_BUFFER_BIT );

        DrawMesh( );
        DrawPlayersPoints( );
        DrawAreas( );

        glutSwapBuffers( );
    }

    void CScreen::UpdateScreen( int width, int heigth )
    {
        float fRatio;

        if( !heigth )
        {
            heigth = 1;
        }

        glViewport( 0, 0, width, heigth );
        glMatrixMode( GL_PROJECTION );

        glLoadIdentity( );

        fRatio = (float)width / (float)heigth;

        if( width <= heigth )
        {
            glOrtho( -100, 100, -100.0 / fRatio, 100.0 / fRatio, 1, -1 );
        }
        else
        {
            glOrtho( -100 * fRatio, 100 * fRatio, -100, 100, 1, -1 );
        }

        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity( );
    }

    Vector2DI CScreen::GetNearestPoint( CPoint point )
    {
        return CScreen::GetNearestPoint( Vector2DI( point.GetX(), point.GetY() ) );
    }

    Vector2DI CScreen::GetNearestPoint( Vector2DI point )
    {
        Vector2DI nearest( 0, 0 );

        for( int i = CellSize; i < ScreenWidth; i += CellSize )
        {
            for( int k = CellSize; k < ScreenHeigth; k += CellSize )
            {
                Vector2DI newPoint( i, k );

                if( (newPoint - point).length( ) < ( nearest - point ).length( ) )
                {
                    nearest = newPoint;
                }
            }
        }

        return nearest;
    }

    bool CScreen::HaveSamePoint( Vector2DI newPoint )
    {
        if( !CGlobals::m_vPointInfo.empty( ) )
        {
            for( auto it = CGlobals::m_vPointInfo.begin( ); it < CGlobals::m_vPointInfo.end( ); it++ )
            {
                Vector2DI oldPoint = it->GetPoint( )->To2DVector( );

                if( oldPoint == newPoint )
                {
                    return true;
                }
            }
        }

        return false;
    }
}