Web alhem.net

MainWindow.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program 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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <stdincl.h>
#include <math.h>
#include <SDL_prim.h>

#include "defaults.h"
#include "Main.h"
#include "MenuDialog.h"
#include "OptionsDialog.h"
#include "LoginDialog.h"
#include "PlayerDialog.h"
#include "TextDialog.h"
#include "Globals.h"
#include "forms/Login.h"
#include "commands/Say.h"
#include "client.h"
#include "TestMenu.h"
#include "Player.h"
#include "events/Map.h"
#include "commands/Map.h"
#include "ConnectThread.h"
#include "Map.h"
#include "DotCursor.h"
#include "DotMenu.h"
#include "MainWindow.h"


#undef DEB
#ifdef _DEBUG
#define DEB(x) x
#else
#define DEB(x)
#endif


#define WARP 0
#define GLOW 0.15
#define GAP 2
#define WIREFRAME


Grid MainWindow::m_grid;


MainWindow::MainWindow(SDLControl *pclControl)
:gui::Surface(pclControl, 0 + WARP, 0 + WARP, pclControl -> GetScreen() -> w - WARP * 2, pclControl -> GetScreen() -> h - WARP * 2)
// colors
// fonts
#ifdef WIN32
,courier8("font.ttf", 15)
#else
,courier8("../gui/fonts/font.ttf", 15) //TIMES.TTF", 12)
#endif
// children
,m_guiInput(this, 0, 455, 640, 25)
// bmp
#ifdef USE_IMAGE
,m_image(SDL_LoadBMP("screenshots_big_7.bmp"))
,m_image_x(0)
,m_image_y(0)
#endif
,m_pclMenuDialog(NULL)
,m_pclOptionsDialog(NULL)
,m_pclLoginDialog(NULL)
,m_pclPlayerDialog(NULL)
,m_pclTextDialog(NULL)
,m_pclConnectThread(NULL)
,m_pclTestMenu(NULL)
,m_dotMenu(NULL)
,m_test_v(90)
,m_test_v_vertikal(90)
,m_dot(NULL)
,m_dc(this,0,0)
{
        // Grid calculation
        m_grid.SetSize(pclControl -> GetScreen() -> w,pclControl -> GetScreen() -> h);
        m_grid.SetBase( 50 );

        // Update palette if 8bpp
//      DEB(printf("Update8bitPalette()\n");)
//      pclControl -> Update8bitPalette();

        // Surface name
        SetText("Main Window");

        // Surface defaults
        SetBgColor(DEFAULT_BG_R,DEFAULT_BG_G,DEFAULT_BG_B);
        SetFgColor(DEFAULT_FG_R,DEFAULT_FG_G,DEFAULT_FG_B);
        SetTTFont(&courier8);
        SetFrameWidth(0);
        SetFrameColor(DEFAULT_BG_R,DEFAULT_BG_G,DEFAULT_BG_B);

        // init children
        //
        m_guiInput.SetBgColor( 255,255,255,0 );
        m_guiInput.SetFgColor( 0,0,0 );
        m_guiInput.SetFrameWidth(0);

        m_dc.SetVisible(false);

        // Add children to surface
        AddChild(&m_guiInput);
        AddChild(&m_dc);

        // 8-bit palett till alla ytor
//      DEB(printf("8-bit palett till alla ytor\n");)
//      Update8bitPalette();

        // Alpha
        SetAlpha(255);
        SetAlpha(SDL_ALPHA_OPAQUE, false);
#ifdef USE_IMAGE
        SDL_SetAlpha(m_image, SDL_RLEACCEL, SDL_ALPHA_OPAQUE);
#endif
}


MainWindow::~MainWindow()
{
        if (m_pclMenuDialog)
        {
                delete m_pclMenuDialog;
        }
        if (m_pclOptionsDialog)
        {
                delete m_pclOptionsDialog;
        }
        if (m_pclLoginDialog)
        {
                delete m_pclLoginDialog;
        }
        if (m_pclTextDialog)
        {
                delete m_pclTextDialog;
        }
        if (m_pclConnectThread)
        {
                delete m_pclConnectThread;
        }
        if (m_pclTestMenu)
        {
                delete m_pclTestMenu;
        }
        if (m_dotMenu)
        {
                delete m_dotMenu;
        }
        while (m_dots.size() > 0)
        {
                mapdots_t::iterator it = m_dots.begin();
                MAPDOT *x = *it;
                m_dots.erase(it);
                delete x;
        }
}


