cWidget::Map Class Reference

Processes and renders a map of the grid. More...

#include <cMap.h>

Inheritance diagram for cWidget::Map:

[legend]

Collaboration diagram for cWidget::Map:

[legend]

List of all members.

Public Member Functions
void	HandleEvent (bool state, int id)
void	Render ()
	calls DrawMap()
virtual bool	Process (tXmlParser::node cur)
	Passes on to all Process() functions of the base classes and calls Base::DisplayError() on failure.
	Map ()
	default constructor
Private Types
enum	mode_t { MODE_STD, MODE_ZONE, MODE_CYCLE }
	mode is a var to manage minimap mode : More...
enum	rotation_t { ROTATION_FIXED, ROTATION_SPAWN, ROTATION_CYCLE, ROTATION_CAMERA }
	rotation mode More...
Private Member Functions
void	DrawRimWalls (tList< eWallRim > &list)
	Draws all the rim walls.
void	DrawWalls (tList< gNetPlayerWall > &list)
	Draws all player walls.
void	DrawObjects (tCoord scale)
	Draws all game objects.
void	DrawMap (bool rimWalls, bool cycleWalls, double cycleSize, double border, double x, double y, double w, double h, double rw, double rh, double ix, double iy)
	Draws the entire map.
void	ToggleMode (void)
	Toggles the display mode.
void	Apply (Mode const &mode)
Private Attributes
mode_t	m_mode
tCoord	m_centre
float	m_zoom
rotation_t	m_rotation
int	m_toggleKey
std::auto_ptr< Clipper >	m_clipper
std::vector< Mode >	m_modes
int	m_currentMode
Friends
class	ClipperRect
class	ClipperCircle
Classes
class	Clipper
class	ClipperCircle
class	ClipperRect
class	Mode

---

Detailed Description

Processes and renders a map of the grid.

Definition at line 50 of file cMap.h.

---

Member Enumeration Documentation

enum cWidget::Map::mode_t [private]

mode is a var to manage minimap mode :

Enumerator:

MODE_STD	the whole map
MODE_ZONE	using zoom factor and clipping centered on the closest zone, when there's no zone, switch to MODE_CYCLE
MODE_CYCLE	using zoom factor and clipping centered on the player position

Definition at line 73 of file cMap.h.

                 {
        MODE_STD, 
        MODE_ZONE, 
        MODE_CYCLE 
    } mode_t;

enum cWidget::Map::rotation_t [private]

rotation mode

Enumerator:

ROTATION_FIXED	default, no rotation
ROTATION_SPAWN	fixed in the direction of the last spawn point
ROTATION_CYCLE	always turn so the current cycle looks upwards
ROTATION_CAMERA	always look in the same direcion as the camera

Definition at line 79 of file cMap.h.

                 {
        ROTATION_FIXED, 
        ROTATION_SPAWN, 
        ROTATION_CYCLE, 
        ROTATION_CAMERA 
    } rotation_t;

---

Constructor & Destructor Documentation

cWidget::Map::Map

(

)

default constructor

Definition at line 463 of file cMap.cpp.

        :
        m_mode(MODE_STD),
        m_zoom(3),
        m_rotation(ROTATION_SPAWN),
        m_toggleKey(0),
        m_clipper(new ClipperRect()),
        m_currentMode(0)
{}

---

Member Function Documentation

void cWidget::Map::DrawRimWalls

(

tList< eWallRim > &

list

)

[private]

Draws all the rim walls.

Definition at line 371 of file cMap.cpp.

References rGradient::BeginDraw(), rGradient::DrawPoint(), eCoord, eWall::EndPoint(), eWallRim::GetBounds(), eRectangle::GetHigh(), eRectangle::GetLow(), glBegin, glEnd, GrowingArrayBase::Len(), cWidget::WithBackground::m_background, m_mode, max(), MODE_STD, se_rimWallRubberBand, rGradient::SetGradientEdges(), sr_alphaBlend, tCoord::x, and tCoord::y.

