//======== (C) Copyright 1999, 2000 Valve, L.L.C. All rights reserved. ========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose: 
//
// $Workfile:     $
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "hud_minimap.h"
#include <vgui_controls/Controls.h>
#include <vgui/ISurface.h>
#include <vgui/IVGui.h>
#include <vgui/IInput.h>
#include <vgui_controls/AnimationController.h>
#include "vgui_BitmapImage.h"
#include "clientmode_tfbase.h"
#include "clientmode_tfnormal.h"
#include "hud.h"
#include "hud_commander_statuspanel.h"
#include "view.h"
#include "filesystem.h"
#include "imessagechars.h"
#include "hud_macros.h"
#include "parsemsg.h"
#include "c_tfteam.h"
#include "c_info_act.h"
#include "engine/IEngineSound.h"
#include "iinput.h"
#include "in_buttons.h"
#include "c_basetfplayer.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

static ConVar minimap_visible( "minimap_visible", "1", 0, "Draw minimap?" );
ConVar minimap_zoomtime( "minimap_zoomtime", "0.4", 0, "How long it takes to resize the minimap." );


static ConVar current_team( "current_team", "-1", 0 );

// Start out new maps at this zoom level
#define DEFAULT_ZOOM_LEVEL	0

void __MsgFunc_MinimapPulse(const char *pszName, int iSize, void *pbuf);

using namespace vgui;

//-----------------------------------------------------------------------------
// Instantiate a temporary trace (position based, or entity based)
//-----------------------------------------------------------------------------
void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, const Vector &vecPosition )
{
	MinimapInitData_t initData;
	initData.m_vecPosition = vecPosition;

	PanelMetaClassMgr()->CreatePanelMetaClass( 
		pMetaClassName, sortOrder, &initData, CMinimapPanel::MinimapRootPanel() );
}

void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, C_BaseEntity *pEntity, const Vector &vecOffset )
{
	MinimapInitData_t initData;
	initData.m_pEntity = pEntity;
	initData.m_vecPosition = vecOffset;

	PanelMetaClassMgr()->CreatePanelMetaClass( 
		pMetaClassName, sortOrder, &initData, CMinimapPanel::MinimapRootPanel() );
}



//-----------------------------------------------------------------------------
// dummy root panel for all minimap traces
//-----------------------------------------------------------------------------
class CMinimapRootPanel : public Panel
{
	typedef Panel BaseClass;

public:
	CMinimapRootPanel( Panel *pParent = NULL ) 
		: BaseClass( pParent,"CMinimapRootPanel" ) 
	{
		SetPaintBackgroundEnabled( false );
		SetPaintEnabled( false );
		SetAutoDelete( false );
	}
};

class CTextHelpPanel : public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CTextHelpPanel, vgui::Panel )

public:
	
	CTextHelpPanel();

	virtual void Paint();
	virtual void PaintBackground();

	void	SetImage( BitmapImage *image );

	virtual void ApplySettings( KeyValues *inResourceData )
	{
		BaseClass::ApplySettings( inResourceData );
	}