void MainWindow::AddLine(const string &str)
{
        if (m_pclTextDialog)
        {
                m_pclTextDialog -> AddLine(str);
        }
}


#ifdef USE_IMAGE
void MainWindow::MoveImage(int xrel,int yrel)
{
        int b = m_grid.GetBase();

/*
        if (xrel > 0)
                b++;
        if (xrel < 0)
                b--;
        m_grid.SetBase(b);
*/
        m_test_v_vertikal += yrel;
        m_test_v += xrel;

//      Draw();
        InvalidateEv();

/*
        m_image_x += xrel;
        m_image_y += yrel;
        m_image_x = (m_image_x < 0) ? 0 : m_image_x;
        m_image_y = (m_image_y < 0) ? 0 : m_image_y;

        m_image_x = (m_image_x + m_screen -> w > m_image -> w) ? m_image_x - (m_image_x + m_screen -> w - m_image -> w) : m_image_x;
        m_image_y = (m_image_y + m_screen -> h > m_image -> h) ? m_image_y - (m_image_y + m_screen -> h - m_image -> h) : m_image_y;
//      Draw();
*/
}
#endif


void MainWindow::ShowMenu()
{
        if (!m_pclMenuDialog)
        {
                m_pclMenuDialog = new MenuDialog( this );
                AddChild(m_pclMenuDialog);
        }
        else
        {
                m_pclMenuDialog -> SetVisible(true);
                m_pclMenuDialog -> BringToTop();
        }
        m_pclMenuDialog -> Connected(m_pclConnectThread ? "Disconnect" : "Connect");
//      m_pclMenuDialog -> DrawAll();
        m_pclMenuDialog -> InvalidateEv();
}


void MainWindow::ShowOptions()
{
        if (!m_pclOptionsDialog)
        {
                m_pclOptionsDialog = new OptionsDialog( this );
                AddChild(m_pclOptionsDialog);
        }
        else
        {
                m_pclOptionsDialog -> SetVisible(true);
                m_pclOptionsDialog -> BringToTop();
        }
        m_pclOptionsDialog -> UpdateData(false);
//      m_pclOptionsDialog -> DrawAll();
        m_pclOptionsDialog -> InvalidateEv();
}


void MainWindow::ShowLogin(Form::Form *pclForm)
{
        if (!m_pclLoginDialog)
        {
                m_pclLoginDialog = new LoginDialog( this );
                AddChild(m_pclLoginDialog);
        }
        else
        {
                m_pclLoginDialog -> SetVisible(true);
                m_pclLoginDialog -> BringToTop();
        }
        m_pclLoginDialog -> SetForm(pclForm);
        m_pclLoginDialog -> UpdateData(false);
//      m_pclLoginDialog -> DrawAll();
        m_pclLoginDialog -> InvalidateEv();
}


void MainWindow::ShowPlayers(Form::Form *pclForm,vector<string> &players)
{
        vector<string>::iterator it;
        if (!m_pclPlayerDialog)
        {
                m_pclPlayerDialog = new PlayerDialog(this);
                AddChild(m_pclPlayerDialog);
        }
        else
        {
                m_pclPlayerDialog -> SetVisible(true);
                m_pclPlayerDialog -> BringToTop();
        }
        m_pclPlayerDialog -> SetForm(pclForm);
        m_pclPlayerDialog -> Clear();
        for (it = players.begin(); it != players.end(); it++)
        {
                m_pclPlayerDialog -> AddButton(*it);
        }
//      m_pclPlayerDialog -> DrawAll();
        m_pclPlayerDialog -> InvalidateEv();
}