Referenced by DrawMap().

                                              {
    if(sr_alphaBlend && m_mode == MODE_STD) {
        const eRectangle &bounds = eWallRim::GetBounds();
        const tCoord dims = bounds.GetHigh() - bounds.GetLow();
        const float max = fmax(dims.x, dims.y); // make sure we get a square
        m_background.SetGradientEdges(bounds.GetLow(), tCoord(bounds.GetLow().x + max, bounds.GetLow().y + max));
        m_background.BeginDraw();
        glBegin(GL_POLYGON);
        for(std::vector<tCoord>::iterator iter = se_rimWallRubberBand.begin(); iter != se_rimWallRubberBand.end(); ++iter) {
            m_background.DrawPoint(*iter);
        }
        m_background.DrawPoint(se_rimWallRubberBand.front());
        glEnd();
    }
    glDisable(GL_TEXTURE_2D);
    glColor4f(1, 1, 1, .5);
    glBegin(GL_LINES);
    {
        for (int i=list.Len()-1; i >= 0; --i)
        {
            eWallRim *wall = list[i];
            eCoord begin = wall->EndPoint(0), end = wall->EndPoint(1);
            glVertex2f(begin.x, begin.y);
            glVertex2f(end.x, end.y);
        }


    }
    glEnd();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::Map::DrawWalls

(

tList< gNetPlayerWall > &

list

)

[private]

Draws all player walls.

Definition at line 402 of file cMap.cpp.

References gCycleMovement::Alive(), gRealColor::b, gNetPlayerWall::BegPos(), gCycle::color_, gNetPlayerWall::Coords(), gNetPlayerWall::Cycle(), eGameObject::DeathTime(), eCoord, gNetPlayerWall::EndPoint(), gNetPlayerWall::EndPos(), gRealColor::g, gCycleMovement::GetDistance(), glBegin, glEnd, GrowingArrayBase::Len(), gRealColor::r, se_GameTime(), gCycle::ThisWallsLength(), gCycle::WallsLength(), and gCycle::WallsStayUpDelay().

Referenced by DrawMap().

                                               {
    unsigned i, len=list.Len();
    double currentTime = se_GameTime();
    bool limitedLength = gCycle::WallsLength() > 0;
    double wallsStayUpDelay = gCycle::WallsStayUpDelay();
    glBegin(GL_LINES);
    for(i=0; i<len; i++) {
        gNetPlayerWall *wall = list[i];
        gCycle *cycle = wall->Cycle();
        if(!cycle) continue;
        double wallsLength = cycle->ThisWallsLength();
        double alpha = 1;
        if(!cycle->Alive() && wallsStayUpDelay >= 0) {
            alpha -= 2 * (currentTime - cycle->DeathTime() - wallsStayUpDelay);
            if(alpha <= 0) continue;
        }
        glColor4f(cycle->color_.r, cycle->color_.g, cycle->color_.b, alpha);
        double cycleDist = cycle->GetDistance();
        double minDist = limitedLength && cycleDist > wallsLength ? cycleDist - wallsLength : 0;
        const eCoord &begPos = wall->EndPoint(0), &endPos = wall->EndPoint(1);
        tArray<gPlayerWallCoord> &coords = wall->Coords();
        double begDist = wall->BegPos();
        double lenDist = wall->EndPos() - begDist;
        unsigned j, numcoords = coords.Len();
        if(numcoords < 2) continue;
        bool prevDangerous = coords[0].IsDangerous;
        double prevDist = coords[0].Pos;
        if(prevDist < minDist) prevDist = minDist;
        prevDist = (prevDist - begDist) / lenDist;
        for(j=1; j<numcoords; j++) {
            bool curDangerous = coords[j].IsDangerous;
            double curDist = coords[j].Pos;
            if(curDist < minDist) curDist = minDist;
            curDist = (curDist - begDist) / lenDist;
            if(prevDangerous) {
                glVertex2f(begPos.x + prevDist * (endPos.x - begPos.x), begPos.y + prevDist * (endPos.y - begPos.y));
                glVertex2f(begPos.x +  curDist * (endPos.x - begPos.x), begPos.y +  curDist * (endPos.y - begPos.y));
            }
            prevDangerous = curDangerous;
            prevDist = curDist;
        }
    }
    glEnd();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::Map::DrawObjects

(

tCoord

scale

)

[private]

Draws all game objects.

Definition at line 447 of file cMap.cpp.

References eGrid::CurrentGrid(), eGrid::GameObjects(), GrowingArrayBase::Len(), eGameObject::Render2D(), and tASSERT.

Referenced by DrawMap().

                                  {
    tList<eGameObject> const &gameObjects = eGrid::CurrentGrid()->GameObjects();
    size_t len = gameObjects.Len();
    for(size_t i = 0; i < len; ++i) {
        eGameObject const *obj = gameObjects(i);
        tASSERT(obj);
        obj->Render2D(scale);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::Map::DrawMap	(	bool	rimWalls,
		bool	cycleWalls,
		double	cycleSize,
		double	border,
		double	x,
		double	y,
		double	w,
		double	h,
		double	rw,
		double	rh,
		double	ix,
		double	iy
	)			[private]

Draws the entire map.

Definition at line 246 of file cMap.cpp.

References eCamera::CameraDir(), gCycle::Direction(), DrawObjects(), DrawRimWalls(), DrawWalls(), eWallRim::GetBounds(), cCockpit::GetFocusCycle(), eRectangle::GetHigh(), eRectangle::GetLow(), cCockpit::GetPlayer(), m_centre, m_clipper, cWidget::Base::m_Cockpit, m_mode, m_rotation, m_zoom, MODE_CYCLE, MODE_STD, MODE_ZONE, eGameObject::Position(), rotate(), ROTATION_CAMERA, ROTATION_CYCLE, ROTATION_SPAWN, se_rimWalls, sg_netPlayerWalls, sg_netPlayerWallsGridded, sg_Zones, gCycleMovement::SpawnDirection(), gCycleMovement::Speed(), tASSERT, tCoord::x, and tCoord::y.

Referenced by Render().

                                                              {
    double pl_CurSpeed, min_dist2, dist2, rad, zoom = 1;
    tCoord pl_CurPos, rotate; // rotate will hold the cos and sin of the rotation to apply
    cCockpit* cp = m_Cockpit;
    if(!rimWalls && !cycleWalls) return;
    const eRectangle &bounds = eWallRim::GetBounds();
    double lx = bounds.GetLow().x - border, hx = bounds.GetHigh().x + border;
    double ly = bounds.GetLow().y - border, hy = bounds.GetHigh().y + border;
    double mw = hx - lx, mh = hy - ly;
    double xpos, ypos, xscale, yscale;
    double xrat = (rw * mh) / (rh * mw);
    double yrat = (rh * mw) / (rw * mh);
    // set scale and position
    if(xrat > yrat) {
        xscale = (w * rh) / (mh * rw);
        yscale = h / mh;
    } else {
        xscale = w / mw;
        yscale = (h * rw) / (mw * rh);
    }
    rotate.x = 1; // no rotation
    rotate.y = 0;

    //do the rotation
    switch(m_rotation) {
    case ROTATION_SPAWN:
    if(!cp->GetFocusCycle()) { break; }
        rotate = cp->GetFocusCycle()->SpawnDirection().Turn(0,-1);
        break;
    case ROTATION_CYCLE:
    if(!cp->GetFocusCycle()) { break; }
        rotate = cp->GetFocusCycle()->Direction().Turn(0,-1);
        break;
    case ROTATION_CAMERA:
        {
            ePlayer const *player = cp->GetPlayer();
            if(!player) break;
            eCamera const *cam = player->cam;
            if(cam) {
                rotate = cam->CameraDir().Turn(0,-1);
            } else {
                rotate = tCoord(1, 0);
            }
        }
        break;
    default:
        rotate = tCoord(1, 0);
        break;
    }

    // manage mode
    switch (m_mode) {
    case MODE_ZONE:
    if(!cp->GetFocusCycle()) { break; }
        pl_CurPos = cp->GetFocusCycle()->Position();
        min_dist2 = (mw*mw+mh*mh)*1000;
        rad = 0;
        for(std::deque<gZone *>::const_iterator i = sg_Zones.begin(); i != sg_Zones.end(); ++i) {
            tASSERT(*i);
            tCoord const &position = (*i)->GetPosition();
            const float radius = (*i)->GetRadius();
            dist2 = (position-pl_CurPos).Norm();
            if (dist2<min_dist2) {
                min_dist2 = dist2;
                m_centre = position;
                rad = radius;
            }
        }
        rad = (rad<15)?15:rad;
        zoom = (w>h)?h/(yscale*m_zoom*rad):w/(xscale*m_zoom*rad);
        zoom = (zoom<1)?1:zoom;
        // check if at least 1 zone was found, if not, toggle to mode 2 ...
        if (rad==0) {
            m_mode = MODE_CYCLE;
        } else {
            break;
        }
    case MODE_CYCLE:
    if(!cp->GetFocusCycle()) { break; }
        m_centre = cp->GetFocusCycle()->Position();
        pl_CurSpeed = cp->GetFocusCycle()->Speed();
        zoom = (w>h)?h/(yscale*m_zoom*pl_CurSpeed):w/(xscale*m_zoom*pl_CurSpeed);
        zoom = (zoom<1)?1:zoom;
        break;
    default :
        zoom = 1;
        m_centre.x = lx + mw / 2;
        m_centre.y = ly + mh / 2;
        break;
    }
    xscale *=zoom;
    yscale *=zoom;
    xpos = x - m_centre.x * xscale + w / 2;
    ypos = y - m_centre.y * yscale + h / 2;
    if(m_mode != MODE_STD) {
        m_clipper->Begin(*this, tCoord(x,y), tCoord(x+w, y+h));
    }
    // set projection matrix
    glPushMatrix();
    glTranslatef(xpos, ypos, 0);
    glScalef(xscale, yscale, 1);
    // translate and rotate
    GLfloat r[16] = {
          rotate.x,  -rotate.y, 0, 0,
          rotate.y,   rotate.x, 0, 0,
                 0,          0, 1, 0,
        m_centre.x, m_centre.y, 0, 1};
    glMultMatrixf(r);
    glTranslatef(-m_centre.x,-m_centre.y,0);
    if(rimWalls)
        DrawRimWalls(se_rimWalls);
    if(cycleWalls) {
        DrawWalls(sg_netPlayerWallsGridded);
        DrawWalls(sg_netPlayerWalls);
    }
    DrawObjects(tCoord((cycleSize * w) / (rw * xscale), (cycleSize * h) / (rh * yscale)));
    glPopMatrix();
    if(m_mode != MODE_STD) {
        m_clipper->End();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::Map::ToggleMode

(

void

)

[private]

Toggles the display mode.

Definition at line 457 of file cMap.cpp.

References Apply(), m_currentMode, and m_modes.

Referenced by HandleEvent().

                         {
    if(m_modes.empty()) return;
    m_currentMode = (m_currentMode+1) % m_modes.size();
    Apply(m_modes[m_currentMode]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::Map::Apply

(

Mode const &

mode

)

[private]

Definition at line 214 of file cMap.cpp.

References cWidget::Map::Mode::m_clipper, m_clipper, cWidget::Map::Mode::m_mode, m_mode, cWidget::Map::Mode::m_rotation, m_rotation, cWidget::Map::Mode::m_zoom, and m_zoom.

Referenced by Process(), and ToggleMode().

                                {
    m_mode = mode.m_mode;
    m_rotation = mode.m_rotation;
    m_zoom = mode.m_zoom;
    m_clipper.reset((*mode.m_clipper)());
}

Here is the caller graph for this function:

void cWidget::Map::HandleEvent	(	bool	state,
		int	id
	)			[virtual]

Overwrite if you need to handle custom events (other than toggling)

Parameters:

	state	true if the key was pressed, false if it was released
	id	key id of the event that was received

Reimplemented from cWidget::Base.

Definition at line 220 of file cMap.cpp.

References HandleEvent(), m_toggleKey, and ToggleMode().

                                        {
    if(id == m_toggleKey) {
        if(state) {
            ToggleMode();
        }
    } else {
        Base::HandleEvent(state, id);
    }
}

Here is the call graph for this function:

void cWidget::Map::Render

(

)

[virtual]

calls DrawMap()

Implements cWidget::Base.

Definition at line 230 of file cMap.cpp.

References DrawMap(), glMatrixMode, cWidget::WithCoordinates::m_position, cWidget::WithCoordinates::m_size, sr_screenWidth, stc_forbidHudMap, tCoord::x, and tCoord::y.

                 {
    // I haven't checked possible initial matrix state, so init to identity and modelview
    if(stc_forbidHudMap) return; // the server doesn't want us to do that
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    glDisable(GL_LINE_SMOOTH);
    glHint (GL_LINE_SMOOTH_HINT, GL_FASTEST);
    DrawMap(true, true,
            5.5, 0.,
            m_position.x-m_size.x, m_position.y-m_size.y, 2.*m_size.x, 2.*m_size.y,
            sr_screenWidth*m_size.x, sr_screenWidth*m_size.y, .5, .5);
}

Here is the call graph for this function:

bool cWidget::Map::Process

(

tXmlParser::node

cur

)

[virtual]

Passes on to all Process() functions of the base classes and calls Base::DisplayError() on failure.

Reimplemented from cWidget::WithCoordinates.

Definition at line 168 of file cMap.cpp.

References cCockpit::AddEventHandler(), Apply(), cWidget::Base::DisplayError(), cWidget::Base::m_Cockpit, m_modes, m_toggleKey, cWidget::WithBackground::Process(), cWidget::WithForeground::Process(), and cWidget::WithCoordinates::Process().

                                    {
    if (
        WithCoordinates ::Process(cur) ||
        WithForeground ::Process(cur) ||
        WithBackground ::Process(cur))
        return true;
    if(cur.IsOfType("MapModes")) {
        int toggleKey;
        cur.GetProp("toggleKey", toggleKey);
        if(toggleKey > 0) {
            m_toggleKey = toggleKey;
            m_Cockpit->AddEventHandler(toggleKey, this);
        }
        for(cur = cur.GetFirstChild(); cur; ++cur) {
            if(cur.IsOfType("MapMode")) {
                m_modes.push_back(Mode(cur));
                if(m_modes.size() == 1) {
                    Apply(m_modes[0]); // apply the first mode and get rid of the defaults
                }
            }
        }
        return true;
    }
    DisplayError(cur);
    return false;
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class ClipperRect [friend]

Definition at line 106 of file cMap.h.

friend class ClipperCircle [friend]

Definition at line 116 of file cMap.h.

---

Member Data Documentation

mode_t cWidget::Map::m_mode [private]

Definition at line 85 of file cMap.h.

Referenced by Apply(), DrawMap(), and DrawRimWalls().

tCoord cWidget::Map::m_centre [private]

Definition at line 86 of file cMap.h.

Referenced by DrawMap().

float cWidget::Map::m_zoom [private]

Definition at line 87 of file cMap.h.

Referenced by Apply(), and DrawMap().

rotation_t cWidget::Map::m_rotation [private]

Definition at line 88 of file cMap.h.

Referenced by Apply(), and DrawMap().

int cWidget::Map::m_toggleKey [private]

Definition at line 90 of file cMap.h.

Referenced by HandleEvent(), and Process().

std::auto_ptr<Clipper> cWidget::Map::m_clipper [private]

Definition at line 117 of file cMap.h.

Referenced by Apply(), and DrawMap().

std::vector<Mode> cWidget::Map::m_modes [private]

Definition at line 127 of file cMap.h.

Referenced by Process(), and ToggleMode().

int cWidget::Map::m_currentMode [private]

Definition at line 128 of file cMap.h.

Referenced by ToggleMode().

---

The documentation for this class was generated from the following files:

• src/tron/cockpit/cMap.h
• src/tron/cockpit/cMap.cpp

---