private:

	BitmapImage		*m_pImage;

	CPanelAnimationVar( Color, m_OverlayColor, "OverlayColor", "White" );
	CPanelAnimationVar( Color, m_BorderColor, "BorderColor", "BrightFg" );
	CPanelAnimationVar( Color, m_BackgroundColor, "BackgroundColor", "Black" );
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTextHelpPanel::CTextHelpPanel()
: BaseClass( NULL, "HudMinimapTextHelpPanel" )
{
	Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );

	SetVisible( false );
	SetZPos( 1 );

	m_pImage = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTextHelpPanel::PaintBackground()
{
	// Get alpha from image
	if ( m_pImage )
	{
		Color bg = m_BackgroundColor;
		int r, g, b, a;
		m_pImage->GetColor( r, g, b, a );
		bg[3] = a;
		SetBgColor( bg );
	
		BaseClass::PaintBackground();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTextHelpPanel::Paint()
{
	BaseClass::Paint();

	if ( !m_pImage )
		return;

	m_pImage->SetColor( m_OverlayColor );
	m_pImage->DoPaint( GetVPanel() );

	int w, h;
	GetSize( w, h );

	surface()->DrawSetColor( m_BorderColor );
	surface()->DrawOutlinedRect( 0, 0, w, h );
	surface()->DrawOutlinedRect( 1, 1, w-1, h-1 );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *image - 
//			x - 
//			y - 
//			w - 
//			h - 
//-----------------------------------------------------------------------------
void CTextHelpPanel::SetImage( BitmapImage *image )
{
	m_pImage = image;
}

//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// All traces are children of this panel
//-----------------------------------------------------------------------------
Panel *CMinimapPanel::MinimapRootPanel()
{
	static CMinimapRootPanel s_MinimapRootPanel;
	return &s_MinimapRootPanel; 
}

CMinimapPanel *CMinimapPanel::MinimapPanel()
{
	ClientModeTFBase *pBasemode = ( ClientModeTFBase * )g_pClientMode;
	if ( !pBasemode )
		return NULL;

	return pBasemode->GetMinimap();
}

DECLARE_HUDELEMENT( CMinimapPanel );

//-----------------------------------------------------------------------------
// Purpose: Placeholder for small overview map with viewport rectangle/selector
//-----------------------------------------------------------------------------
CMinimapPanel::CMinimapPanel( const char *pElementName )
: CHudElement( pElementName ), BaseClass( NULL, "HudMinimap" )
{
	Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );

	SetAutoDelete( false );
	for ( int i = 0; i < MAX_ACT_TEAMS; i++ )
	{
		m_pBackground[ i ] = 0;
	}
	memset( m_rgOverlays, 0, sizeof( m_rgOverlays ) );

	m_flExpansionFrac = 0.0f;

	// Minimap zoom
	m_bMinimapZoomed = false;
	m_nZoomLevel = DEFAULT_ZOOM_LEVEL;

	m_vecCurrentOrigin.Init();
	m_vecMapCenter.Init();
	m_flMapAspectRatio = 1.0f;
	m_flViewportAspectRatio = 1.0f;
	m_flAspectAdjustment = 1.0f;
	m_flNormalizedXScale = 1.0f;
	m_flNormalizedYScale = 1.0f;
	m_flNormalizedXOffset = 0.0f;
	m_flNormalizedYOffset = 0.0f;

	m_nCurrentAct = ACT_NONE_SPECIFIED;

	m_pTextPanel = new CTextHelpPanel();
	m_pBackgroundPanel = new Panel( NULL, "BackgroundPanel" );

	// We're gonna manage the lifetime of the text panel
	// since we change it's hierarchical connections from time to time
	m_pTextPanel->SetAutoDelete( false );
	m_pBackgroundPanel->SetAutoDelete( false );
	SetAutoDelete( false );
	
	m_pClient = NULL;

	m_flZoomAdjust = 1.0f;
	m_flPrevZoomAmount = 0.01f;

	SetZPos( 10 );

	ivgui()->AddTickSignal( GetVPanel() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CMinimapPanel::~CMinimapPanel( void )
{
	delete m_pTextPanel;
	delete m_pBackgroundPanel;

	for ( int i = 0; i < MAX_ACT_TEAMS; i++ )
	{
		delete m_pBackground[ i ];
	}

	ShutdownOverlays();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *scheme - 
//-----------------------------------------------------------------------------
void CMinimapPanel::ApplySchemeSettings( IScheme *scheme )
{
	BaseClass::ApplySchemeSettings( scheme );
	SetPaintBackgroundEnabled( false );
}


//-----------------------------------------------------------------------------
// initialization
//-----------------------------------------------------------------------------
void CMinimapPanel::Init( IMinimapClient* pClient )
{
	m_pClient = pClient;
}

//-----------------------------------------------------------------------------
// Call this when the minimap panel is going to be drawn...
//-----------------------------------------------------------------------------
void CMinimapPanel::Activate()
{
	// The panel is a view into the minimap root panel
	MinimapRootPanel()->SetParent( this );

	Panel *pParent = g_pClientMode->GetViewport();

	if ( pParent && m_pBackgroundPanel )
	{
		m_pBackgroundPanel->SetParent( pParent );
		m_pBackgroundPanel->SetBounds( XRES( 0 ), YRES( 0 ), XRES( 640 ), YRES( 480 ) );
		m_pBackgroundPanel->SetVisible( false );
		m_pBackgroundPanel->SetZPos( 0 );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : w - 
//			h - 
//-----------------------------------------------------------------------------
void CMinimapPanel::OnSizeChanged( int w, int h )
{
	BaseClass::OnSizeChanged( w, h );

	MinimapRootPanel()->SetSize( w, h );

	// Make sure icons are snapped to current window size
	InvokeOnTickOnChildren( this );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float CMinimapPanel::GetAdjustedZoom( void )
{
	return m_flZoomAmount * m_flZoomAdjust;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float CMinimapPanel::GetTrueZoom()
{
	return m_flZoomAmount;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : center - 
//			scale - 
//-----------------------------------------------------------------------------
void CMinimapPanel::GetMapOriginAndScale( Vector& origin, float& scale )
{
	origin	= m_vecCurrentOrigin;
	scale	= GetAdjustedZoom();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : clip - 
//			pos - 
//			outx - 
//			outy - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMinimapPanel::WorldToMinimap( MinimapPosType_t posType, const Vector& pos, float& outx, float& outy )
{
	Vector origin;
	float zoomscale;

	GetMapOriginAndScale( origin, zoomscale );

	return InternalWorldToMinimap( posType, pos, origin, zoomscale, outx, outy );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : x - 
//			y - 
//-----------------------------------------------------------------------------
void CMinimapPanel::AdjustNormalizedPositionForAspectRatio( float& x, float& y )
{
	x = m_flNormalizedXOffset + x * m_flNormalizedXScale;
	y = m_flNormalizedYOffset + y * m_flNormalizedYScale;
}

//-----------------------------------------------------------------------------
// Converts a world-space position to a coordinate in minimap panel space
//-----------------------------------------------------------------------------
bool CMinimapPanel::InternalWorldToMinimap( MinimapPosType_t posType, const Vector &pos, const Vector& origin, float zoomscale, float& outx, float& outy )
{
	int wide, tall;
	MinimapRootPanel()->GetSize( wide, tall );

	Vector worldmins, worldmaxs;
	MapData().GetMapBounds( worldmins, worldmaxs );
	Vector worldsize = worldmaxs - worldmins;

	Vector test = ( pos -  origin );

	float xfraction = 0.0f;
	
	if ( worldsize.x > 0 )
	{
		xfraction = (test.x - worldmins.x) / (worldmaxs.x - worldmins.x);
	}

	float yfraction = 0.0f;
	
	if ( worldsize.y > 0 )
	{
		yfraction = (test.y - worldmins.y) / (worldmaxs.y - worldmins.y);
	}

	xfraction = ( xfraction - 0.5f ) * zoomscale + 0.5f; 
	yfraction = ( yfraction - 0.5f ) * zoomscale + 0.5f;

	yfraction = 1.0f - yfraction;

	// Adjust in case not all of map can be shown
	AdjustNormalizedPositionForAspectRatio( xfraction, yfraction );

	// Normalize?
	bool inside = true;
	switch ( posType )
	{
	case MINIMAP_CLIP:
		{
			// Clip the vector from minimap center to object
			// to the minimap bounds and put the object on the edge
			Vector2D delta( xfraction - 0.5f, yfraction - 0.5f );
			Vector2D fdelta( fabs(delta.x), fabs(delta.y) );
			if (fdelta.x > fdelta.y)
			{
				// It's more horizontal than vertical..
				if (fdelta.x >= 0.5f)
				{
					float flRatio = delta.y / delta.x;
					xfraction = clamp(xfraction, 0, 1);
					yfraction = (xfraction - 0.5f) * flRatio + 0.5f;
				}
			}
			else
			{
				if (fdelta.y >= 0.5f)
				{
					// It's more vertical than horizontal
					float flRatio = delta.x / delta.y;
					yfraction = clamp(yfraction, 0, 1);
					xfraction = (yfraction - 0.5f) * flRatio + 0.5f;
				}
			}
		}
		break;

	case MINIMAP_CLAMP:
		{
			// Clamp the position to lie within the minimap
			xfraction = clamp(xfraction, 0, 1);
			yfraction = clamp(yfraction, 0, 1);
		}
		break;

	case MINIMAP_NOCLIP:
		{
			// See if it's off screen
			if ( xfraction < 0.0 || xfraction > 1.0 ||
				 yfraction < 0.0 || yfraction > 1.0 )
			{
				inside = false;
			}
		}
		break;
	}

	outx = xfraction * wide;
	outy = yfraction * tall;
	
	return inside;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *mapname - 
//-----------------------------------------------------------------------------
void CMinimapPanel::LevelInit( const char *mapname )
{
	SetBackgroundMaterials( MapData().m_Minimap.m_szBackgroundMaterial );

	m_nZoomLevel = DEFAULT_ZOOM_LEVEL;

	HOOK_MESSAGE( MinimapPulse );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::LevelShutdown( void )
{
}

//-----------------------------------------------------------------------------
// Sets the background material
//-----------------------------------------------------------------------------
void CMinimapPanel::SetBackgroundMaterials( const char *pMaterialName )
{
	int i;
	for ( i = 0; i < MAX_ACT_TEAMS; i++ )
	{
		delete m_pBackground[ i ];
		m_pBackground[ i ] = NULL;
	}

	if ( pMaterialName[ 0 ] )
	{
		for ( i = 0; i < MAX_ACT_TEAMS; i++ )
		{
			char teammaterial[ 512 ];

			Q_snprintf( teammaterial, sizeof( teammaterial ), "%s_team%i",
				pMaterialName, i + 1 );

			// If a _team# version exists, use that, otherwise, use the default
			if ( vgui::filesystem()->FileExists( VarArgs( "materials/%s.vmt", teammaterial ) ) )
			{
				 m_pBackground[ i ] = new BitmapImage( GetVPanel(), teammaterial );
			}
			else
			{
				 m_pBackground[ i ] = new BitmapImage( GetVPanel(), pMaterialName );
			}
		}
	}

	if ( m_pTextPanel )
	{
		m_pTextPanel->SetImage( NULL );
	}

	ShutdownOverlays();
	InitOverlays( pMaterialName );
}

//-----------------------------------------------------------------------------
// Called when the mouse is hit 
//-----------------------------------------------------------------------------
void CMinimapPanel::OnMousePressed(MouseCode code)
{
	if ((code == MOUSE_LEFT) && m_pClient)
	{
		// Convert mouse position to world position
		int x, y;
		vgui::input()->GetCursorPos( x, y );

		int w, h;
		GetSize( w, h );

		Vector worldPos;
		worldPos.x = (float) x / (float) w;
		worldPos.y = 1.0f - (float) y / (float) h;
		worldPos.z = 0;	// z isn't used

		Vector worldMins, worldMaxs;
		MapData().GetMapBounds( worldMins, worldMaxs );
		worldPos *= (worldMaxs - worldMins);
		worldPos += worldMins;

		m_pClient->MinimapClicked( worldPos );
	}
}

void CMinimapPanel::SetBackgroundViewport( float minx, float miny, float maxx, float maxy, bool includedetails )
{
	int i;
	int x, y, w, h;

	x = 0;
	y = 0;
	w = GetWide();
	h = GetTall();

	if ( minx < 0.0f || maxx > 1.0f ||
		 miny < 0.0f || maxy > 1.0f )
	{
		float x0 = 0.0f;
		float y0 = 0.0f;
		float x1 = 1.0f;
		float y1 = 1.0f;

		float xrange = maxx - minx;
		float yrange = maxy - miny;

		if ( minx < 0.0f )
		{
			x0 = -minx / xrange;
			//xrange += minx;
			maxx -= minx;
			minx = 0.0f;
		}
		if ( maxx > 1.0f )
		{
			x1 = 1.0f - ( maxx - 1.0f ) / xrange;
			maxx = 1.0f;
		}
		if ( miny < 0.0f )
		{
			y0 = -miny / yrange;
			//yrange += miny;
			maxy -= miny;
			miny = 0.0f;
		}
		if ( maxy > 1.0f )
		{
			y1 =  1.0f - ( maxy - 1.0f ) / yrange;
			maxy = 1.0f;
		}

		x = x0 * w;
		y = y0 * h;
		w = x1 * w;
		h = y1 * h;
	}

	for ( i = 0; i < MAX_ACT_TEAMS; i++ )
	{
		if ( m_pBackground[ i ] )
		{
			m_pBackground[ i ]->SetPos( x, y );
			m_pBackground[ i ]->SetRenderSize( w, h );
			m_pBackground[ i ]->SetViewport( true, minx, miny, maxx, maxy );
		}
	}

	if ( includedetails )
	{
		int t;
		for ( t = 0; t < MAX_ACT_TEAMS; t++ )
		{
			for ( i = 0; i < MAX_ACTS; i++ )
			{
				Overlays *p = &m_rgOverlays[ t ][ i ];
				if ( !p->m_bInUse )
					continue;

				if ( !p->m_pOverlay )
					continue;

				p->m_pOverlay->SetPos( x, y );
				p->m_pOverlay->SetRenderSize( w, h );
				p->m_pOverlay->SetViewport( true, minx, miny, maxx, maxy );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::PaintActOverlays( int teamIndex, int alpha )
{
	Assert( teamIndex >= 0 && teamIndex < MAX_ACT_TEAMS );

	bool textshowing = false;

	int i = GetCurrentActNumber();
	if ( i != ACT_NONE_SPECIFIED )
	{
		i = clamp( i, 0, MAX_ACTS - 1 );
		Overlays *p = &m_rgOverlays[ teamIndex ][ i ];
		if ( p->m_bInUse )
		{
			int r, g, b, a;

			if ( p->m_pOverlay )
			{
				p->m_pOverlay->GetColor( r, g, b, a );
				Color clr( r, g, b, alpha );
				p->m_pOverlay->SetColor( clr );
				p->m_pOverlay->DoPaint( NULL, 0, (float)alpha/255.0f );
			}

			if ( p->m_pText && m_pTextPanel )
			{
				p->m_pText->GetColor( r, g, b, a );
				Color clr( r, g, b, alpha );
				p->m_pText->SetColor( clr );

				m_pTextPanel->SetImage( p->m_pText );

				clr = m_BackgroundColor;
				clr[3] = alpha;
				m_pBackgroundPanel->SetBgColor( clr );
 
				textshowing = true;
			}				
		}
	}
	
	if ( !textshowing )
	{
		m_pTextPanel->SetVisible( false );
		m_pTextPanel->SetImage( NULL );
		m_pBackgroundPanel->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::OnThink()
{
	BaseClass::OnThink();

	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
	if ( local )
	{
		if ( local->m_TFLocal.m_bForceMapOverview && m_bMinimapZoomed != local->m_TFLocal.m_bForceMapOverview )
		{
			SetMinimapZoom( local->m_TFLocal.m_bForceMapOverview );
		}
	}

	if ( !IsVisible() )
		return;

	if ( m_flZoomAmount != m_flPrevZoomAmount )
	{
		m_flPrevZoomAmount = m_flZoomAmount;
		ComputeMapOrigin( m_vecCurrentOrigin );	
		InvokeOnTickOnChildren( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::Paint()
{
	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
	{
		// Remove the minimap zoom if the hud's hidden
		SetMinimapZoom( false );
		return;
	}

	C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();
	int team = 0;
	if ( local )
	{
		team = local->GetTeamNumber();
	}

	int w, h;
	GetSize( w, h );

	int alpha;
	bool shouldDrawDetails = ShouldDrawZoomDetails( alpha );

	if ( m_pTextPanel && m_pBackgroundPanel )
	{
		m_pTextPanel->SetVisible( shouldDrawDetails );
		m_pBackgroundPanel->SetVisible( shouldDrawDetails );
	}

	// DEBUGGING:  Allow cvar override
	if ( current_team.GetInt() >= 0 )
	{
		team = current_team.GetInt();
	}

	// Can can be 0 through MAX_ACT_TEAMS
	team = clamp( team, 0, MAX_ACT_TEAMS );

	// Array index is 0 to MAX_ACT_TEAMS - 1 where a team of zero means no team and won't be indexed
	//  due to logic that checks team > 0 
	int teamIndex = clamp( team - 1, 0, MAX_ACT_TEAMS - 1 );

	if ( m_pBackground[ teamIndex ] )
	{
		if ( shouldDrawDetails )
		{
			Color clr = m_BackgroundColor;
			clr[3] *= alpha / 255.0f;
			surface()->DrawSetColor( clr );
			surface()->DrawFilledRect( 0, 0, w, h );
		}

		float offsetx, offsety;

		// Need to translate m_vecCurrentOrigin into minimap space
		InternalWorldToMinimap( 
			MINIMAP_NOCLIP, 
			m_vecCurrentOrigin,
			-m_vecMapCenter,
			1,
			offsetx, offsety );

		// Scale to 0.0f to 1.0f
		offsetx /= (float)w;
		offsety /= (float)h;

		float minx, maxx, miny, maxy;

		float xscale = 1.0f;
		float yscale = 1.0f;
		float startx = 0.0f;
		float starty = 0.0f;

		Assert( m_flAspectAdjustment > 0.0f );

		// Note, the scale sense is inverted here
		float invaspect = 1.0f / m_flAspectAdjustment;

		if ( m_flAspectAdjustment < 1.0f )
		{
			xscale = invaspect;
			startx = ( 1.0f - xscale ) * 0.5f;
		}
		else
		{
			yscale = m_flAspectAdjustment;
			starty = ( 1.0f - yscale ) * 0.5f;
		}

		float halfzoom = ( 1.0f / GetAdjustedZoom() ) * 0.5f;

		// zoom scale is already normalized, so just take half in one direction, half the other
		minx = startx + xscale * ( offsetx - halfzoom );
		miny = starty + yscale * ( offsety - halfzoom );
		maxx = startx + xscale * ( offsetx + halfzoom );
		maxy = starty + yscale * ( offsety + halfzoom );

		SetBackgroundViewport( minx, miny, maxx, maxy, shouldDrawDetails );

		m_pBackground[ teamIndex ]->DoPaint( NULL );

		if ( shouldDrawDetails && ( team > 0 ) )
		{
			PaintActOverlays( teamIndex, alpha );
		}
	}
	else
	{
		Color clr = m_BackgroundColor;
		clr[3] *= alpha * 0.9f / 255.0f;

		surface()->DrawSetColor( clr );
		surface()->DrawFilledRect( 0, 0, w, h );
	}

	// Dumb place to do this
	if ( !shouldDrawDetails && CurrentActIsAWaitingAct() )
	{
		char *cmsg = "Wait for game start...";
		int width, height;
		messagechars->GetStringLength( g_hFontTrebuchet24, &width, &height, cmsg );
		messagechars->DrawString( g_hFontTrebuchet24, XRES(16), ScreenHeight() - (height * 6), 255, 255, 245, 255, cmsg, IMessageChars::MESSAGESTRINGID_NONE );
	}

	Color border = m_BorderColor;
	border[3] = border[3] * ( alpha * 0.9f ) / 255.0f;

	//border = vgui::Color( 255, 0, 120, 255 );

	surface()->DrawSetColor( border );
	surface()->DrawOutlinedRect( 0, 0, w, h );
	surface()->DrawOutlinedRect( 1, 1, w-1, h-1 );
}

void CMinimapPanel::InvokeOnTickOnChildren( vgui::Panel *parent )
{
	if ( !parent )
		return;

	int c = parent->GetChildCount();
	int i;
	for ( i = 0; i < c; i++ )
	{
		vgui::Panel *child = parent->GetChild( i );
		child->OnTick();
		InvokeOnTickOnChildren( child );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::OnTick()
{
	// See if the act's changed. If it has, bring up the act overlays.
	if ( m_nCurrentAct != GetCurrentActNumber() )
	{
	//	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "MinimapActChanged" );
	//	SetMinimapZoom( true );
		m_nCurrentAct = GetCurrentActNumber();
	}

	// Cache these only once per frame if in a valid game
	if ( C_BasePlayer::GetLocalPlayer() && minimap_visible.GetBool() )
	{
		SetVisible( true );
		ComputeMapOrigin( m_vecCurrentOrigin );	
	}
	else
	{
		SetVisible( false );
	}

	InvokeOnTickOnChildren( this );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : alpha - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMinimapPanel::ShouldDrawZoomDetails( int& alpha )
{
	alpha = (int)m_flDetailsAlpha;
	alpha = clamp( alpha, 0, 255 );

	if ( !alpha )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : center - 
//-----------------------------------------------------------------------------
void CMinimapPanel::ComputeMapOrigin( Vector& origin )
{
	Vector worldmins, worldmaxs, worldsize;
	MapData().GetMapBounds( worldmins, worldmaxs );
	VectorSubtract( worldmaxs, worldmins, worldsize );

	// Cache true map center
	m_vecMapCenter = ( worldmins + worldmaxs ) * 0.5f;

	C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();

	Vector playerOrigin; 

	if( !pPlayer )
	{
		playerOrigin = m_vecMapCenter;
	}
	else
	{
		playerOrigin = pPlayer->GetAbsOrigin();
	}

	origin.Init();
	 
	playerOrigin.z = m_vecMapCenter.z = 0.0f;

	Vector delta = playerOrigin - m_vecMapCenter;

	// Map center pointer is biased toward player origin as we become zoomed in to 1.0x to 2.5x and toward true world center as we zoom all the way out
	VectorScale( delta, m_flCenterOnPlayer, origin );

	int vw, vh;
	GetSize( vw, vh );

	m_flMapAspectRatio = 1.0f;
	m_flViewportAspectRatio = 1.0f;
	m_flAspectAdjustment = 1.0f;

	if ( vh > 0 )
	{
		m_flViewportAspectRatio = ( float )vw / ( float )vh;
	}

	if ( worldsize.y > 0 )
	{
		m_flMapAspectRatio = worldsize.x / worldsize.y;
	}

	if ( m_flViewportAspectRatio > 0 )
	{
		m_flAspectAdjustment = m_flMapAspectRatio / m_flViewportAspectRatio;
	}

	float fittedworldunitsperpixel;
	float zoomedworldunitsperpixel;
	float zooomedoutworldunitsperpixel;
	float actualworldunitsperpixel;

	if ( m_flAspectAdjustment > 1.0f )
	{
		// World height fits exactly in minimap height at zoom 1x
		fittedworldunitsperpixel = worldsize.y / (float)( vh );

		// At higher zoom we get less world units per pixel
		zoomedworldunitsperpixel = fittedworldunitsperpixel / m_flZoomAmount;

		// at fully zoomed back view, world width fits window width instead
		zooomedoutworldunitsperpixel = worldsize.x / (float)( vw );

		// As we center more on player, we move away from zoomed out units and toward zoomed units per pixel
		actualworldunitsperpixel = zooomedoutworldunitsperpixel + m_flCenterOnPlayer * ( zoomedworldunitsperpixel - zooomedoutworldunitsperpixel );

		m_flZoomAdjust = (1-m_flCenterOnPlayer) + m_flCenterOnPlayer * ( 1/m_flViewportAspectRatio );
	}
	else
	{
		// World width fits exactly in minimap width at zoom 1x
		fittedworldunitsperpixel = worldsize.x / (float)( vw );

		// At higher zoom we get less world units per pixel
		zoomedworldunitsperpixel = fittedworldunitsperpixel / m_flZoomAmount;

		// at fully zoomed back view, world height fits window height instead
		zooomedoutworldunitsperpixel = worldsize.y / (float)( vh );

		// As we center more on player, we move away from zoomed out units and toward zoomed units per pixel
		actualworldunitsperpixel = zooomedoutworldunitsperpixel + m_flCenterOnPlayer * ( zoomedworldunitsperpixel - zooomedoutworldunitsperpixel );

		m_flZoomAdjust = (1-m_flCenterOnPlayer) + m_flCenterOnPlayer * ( 1/m_flAspectAdjustment );
	}

	Vector preOrigin = origin;

	float inset_pixels = m_flInsetPixels;

	float viewport_width_world_units	= ( float )( vw - 2 * inset_pixels ) * actualworldunitsperpixel;
	float viewport_height_world_units	= ( float )( vh - 2 * inset_pixels ) * actualworldunitsperpixel;

	// Insets apply when centering on player
	m_flWorldSpaceInsets[ 0 ] = min( m_vecMapCenter.x, worldmins.x + m_flCenterOnPlayer * ( viewport_width_world_units ) * 0.5f );
	m_flWorldSpaceInsets[ 1 ] = min( m_vecMapCenter.y, worldmins.y + m_flCenterOnPlayer * ( viewport_height_world_units ) * 0.5f );
	m_flWorldSpaceInsets[ 2 ] = max( m_vecMapCenter.x, worldmaxs.x - m_flCenterOnPlayer * ( viewport_width_world_units ) * 0.5f );
	m_flWorldSpaceInsets[ 3 ] = max( m_vecMapCenter.y, worldmaxs.y - m_flCenterOnPlayer * ( viewport_height_world_units ) * 0.5f );
	
	// Assuming origin is at center of view, compute world space left, top, right, bottom
	m_flWorldSpaceBounds[ 0 ] = m_vecMapCenter.x + origin.x - viewport_width_world_units * 0.5f;
	m_flWorldSpaceBounds[ 1 ] = m_vecMapCenter.y + origin.y - viewport_height_world_units * 0.5f;
	m_flWorldSpaceBounds[ 2 ] = m_vecMapCenter.x + origin.x + viewport_width_world_units * 0.5f;
	m_flWorldSpaceBounds[ 3 ] = m_vecMapCenter.y + origin.y + viewport_height_world_units * 0.5f;

	// Clip these bounds
	m_flClippedWorldSpaceBounds[ 0 ] = max( worldmins.x, m_flWorldSpaceBounds[ 0 ] );
	m_flClippedWorldSpaceBounds[ 1 ] = max( worldmins.y, m_flWorldSpaceBounds[ 1 ] );
	m_flClippedWorldSpaceBounds[ 2 ] = min( worldmaxs.x, m_flWorldSpaceBounds[ 2 ] );
	m_flClippedWorldSpaceBounds[ 3 ] = min( worldmaxs.y, m_flWorldSpaceBounds[ 3 ] );

	// Clip origin to inserts
	origin.x = clamp( origin.x, m_flWorldSpaceInsets[ 0 ] - m_vecMapCenter.x, m_flWorldSpaceInsets[ 2 ] - m_vecMapCenter.x );
	origin.y = clamp( origin.y, m_flWorldSpaceInsets[ 1 ] - m_vecMapCenter.y, m_flWorldSpaceInsets[ 3 ] - m_vecMapCenter.y );

	/*
	engine->Con_NPrintf( 1, "map bounds left %i top %i right %i bottom %i", 
		(int)worldmins.x,
		(int)worldmins.y,
		(int)worldmaxs.x,
		(int)worldmaxs.y );

	engine->Con_NPrintf( 2, "world space bounds left %i top %i right %i bottom %i", 
		(int)m_flWorldSpaceBounds[ 0 ],
		(int)m_flWorldSpaceBounds[ 1 ],
		(int)m_flWorldSpaceBounds[ 2 ],
		(int)m_flWorldSpaceBounds[ 3 ] );

	engine->Con_NPrintf( 3, "world space insets left %i top %i right %i bottom %i", 
		(int)m_flWorldSpaceInsets[ 0 ],
		(int)m_flWorldSpaceInsets[ 1 ],
		(int)m_flWorldSpaceInsets[ 2 ],
		(int)m_flWorldSpaceInsets[ 3 ] );

	engine->Con_NPrintf( 4, "world space clipping left %i top %i right %i bottom %i", 
		(int)m_flClippedWorldSpaceBounds[ 0 ],
		(int)m_flClippedWorldSpaceBounds[ 1 ],
		(int)m_flClippedWorldSpaceBounds[ 2 ],
		(int)m_flClippedWorldSpaceBounds[ 3 ] );


	engine->Con_NPrintf( 5, "world center %i %i", 
		(int)m_vecMapCenter.x, (int)m_vecMapCenter.y );

	engine->Con_NPrintf( 6, "player origin %i %i", 
		(int)playerOrigin.x, (int)playerOrigin.y );

	engine->Con_NPrintf( 7, "desired map center %i %i", 
		(int)( m_vecMapCenter.x + preOrigin.x ), (int)( preOrigin.y + m_vecMapCenter.x ) );

	engine->Con_NPrintf( 8, "actual map center %i %i", 
		(int)( m_vecMapCenter.x + origin.x ), (int)( origin.y + m_vecMapCenter.y ) );

	engine->Con_NPrintf( 9, "viewport (%ix%i) aspect %.2f world (%ix%i) aspect %f",
		vw, vh, m_flViewportAspectRatio, (int)worldsize.x, (int)worldsize.y, m_flMapAspectRatio );
	
	engine->Con_NPrintf( 10, "zoom %.3f zoom adjust %.3f", 
		m_flZoomAmount, m_flZoomAdjust );

	engine->Con_NPrintf( 11, "viewport %i x %i", 
		(int)viewport_width_world_units, (int)viewport_height_world_units );
	*/

	// Assume 100% scale and no x or y offset to make up for aspect ration diff
	m_flNormalizedXScale = 1.0f;
	m_flNormalizedYScale = 1.0f;
	m_flNormalizedXOffset = 0.0f;
	m_flNormalizedYOffset = 0.0f;

	if ( m_flAspectAdjustment < 1.0f )
	{
		m_flNormalizedXScale = m_flAspectAdjustment;
		// Offset 0->1 version of x value
		m_flNormalizedXOffset = ( 1.0f - m_flNormalizedXScale ) * 0.5f;
	}
	else
	{
		m_flNormalizedYScale = 1.0f / m_flAspectAdjustment;
		// Offset 0->1 version of y value
		m_flNormalizedYOffset = ( 1.0f - m_flNormalizedYScale ) * 0.5f;
	}
}

void CMinimapPanel::InitOverlays( const char *materialrootname )
{
	if ( !materialrootname || !materialrootname[0] )
		return;

	int t;
	for ( t = 0; t < MAX_ACT_TEAMS; t++ )
	{
		char teamnum[ 2 ];
		Q_snprintf( teamnum, sizeof( teamnum ), "%01i", t + 1 );

		int i;
		for ( i = 0; i < MAX_ACTS; i++ )
		{
			char actnum[ 3 ];

			char filename[ 512 ];

			Q_snprintf( actnum, sizeof( actnum ), "%02i", i );

			Overlays *p = &m_rgOverlays[ t ][ i ];
			Assert( p && !p->m_bInUse );

			Q_snprintf( filename, sizeof( filename ), "%s_act%s_overlay_team%s",
				materialrootname, actnum, teamnum );

			// Check if file exists
			if ( vgui::filesystem()->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
			{
				p->m_pOverlay = new BitmapImage( GetVPanel(), filename );
				p->m_bInUse = true;
			}
			else
			{
				// Try it without the team number
				Q_snprintf( filename, sizeof( filename ), "%s_act%s_overlay",
					materialrootname, actnum );

				if ( vgui::filesystem()->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
				{
					p->m_pOverlay = new BitmapImage( GetVPanel(), filename );
					p->m_bInUse = true;
				}
			}

			Q_snprintf( filename, sizeof( filename ), "%s_act%s_text_team%s",
				materialrootname, actnum, teamnum );

			// Check if file exists
			if ( vgui::filesystem()->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
			{
				p->m_pText = new BitmapImage( GetTextPaintPanel()->GetVPanel(), filename );
				p->m_bInUse = true;
			}
			else
			{
				// Try it without the team number
				Q_snprintf( filename, sizeof( filename ), "%s_act%s_text",
					materialrootname, actnum );

				// Check if file exists
				if ( vgui::filesystem()->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
				{
					p->m_pText = new BitmapImage( GetTextPaintPanel()->GetVPanel(), filename );
					p->m_bInUse = true;
				}
			}
		}	
	}
}

void CMinimapPanel::ShutdownOverlays( void )
{
	int t;
	for ( t = 0; t < MAX_ACT_TEAMS; t++ )
	{

		int i;
		for ( i = 0; i < MAX_ACTS; i++ )
		{
			Overlays *p = &m_rgOverlays[ t ][ i ];
			Assert( p );
			if ( !p->m_bInUse )
				continue;

			delete p->m_pOverlay;
			delete p->m_pText;
			p->m_bInUse = false;
			p->m_pOverlay = NULL;
			p->m_pText = NULL;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Panel
//-----------------------------------------------------------------------------
Panel *CMinimapPanel::GetTextPaintPanel( void )
{
	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
	if ( !basemode )
	{
		Assert( 0 );
		return NULL;
	}

	return basemode->GetMinimapParent();
}

void CMinimapPanel::ZoomIn( void )
{
	if ( m_flDetailsAlpha > 0 )
	{
		if ( m_nZoomLevel != 0 )
		{
		//	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
		//		"MinimapZoomLevel0" );
		}

		// Full window
		m_nZoomLevel = 0;
	}
	else
	{
		m_nZoomLevel = ( m_nZoomLevel + 1 ) % ( NUM_WIDTHS );
		m_nZoomLevel = clamp( m_nZoomLevel, 0, NUM_WIDTHS - 1 );	

		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
			m_nZoomLevel == 0 ? 
				"MinimapZoomLevel0" :
				"MinimapZoomLevel1" );
	}
}

void CMinimapPanel::Zoom_Minimap_f( void )
{
	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
	if ( !basemode )
		return;

	CMinimapPanel *minimap = basemode->GetMinimap();
	if ( !minimap )
		return;

	minimap->ZoomIn();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMinimapPanel::ToggleMinimap( void )
{
	int iKeybits = ::input->GetButtonBits( 0 );
	bool hitting_button = ( iKeybits & (IN_ATTACK | IN_ATTACK2 | IN_JUMP) ) ? true : false;
	if ( hitting_button && !m_bMinimapZoomed )
	{
		CLocalPlayerFilter filter;
		C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "ClientModeTFNormal.ToggleMinimap" );
	}

	SetMinimapZoom( !m_bMinimapZoomed );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void Toggle_Minimap_f( void )
{
	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
	if ( !basemode )
		return;

	CMinimapPanel *minimap = basemode->GetMinimap();
	if ( !minimap )
		return;
	minimap->ToggleMinimap();
}

static ConCommand minimap( "minimap", Toggle_Minimap_f, "Toggle size of the tf2 minimap." );

//-----------------------------------------------------------------------------
// Purpose: Set the state of the minimap's zoom
//-----------------------------------------------------------------------------
void CMinimapPanel::SetMinimapZoom( bool bZoom )
{
	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
	if ( local && local->m_TFLocal.m_bForceMapOverview ) 
	{
		bZoom = true;
	}

	bool changed = bZoom != m_bMinimapZoomed;
	m_bMinimapZoomed = bZoom;
	if ( bZoom )
	{
		m_nZoomLevel = 0;
	}

	if ( changed )
	{
		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
			m_bMinimapZoomed ?
			"MinimapZoomToFullScreen" :
			"MinimapZoomToCorner");

		CLocalPlayerFilter filter;
		C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, m_bMinimapZoomed ? "Minimap.ZoomIn" : "Minimap.ZoomOut" );

	}
}

//-----------------------------------------------------------------------------
// Purpose: Get at input data before it's used
//-----------------------------------------------------------------------------
void CMinimapPanel::ProcessInput()
{
	int iKeybits = ::input->GetButtonBits( 0 );

	bool hitting_button = ( iKeybits & (IN_ATTACK | IN_ATTACK2 | IN_JUMP) ) ? true : false;

	// While the minimap's zoomed, 
	if ( m_bMinimapZoomed && hitting_button )
	{
		SetMinimapZoom( false );
		::input->ClearInputButton( (IN_ATTACK | IN_ATTACK2 | IN_JUMP) );
	}

	CHudElement::ProcessInput();
}

static ConCommand zoom_minimap( "zoom_minimap", CMinimapPanel::Zoom_Minimap_f, "Zoom in on minimap." );

//-----------------------------------------------------------------------------
// Purpose: Play a pulse on the minimap
//-----------------------------------------------------------------------------
void __MsgFunc_MinimapPulse(const char *pszName, int iSize, void *pbuf)
{
	BEGIN_READ( pbuf, iSize );

	Vector vecPosition;
	READ_VEC3COORD( vecPosition );
	C_TFTeam *pTeam = (C_TFTeam *)GetLocalTeam();
	if ( pTeam )
	{
		pTeam->NotifyBaseUnderAttack( vecPosition, false );
	}
}