void MainWindow::ShowText()
{
        if (!m_pclTextDialog)
        {
                m_pclTextDialog = new TextDialog( this );
                AddChild(m_pclTextDialog);
        }
        else
        {
                m_pclTextDialog -> SetVisible(true);
                m_pclTextDialog -> BringToTop();
        }
//      m_pclTextDialog -> DrawAll();
        m_pclTextDialog -> InvalidateEv();
}


void MainWindow::OnEvent(surface_event_t *pstEvent)
{
        if (pstEvent -> type == GUI_EVENT_CLOSE)
        {
/*
                if (m_pclMenuDialog && pstEvent -> id == m_pclMenuDialog -> GetID())
                {
                        m_pclMenuDialog -> SetVisible(false);
                        m_pclMenuDialog -> InvalidateEv();
                }
                else
                if (m_pclOptionsDialog && pstEvent -> id == m_pclOptionsDialog -> GetID())
                {
                        m_pclOptionsDialog -> SetVisible(false);
                        m_pclOptionsDialog -> InvalidateEv();
                }
                else
*/
                if (m_pclLoginDialog && pstEvent -> id == m_pclLoginDialog -> GetID())
                {
                        Form::Form *pclForm = m_pclLoginDialog -> GetForm();
                        if (pclForm)
                        {
                                if (dynamic_cast<Form::Login *>(pclForm))
                                {
DEB(                    printf("SEND_LOGIN: pclForm is a Login\n");)
                                }
                                else
                                {
DEB(                    printf("SEND_LOGIN: pclForm is NOT a Login\n");)
                                }
                        }
                        else
                        {
DEB(            printf("SEND_LOGIN: pclForm is NULL\n");)
                        }
                        if (m_pclConnectThread)
                        {
DEB(            printf("SEND_LOGIN: BufMessage()\n");)
                                m_pclConnectThread -> BufMessage(pclForm);
                        }
                        else
                        {
DEB(            printf("SEND_LOGIN: m_pclConnectThread is NULL\n");)
                        }
                        m_pclLoginDialog -> SetVisible(false);
                        m_pclLoginDialog -> InvalidateEv();
                }
                else
                if (m_pclPlayerDialog && pstEvent -> id == m_pclPlayerDialog -> GetID())
                {
                        if (m_pclConnectThread)
                        {
                                Form::Form *pclForm = m_pclPlayerDialog -> GetForm();
                                m_pclConnectThread -> BufMessage(pclForm);
                        }
                        m_pclPlayerDialog -> SetVisible(false);
                        m_pclPlayerDialog -> InvalidateEv();
                }
                else
/*
                if (m_pclTextDialog && pstEvent -> id == m_pclTextDialog -> GetID())
                {
                        m_pclTextDialog -> SetVisible(false);
                        m_pclTextDialog -> InvalidateEv();
                }
                else
                if (m_pclTestMenu && pstEvent -> id == m_pclTestMenu -> GetID())
                {
                        m_pclTestMenu -> SetVisible(false);
                        m_pclTestMenu -> InvalidateEv();
                }
                else
*/
                {
                        // Auto...
                        for (surfacevector_t::iterator it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                        {
                                if (pstEvent -> id == (*it) -> GetID())
                                {
                                        (*it) -> SetVisible(false);
                                        (*it) -> InvalidateEv();
                                }
                        }
                }
        }
        else
        if (pstEvent -> type == GUI_EVENT_EDIT)
        {
                if (pstEvent -> id == m_guiInput.GetID())
                {
                        if (m_pclConnectThread)
                        {
                                Command::Say cmd(m_guiInput.GetLine());
                                m_pclConnectThread -> BufMessage(&cmd);
                        }
DEB(printf("Input: '%s'\n", m_guiInput.GetLine());)
                        m_guiInput.SetLine("");
                        m_guiInput.InvalidateEv();
                }
        }
}


void MainWindow::OnMouseMove(coord_t x,coord_t y,coord_t xrel,coord_t yrel)
{
        // find intersection or triangle
        mapdots_t::iterator it;
        MAPDOT *dot = NULL;

        for (it = m_dots.begin(); it != m_dots.end(); it++)
        {
                MAPDOT *d = *it;
                long xx = abs(d -> x - x);
                long yy = abs(d -> y - y);
                if (xx < 10 && yy < 10)
                {
                        dot = d;
                }
        }
        if (dot != m_dot)
        {
                if (m_dc.IsVisible())
                {
                        SDL_Rect a = m_dc.GetAbsoluteRect();
                        InvalidateRectEv(a);
                }               
        }
        m_dot = dot;
        if (m_dot)
        {
                m_dc.MoveTo(this, m_dot -> x - 5, m_dot -> y - 5);
        }
        else
        {
                m_dc.MoveTo(this, 0, 0, false);
        }
        if (dot)
        {
                m_dot = dot;
                m_dc.SetX(m_dot -> x - 5);
                m_dc.SetY(m_dot -> y - 5);
                m_dc.GetParent() -> CalculateAbsolute();
                m_dc.SetVisible(true);
                m_dc.InvalidateEv();
        }
        else
        {
                m_dot = dot;
                m_dc.SetVisible(false);
        }
}


void MainWindow::OnRightClick(coord_t x,coord_t y)
{
        if (m_dot)
        {
                if (!m_dotMenu)
                {
                        m_dotMenu = new DotMenu( this );
                        m_dotMenu -> SetX( m_dot -> x );
                        m_dotMenu -> SetY( m_dot -> y );
                        AddChild(m_dotMenu);
                        m_dotMenu -> InvalidateEv();
                        m_dc.Bond( m_dotMenu );
                }
                else
                {
                        if (m_dotMenu -> IsVisible())
                        {
                                SDL_Rect a = m_dotMenu -> GetAbsoluteRect();
                                InvalidateRectEv(a);
                        }
                        else
                        {
                                m_dotMenu -> SetVisible(true);
                        }
                        m_dotMenu -> SetX( m_dot -> x );
                        m_dotMenu -> SetY( m_dot -> y );
                        CalculateAbsolute();
                        m_dotMenu -> InvalidateEv();
                }
        }
        else
        {
                if (!m_pclTestMenu)
                {
                        m_pclTestMenu = new TestMenu( this );
                        m_pclTestMenu -> SetX( x );
                        m_pclTestMenu -> SetY( y );
                        AddChild(m_pclTestMenu);
                        m_pclTestMenu -> InvalidateEv();
                }
                else
                {
                        if (m_pclTestMenu -> IsVisible())
                        {
                                SDL_Rect a = m_pclTestMenu -> GetAbsoluteRect();
                                InvalidateRectEv(a);
                        }
                        else
                        {
                                m_pclTestMenu -> SetVisible(true);
                        }
                        m_pclTestMenu -> SetX( x );
                        m_pclTestMenu -> SetY( y );
                        CalculateAbsolute();
                        m_pclTestMenu -> InvalidateEv();
                }
        }
}


void MainWindow::Connect()
{
        if (m_pclConnectThread)
        {
printf("Already connected - disconnecting...\n");
                Disconnect();
                return;
        }
        if (!m_pclConnectThread)
        {
printf("Creating connect thread\n");
                m_pclConnectThread = new ConnectThread( (char *)Globals::m_host.c_str(), Globals::m_port);
        }
        else
        {
                pprintf("Already connected.\n");
        }
}


void MainWindow::Disconnect()
{
        if (m_pclConnectThread)
        {
printf("Deleteing connect thread\n");
                m_pclConnectThread -> SetRunning(false);
                SDL_Delay(1000);
                delete m_pclConnectThread;
                m_pclConnectThread = NULL;
        }
        else
        {
                pprintf("Not connected.\n");
        }
}


Surface *MainWindow::GetInput()
{
        return &m_guiInput;
}


void MainWindow::SetAngles(double a1,double a2)
{
        m_test_v = a1;
        m_test_v_vertikal = a2;

//      Draw();
//      InvalidateEv();
        SetDirty(true);
}


void MainWindow::IncreaseBase()
{
        int b = m_grid.GetBase();

        b++;
        m_grid.SetBase(b);

//      Draw();
//      Invalidate();
        SetDirty(true);
}


void MainWindow::DecreaseBase()
{
        int b = m_grid.GetBase();

        b--;
        if (b > 0)
        {
                m_grid.SetBase(b);
        }

//      Draw();
//      Invalidate();
        SetDirty(true);
}


void MainWindow::Redraw()
{
//      Draw();
//      Invalidate();
        SetDirty(true);
}


#ifdef USE_IMAGE
void MainWindow::Draw()
{
        SDL_Rect src;
        SDL_Rect dst;
        SDLControl *pcl = GetSDLControl();

        src.w = dst.w = pcl -> GetScreen() -> w;
        src.h = dst.h = pcl -> GetScreen() -> h;
        src.x = m_image_x;
        src.y = m_image_y;
        dst.x = 0;
        dst.y = 0;
        SDL_BlitSurface(m_image, &src, m_screen, &dst);
}
#endif


void MainWindow::Draw()
{
#pragma warning("remember to reset m_self when disconnected from server")
#pragma warning("and player cache")
#pragma warning("and map cache")
#pragma warning("etc etc cache")
        Player *self = NULL;

printf("MainWindow::Draw()\n");
        if (!m_pclConnectThread || (self = m_pclConnectThread -> GetSelf()) == NULL)
        {
printf("Not drawing background, because..\n");
if (!m_pclConnectThread)
{
        printf(" * not connected\n");
}
else
if (!self)
{
        printf(" * self is NULL\n");
}
                SDL_FillRect(GetScreen(), GetClientRectPtr(), SDL_MapRGB(GetScreen() -> format, 224, 224, 192));
                return;
        }
        else
        {
printf("Drawing background!\n");
        }

        long xpos = self -> GetX();
        long ypos = self -> GetY();
#define CHUNKSIZE MAPSIZE
        long chunkx = xpos / CHUNKSIZE;
        long chunky = ypos / CHUNKSIZE;
        for (long x = chunkx - 1; x <= chunkx + 1; x++)
        {
                long cx = x * CHUNKSIZE;
                for (long y = chunky - 1; y <= chunky + 1; y++)
                {
                        long cy = y * CHUNKSIZE;
                        Map *map = m_pclConnectThread -> GetMap(cx, cy);
printf(" . map @ [%ld,%ld] is %s\n",cx,cy,map ? "ok" : "NULL");
                        if (!map)
                        {
                        // send request for version 0 always if not in cache
                                Command::Map cmd(cx,cy,0);
                                m_pclConnectThread -> BufMessage(&cmd);
//#pragma warning("add an empty map section (chunk) for [cx,cy] in map cache to avoid")
//#pragma warning("multiple requests for same section")
printf("adding empty section\n");
fflush(stdout);
                                m_pclConnectThread -> AddMap(cx, cy);
#pragma warning("how to re-request this section if we don't get it?")
                        }
                        else
                        {
                        // bra bra, vi har den redan - kanske..
                        }
                }
        }

printf(" * done requesting map parts\n");

{
#ifdef WIREFRAME
        Uint32 color = GetFgColor();
#endif
        Uint32 light;
        int w = m_grid.GetWidth() / 2 + 2;
        int h = m_grid.GetHeight() / 2 + 2;
        double base = m_grid.GetBase(); // triangel sida horisontell
        double hbase = m_grid.GetHBase(); // triangel höjd
        int xpos1;
        int ypos1;
        int xpos2;
        int ypos2;
        int xpos3;
        int ypos3;
        int xpos4;
        int ypos4;
        int h1;
        int h2;
        int h3;
        int h4;
        double dh1,dh2,dh3,dh4;
        double hmitt;
        // horisontell infallsvinkel
//      double test_r = 2 * M_PI * m_test_v / 360;
        double r;
        double v;
        double aa;
        // vertikal infallsvinkel
//      double test_r_vertikal = 2 * M_PI * m_test_v_vertikal / 360;
        double r_vertikal;
        double v_vertikal;
        double aa_vertikal;
        //
        double aa2;
        double aa2_vertikal;

        if (SDL_MUSTLOCK(m_screen))
        {
                SDL_LockSurface(m_screen);
        }

        SDL_FillRect(m_screen, GetClientRectPtr(), GetBgColor());


        // 0,0   1,0   2,0   3,0
        //    0,1   1,1   2,1   3,1
        // 0,2   1,2   2,2   3,2
        //    0,3   1,3   2,3   3,3
        
        while (m_dots.size() > 0)
        {
                mapdots_t::iterator it = m_dots.begin();
                MAPDOT *x = *it;
                m_dots.erase(it);
                delete x;
        }
        m_dot = NULL;
        m_dc.SetVisible(false);
        m_dc.InvalidateEv();

        for (int y = -h; y <= h; y++)
        {
                long cy = ypos + y;

                for (int x = -w; x <= w; x++)
                {
                        long cx = xpos + x;

                        m_grid.GetXY(x,y,&xpos1,&ypos1,&h1);
                        h1 = Get_h(cx,cy);
                        ypos1 += h1;
                        dh1 = h1;
                        {
                                MAPDOT *dot = new MAPDOT;
                                dot -> x = xpos1;
                                dot -> y = ypos1;
                                dot -> cx = cx;
                                dot -> cy = cy;
                                m_dots.insert(m_dots.end(), dot);
                        }

                        if (y % 2)
                        {
                                m_grid.GetXY(x,y - 1,&xpos2,&ypos2,&h2);
                                h2 = Get_h(cx,cy - 1);
                        }
                        else
                        {
                                m_grid.GetXY(x - 1,y - 1,&xpos2,&ypos2,&h2);
                                h2 = Get_h(cx - 1,cy - 1);
                        }
                        ypos2 += h2;
                        dh2 = h2;

                        // vänster triangel - sittande
                        //  2
                        // 3 1
                        if (y % 2) // xpos ett halvt steg till höger
                        {
                                m_grid.GetXY(x - 1,y,&xpos3,&ypos3,&h3);
                                h3 = Get_h(cx - 1,cy);
                        }
                        else
                        {
                                m_grid.GetXY(x - 1,y,&xpos3,&ypos3,&h3);
                                h3 = Get_h(cx - 1,cy);
                        }
                        ypos3 += h3;
                        dh3 = h3;

                        // beräkna horisontell triangelvinkel
                        if (h3 > h1) // vadd+
                        {
                                r = atan((dh3 - dh1) / base);
                                v = 360 * r / (2 * M_PI);
                        }
                        else
                        if (h3 < h1) // vadd-
                        {
                                r = -atan((dh1 - dh3) / base);
                                v = 360 * r / (2 * M_PI);
                        }
                        else
                        {
                                r = 0;
                                v = 0;
                        }
                        // beräkna vertikal triangelvinkel
                        hmitt = (dh2 + dh3) / 2;
                        if (hmitt > h2)
                        {
                                r_vertikal = atan((hmitt - dh2) / hbase);
                                v_vertikal = 360 * r_vertikal / (2 * M_PI);
                        }
                        else
                        if (hmitt < h2)
                        {
                                r_vertikal = -atan((dh2 - hmitt) / hbase);
                                v_vertikal = 360 * r_vertikal / (2 * M_PI);
                        }
                        else
                        {
                                r_vertikal = 0;
                                v_vertikal = 0;
                        }
                        // beräkna infallsvinklar
                        aa = m_grid.Sin(m_test_v + v);
                        aa2 = m_grid.Sin(90 + v_vertikal);
                        aa_vertikal = m_grid.Sin(m_test_v_vertikal + v_vertikal);
                        aa2_vertikal = m_grid.Sin(90 + v);
                        // night glow
                        if (aa < GLOW)
                        {
                                aa = GLOW;
                        }
                        if (aa_vertikal < GLOW)
                        {
                                aa_vertikal = GLOW;
                        }
                        light = SDL_MapRGB(m_screen -> format,
                                0,
                                (int)(255 * aa * aa2 * aa_vertikal * aa2_vertikal),
                                0);

#ifdef WIREFRAME
                        SDL_drawLine(m_screen, xpos1, ypos1, xpos2, ypos2, color);
                        SDL_drawLine(m_screen, xpos1, ypos1, xpos3, ypos3, color);
                        SDL_drawLine(m_screen, xpos2, ypos2, xpos3, ypos3, color);
#else
                        SDL_fillTriangle(m_screen, xpos1-GAP, ypos1-GAP, xpos2, ypos2+GAP, xpos3+GAP, ypos3-GAP, light);
#endif

                        // höger triangel - stående
                        // 2 4
                        //  1
                        if (y % 2) // xpos ett halvt steg till höger
                        {
                                m_grid.GetXY(x + 1,y - 1,&xpos4,&ypos4,&h4);
                                h4 = Get_h(cx + 1,cy - 1);
                        }
                        else
                        {
                                m_grid.GetXY(x,y - 1,&xpos4,&ypos4,&h4);
                                h4 = Get_h(cx, cy - 1);
                        }
                        ypos4 += h4;
                        dh4 = h4;

                        // beräkna horisontell triangelvinkel
                        if (h2 > h4) // vadd+
                        {
                                r = atan((dh2 - dh4) / base);
                                v = 360 * r / (2 * M_PI);
                        }
                        else
                        if (h2 < h4) // vadd-
                        {
                                r = -atan((dh4 - dh2) / base);
                                v = 360 * r / (2 * M_PI);
                        }
                        else
                        {
                                r = 0;
                                v = 0;
                        }
                        // beräkna vertikal triangelvinkel
                        hmitt = (dh2 + dh4) / 2;
                        if (hmitt > h1)
                        {
                                r_vertikal = -atan((hmitt - dh1) / hbase);
                                v_vertikal = 360 * r_vertikal / (2 * M_PI);
                        }
                        else
                        if (hmitt < h1)
                        {
                                r_vertikal = atan((dh1 - hmitt) / hbase);
                                v_vertikal = 360 * r_vertikal / (2 * M_PI);
                        }
                        else
                        {
                                r_vertikal = 0;
                                v_vertikal = 0;
                        }
                        // beräkna infallsvinklar
                        aa = m_grid.Sin(m_test_v + v);
                        aa2 = m_grid.Sin(90 + v_vertikal);
                        aa_vertikal = m_grid.Sin(m_test_v_vertikal + v_vertikal);
                        aa2_vertikal = m_grid.Sin(90 + v);
                        // night glow
                        if (aa < GLOW)
                        {
                                aa = GLOW;
                        }
                        if (aa_vertikal < GLOW)
                        {
                                aa_vertikal = GLOW;
                        }
                        light = SDL_MapRGB(m_screen -> format,
                                0,
                                (int)(255 * aa * aa2 * aa_vertikal * aa2_vertikal),
                                0);
#ifdef WIREFRAME
                        SDL_drawLine(m_screen, xpos1, ypos1, xpos2, ypos2, color);
                        SDL_drawLine(m_screen, xpos1, ypos1, xpos4, ypos4, color);
                        SDL_drawLine(m_screen, xpos2, ypos2, xpos4, ypos4, color);
#else
                        SDL_fillTriangle(m_screen, xpos1, ypos1-GAP, xpos2+GAP, ypos2+GAP, xpos4-GAP, ypos4+GAP, light);
#endif

                } // for (x...)
        } // for (y...)
        for (mapdots_t::iterator it = m_dots.begin(); it != m_dots.end(); it++)
        {
                MAPDOT *dot = *it;
                // En liten cirkel vid varje punkt
//#define WIREFRAME
#ifdef WIREFRAME
                SDL_fillCircle(m_screen, dot -> x, dot -> y, 2, SDL_MapRGB(m_screen -> format, 255, 255, 255));
#endif
        }
        if (SDL_MUSTLOCK(m_screen))
        {
                SDL_UnlockSurface(m_screen);
        }
}
}


int MainWindow::Get_h(long x,long y)
{
        Map *map = m_pclConnectThread -> GetMap(x,y);
        return map ? map -> Get_h(x,y) : 0;
}


int MainWindow::Get_t_left(long x,long y)
{
        Map *map = m_pclConnectThread -> GetMap(x,y);
        return map -> Get_t_left(x,y);
}


int MainWindow::Get_t_up(long x,long y)
{
        Map *map = m_pclConnectThread -> GetMap(x,y);
        return map -> Get_t_up(x,y);
}

---