diff --git a/mp/game/momentum/gameinfo.txt b/mp/game/momentum/gameinfo.txt
index 1d3168a02..98fd623c8 100644
--- a/mp/game/momentum/gameinfo.txt
+++ b/mp/game/momentum/gameinfo.txt
@@ -15,7 +15,7 @@
 
 	FileSystem
 	{
-		SteamAppId				243730 // This sets the app ID in Steam. This is the Source SDK Base 2013 Singleplayer
+		SteamAppId				244310 // This sets the app ID in Steam. This is the Source SDK Base 2013 Singleplayer
 		
 		//
 		// The code that loads this file automatically does a few things here:
diff --git a/mp/src/game/client/momentum/ClientTimesDisplay.cpp b/mp/src/game/client/momentum/ClientTimesDisplay.cpp
new file mode 100644
index 000000000..2b083be97
--- /dev/null
+++ b/mp/src/game/client/momentum/ClientTimesDisplay.cpp
@@ -0,0 +1,661 @@
+#include "cbase.h"
+//#include "ClientTimesDisplay.h"
+//#include <stdio.h>
+//
+//#include <cdll_client_int.h>
+//#include <cdll_util.h>
+//#include <globalvars_base.h>
+//#include <igameresources.h>
+//#include "IGameUIFuncs.h" // for key bindings
+//#include "inputsystem/iinputsystem.h"
+//#include <voice_status.h>
+//
+//#include <vgui/IScheme.h>
+//#include <vgui/ILocalize.h>
+//#include <vgui/ISurface.h>
+//#include <vgui/IVGui.h>
+//#include <vstdlib/IKeyValuesSystem.h>
+//
+//#include <KeyValues.h>
+//#include <vgui_controls/ImageList.h>
+//#include <vgui_controls/Label.h>
+//#include <vgui_controls/SectionedListPanel.h>
+//
+//#include <game/client/iviewport.h>
+//#include <igameresources.h>
+//
+//#include "vgui_avatarimage.h"
+//
+//// memdbgon must be the last include file in a .cpp file!!!
+//#include "tier0/memdbgon.h"
+//
+//using namespace vgui;
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Constructor
+////-----------------------------------------------------------------------------
+//CClientTimesDisplay::CClientTimesDisplay(IViewPort *pViewPort) : EditablePanel(NULL, PANEL_SCOREBOARD)
+//{
+//    
+//    m_nCloseKey = BUTTON_CODE_INVALID;
+//
+//    //memset(s_VoiceImage, 0x0, sizeof( s_VoiceImage ));
+//    TrackerImage = 0;
+//    m_pViewPort = pViewPort;
+//
+//    //initialize dialog
+//    SetProportional(true);
+//    SetKeyBoardInputEnabled(false);
+//    SetMouseInputEnabled(false);
+//
+//    //set the scheme before any child control is created
+//    SetScheme("ClientScheme");
+//    
+//    // load scoreboard components
+//
+//    LoadControlSettings("Resource/UI/timesdisplay.res");
+//
+//    m_pHeader = FindControl<Panel>("Header", true);
+//    m_lMapSummary = FindControl<Label>("MapSummary", true);
+//    m_pPlayerStats = FindControl<Panel>("PlayerStats", true);
+//    m_pPlayerAvatar = FindControl<ImagePanel>("PlayerAvatar",true);
+//    m_lPlayerName = FindControl<Label>("PlayerName", true);
+//    m_lPlayerMapRank = FindControl<Label>("PlayerMapRank", true);
+//    m_lPlayerGlobalRank = FindControl<Label>("PlayerGlobalRank", true);
+//    m_pLeaderboards = FindControl<Panel>("Leaderboards", true);
+//    m_pOnlineLeaderboards = FindControl<SectionedListPanel>("OnlineNearbyLeaderboard", true);
+//    m_pLocalBests = FindControl<SectionedListPanel>("LocalPersonalBest", true);
+//    
+//    if (!m_pHeader || !m_lMapSummary || !m_pPlayerStats || !m_pPlayerAvatar || !m_lPlayerName ||
+//        !m_lPlayerMapRank || !m_lPlayerGlobalRank || !m_pLeaderboards || !m_pOnlineLeaderboards || !m_pLocalBests)
+//    {
+//        Assert("Null pointer(s) on scoreboards");
+//    }
+//    
+//
+//    m_lMapSummary->SetParent(m_pHeader);
+//    m_pPlayerAvatar->SetParent(m_pPlayerStats);
+//    m_lPlayerName->SetParent(m_pPlayerStats);
+//    m_lPlayerMapRank->SetParent(m_pPlayerStats);
+//    m_lPlayerGlobalRank->SetParent(m_pPlayerStats);
+//    m_pOnlineLeaderboards->SetParent(m_pLeaderboards);
+//    m_pLocalBests->SetParent(m_pLeaderboards);
+//
+//    m_pOnlineLeaderboards->SetVerticalScrollbar(false);
+//    m_pLocalBests->SetVerticalScrollbar(false);
+//
+//    m_iDesiredHeight = GetTall();
+//    m_pHeader->SetVisible(false); // hide this until we load everything in applyschemesettings
+//    m_pPlayerStats->SetVisible(false); // hide this until we load everything in applyschemesettings
+//    m_pLeaderboards->SetVisible(false); // hide this until we load everything in applyschemesettings
+//
+//    m_HLTVSpectators = 0;
+//    m_ReplaySpectators = 0;
+//
+//    // update scoreboard instantly if on of these events occure
+//    ListenForGameEvent("hltv_status");
+//    ListenForGameEvent("server_spawn");
+//    //Momentum specific
+//    ListenForGameEvent("runtime_posted");
+//
+//    m_pImageList = NULL;
+//
+//    m_mapAvatarsToImageList.SetLessFunc(DefLessFunc(CSteamID));
+//    m_mapAvatarsToImageList.RemoveAll();
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Constructor
+////-----------------------------------------------------------------------------
+//CClientTimesDisplay::~CClientTimesDisplay()
+//{
+//    if (NULL != m_pImageList)
+//    {
+//        delete m_pImageList;
+//        m_pImageList = NULL;
+//    }
+//
+//    //// Kill children before parents
+//
+//    //if (NULL != m_lMapSummary)
+//    //{
+//    //    delete m_lMapSummary;
+//    //    m_lMapSummary = NULL;
+//    //}
+//    //if (NULL != m_pHeader)
+//    //{
+//    //    delete m_pHeader;
+//    //    m_pHeader = NULL;
+//    //}
+//
+//    //if (NULL != m_lPlayerName)
+//    //{
+//    //    delete m_lPlayerName;
+//    //    m_lPlayerName = NULL;
+//    //}
+//    //if (NULL != m_lPlayerMapRank)
+//    //{
+//    //    delete m_lPlayerMapRank;
+//    //    m_lPlayerMapRank = NULL;
+//    //}
+//    //if (NULL != m_lPlayerGlobalRank)
+//    //{
+//    //    delete m_lPlayerGlobalRank;
+//    //    m_lPlayerGlobalRank = NULL;
+//    //}
+//    //if (NULL != m_pPlayerStats)
+//    //{
+//    //    delete m_pPlayerStats;
+//    //    m_pPlayerStats = NULL;
+//    //}
+//
+//    //if (NULL != m_pOnlineLeaderboards)
+//    //{
+//    //    delete m_pOnlineLeaderboards;
+//    //    m_pOnlineLeaderboards = NULL;
+//    //    
+//    //}
+//    //if (NULL != m_pLocalBests)
+//    //{
+//    //    delete m_pLocalBests;
+//    //    m_pLocalBests = NULL;
+//    //}
+//    //if (NULL != m_pLeaderboards)
+//    //{
+//    //    delete m_pLeaderboards;
+//    //    m_pLeaderboards = NULL;
+//    //}
+//
+//    //// And now the KV for the data.
+//    //if (NULL != m_kvPlayerData)
+//    //{
+//    //    m_kvPlayerData->deleteThis();
+//    //    m_kvPlayerData = NULL;
+//    //}
+//}
+//
+////-----------------------------------------------------------------------------
+//// Call every frame
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::OnThink()
+//{
+//    BaseClass::OnThink();
+//
+//    // NOTE: this is necessary because of the way input works.
+//    // If a key down message is sent to vgui, then it will get the key up message
+//    // Sometimes the scoreboard is activated by other vgui menus, 
+//    // sometimes by console commands. In the case where it's activated by
+//    // other vgui menus, we lose the key up message because this panel
+//    // doesn't accept keyboard input. It *can't* accept keyboard input
+//    // because another feature of the dialog is that if it's triggered
+//    // from within the game, you should be able to still run around while
+//    // the scoreboard is up. That feature is impossible if this panel accepts input.
+//    // because if a vgui panel is up that accepts input, it prevents the engine from
+//    // receiving that input. So, I'm stuck with a polling solution.
+//    // 
+//    // Close key is set to non-invalid when something other than a keybind
+//    // brings the scoreboard up, and it's set to invalid as soon as the 
+//    // dialog becomes hidden.
+//    if (m_nCloseKey != BUTTON_CODE_INVALID)
+//    {
+//        if (!g_pInputSystem->IsButtonDown(m_nCloseKey))
+//        {
+//            m_nCloseKey = BUTTON_CODE_INVALID;
+//            gViewPortInterface->ShowPanel(PANEL_SCOREBOARD, false);
+//            GetClientVoiceMgr()->StopSquelchMode();
+//        }
+//    }
+//}
+//
+////-----------------------------------------------------------------------------
+//// Called by vgui panels that activate the client scoreboard
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::OnPollHideCode(int code)
+//{
+//    m_nCloseKey = (ButtonCode_t)code;
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: clears everything in the scoreboard and all it's state
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::Reset(bool pUpdateLists)
+//{
+//    if (pUpdateLists)
+//    {
+//        // clear
+//        if (m_pOnlineLeaderboards)
+//        {
+//            m_pOnlineLeaderboards->DeleteAllItems();
+//            m_pOnlineLeaderboards->RemoveAll();
+//        }
+//        if (m_pLocalBests)
+//        {
+//            m_pLocalBests->DeleteAllItems();
+//            m_pLocalBests->RemoveAll();
+//        }
+//        // add all the sections
+//        InitScoreboardSections();
+//    }
+//    m_iSectionId = 0;
+//    m_fNextUpdateTime = 0;
+//}
+//
+//void CClientTimesDisplay::Reset()
+//{
+//    Reset(false);
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Fills the leaderboards lists
+//// MOM_TODO: Implement
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::InitScoreboardSections()
+//{
+//
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: sets up screen
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::ApplySchemeSettings(IScheme *pScheme)
+//{
+//    
+//    BaseClass::ApplySchemeSettings(pScheme);
+//    
+//    if (m_pImageList)
+//        delete m_pImageList;
+//    m_pImageList = new ImageList(false);
+//    
+//    m_mapAvatarsToImageList.RemoveAll();
+//    
+//    PostApplySchemeSettings(pScheme);
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Does dialog-specific customization after applying scheme settings.
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::PostApplySchemeSettings(IScheme *pScheme)
+//{
+//    // resize the images to our resolution
+//    for (int i = 0; i < m_pImageList->GetImageCount(); i++)
+//    {
+//        int wide, tall;
+//        m_pImageList->GetImage(i)->GetSize(wide, tall);
+//        m_pImageList->GetImage(i)->SetSize(scheme()->GetProportionalScaledValueEx(GetScheme(), wide), scheme()->GetProportionalScaledValueEx(GetScheme(), tall));
+//    }
+//    // MOM_TODO: Which one is the Player's avatar?
+//    m_pPlayerAvatar->SetImage(m_pImageList->GetImage(0));
+//    // Now that the image is loaded, we display the whole thing
+//    if (m_pHeader)
+//     m_pHeader->SetVisible(true); // hide this until we load everything in applyschemesettings
+//    if (m_pPlayerStats)
+//        m_pPlayerStats->SetVisible(true); // hide this until we load everything in applyschemesettings
+//    if (m_pLeaderboards)
+//        m_pLeaderboards->SetVisible(true); // hide this until we load everything in applyschemesettings
+//    
+//    // light up scoreboard a bit
+//    SetBgColor(Color(0, 0, 0, 0));
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: 
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::ShowPanel(bool bShow)
+//{
+//    // Catch the case where we call ShowPanel before ApplySchemeSettings, eg when
+//    // going from windowed <-> fullscreen
+//    if (m_pImageList == NULL)
+//    {
+//        InvalidateLayout(true, true);
+//    }
+//
+//    if (!bShow)
+//    {
+//        m_nCloseKey = BUTTON_CODE_INVALID;
+//    }
+//
+//    if (BaseClass::IsVisible() == bShow)
+//        return;
+//
+//    if (bShow)
+//    {
+//        Reset(true);
+//        Update(false);
+//        SetVisible(true);
+//        MoveToFront();
+//    }
+//    else
+//    {
+//        BaseClass::SetVisible(false);
+//        SetMouseInputEnabled(false);
+//        SetKeyBoardInputEnabled(false);
+//    }
+//}
+//
+//void CClientTimesDisplay::FireGameEvent(IGameEvent *event)
+//{
+//    const char * type = event->GetName();
+//
+//    if (Q_strcmp(type, "hltv_status") == 0)
+//    {
+//        // spectators = clients - proxies
+//        m_HLTVSpectators = event->GetInt("clients");
+//        m_HLTVSpectators -= event->GetInt("proxies");
+//    }
+//    else if (Q_strcmp(type, "server_spawn") == 0)
+//    {
+//        // We'll post the message ourselves instead of using SetControlString()
+//        // so we don't try to translate the hostname.
+//        const char *hostname = event->GetString("hostname");
+//        Panel *control = FindChildByName("ServerName");
+//        if (control)
+//        {
+//            PostMessage(control, new KeyValues("SetText", "text", hostname));
+//            control->MoveToFront();
+//        }
+//    }
+//    else if (Q_strcmp(type, "runtime_posted") == 0)
+//    {
+//        // MOM_TODO(ish): Update the scoreboard when a new run is submited
+//    }
+//
+//    if (IsVisible())
+//        Update(true);
+//
+//}
+//
+//bool CClientTimesDisplay::NeedsUpdate(void)
+//{
+//    return (m_fNextUpdateTime < gpGlobals->curtime);
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Recalculate the internal scoreboard data
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::Update(bool pFullUpdate)
+//{
+//    Reset(pFullUpdate);
+//
+//    FillScoreBoard(pFullUpdate);
+//
+//    // grow the scoreboard to fit all the players
+//   /* int wide, tall;
+//    m_pPlayerList->GetContentSize(wide, tall);
+//    tall += GetAdditionalHeight();
+//    wide = GetWide();
+//    if (m_iDesiredHeight < tall)
+//    {
+//        SetSize(wide, tall);
+//        m_pPlayerList->SetSize(wide, tall);
+//    }
+//    else
+//    {
+//        SetSize(wide, m_iDesiredHeight);
+//        m_pPlayerList->SetSize(wide, m_iDesiredHeight);
+//    }*/
+//
+//    MoveToCenterOfScreen();
+//
+//    // update every 2 seconds.
+//    // Maybe we can increase this number (We don't really need to update too often)
+//    // MOM_TODO: Think about update interval
+//    m_fNextUpdateTime = gpGlobals->curtime + 2.0f;
+//}
+//
+//void CClientTimesDisplay::Update()
+//{
+//    Update(false);
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: 
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::UpdatePlayerInfo()
+//{
+//    for (int i = 1; i <= gpGlobals->maxClients; ++i)
+//    {
+//        IGameResources *gr = GameResources();
+//
+//        if (gr && gr->IsConnected(i))
+//        {
+//            // add the player to the list
+//            KeyValues *playerData = new KeyValues("data");
+//            UpdatePlayerAvatar(i, playerData);
+//
+//            const char *oldName = playerData->GetString("name", "");
+//            char newName[MAX_PLAYER_NAME_LENGTH];
+//            UTIL_MakeSafeName(oldName, newName, MAX_PLAYER_NAME_LENGTH);
+//            playerData->SetString("name", newName);
+//
+//            playerData->SetInt("globalRank", -1);
+//            playerData->SetInt("globalCount", -1);
+//            playerData->SetInt("mapRank", -1);
+//            playerData->SetInt("mapCount", -1);
+//
+//            m_kvPlayerData = playerData;
+//            playerData->deleteThis();
+//        }// else, we're not connected. We simply can't be here and disconnected unless something is fucked up
+//    }
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: adds the top header of the scoreboars
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::AddHeader()
+//{
+//    //// MOM_TODO: Implement map & gamemode detection
+//    //Q_strcat(ch, "(", 512);
+//    //Q_strcat(ch, "Gamemode", 512);
+//    //Q_strcat(ch, ")", 512);
+//    if (m_lMapSummary)
+//    {
+//        char *ch = "mapname";
+//        m_lMapSummary->SetText(ch);
+//        // add the top header
+//        m_lMapSummary->SetVisible(true);
+//    }
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Adds a new section to the scoreboard (i.e the team header)
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::AddSection(int teamType, int teamNumber)
+//{
+//    //if (teamType == TYPE_TEAM)
+//    //{
+//    //    IGameResources *gr = GameResources();
+//
+//    //    if (!gr)
+//    //        return;
+//
+//    //    // setup the team name
+//    //    wchar_t *teamName = g_pVGuiLocalize->Find(gr->GetTeamName(teamNumber));
+//    //    wchar_t name[64];
+//    //    wchar_t string1[1024];
+//
+//    //    if (!teamName)
+//    //    {
+//    //        g_pVGuiLocalize->ConvertANSIToUnicode(gr->GetTeamName(teamNumber), name, sizeof(name));
+//    //        teamName = name;
+//    //    }
+//
+//    //    g_pVGuiLocalize->ConstructString(string1, sizeof(string1), g_pVGuiLocalize->Find("#Player"), 2, teamName);
+//
+//    //    m_pPlayerList->AddSection(m_iSectionId, "", StaticPlayerSortFunc);
+//
+//    //    // Avatars are always displayed at 32x32 regardless of resolution
+//    //    if (ShowAvatars())
+//    //    {
+//    //        m_pPlayerList->AddColumnToSection(m_iSectionId, "avatar", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, m_iAvatarWidth);
+//    //    }
+//
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "name", string1, 0, scheme()->GetProportionalScaledValueEx(GetScheme(), NAME_WIDTH) - m_iAvatarWidth);
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "frags", "", 0, scheme()->GetProportionalScaledValueEx(GetScheme(), SCORE_WIDTH));
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "deaths", "", 0, scheme()->GetProportionalScaledValueEx(GetScheme(), DEATH_WIDTH));
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "ping", "", 0, scheme()->GetProportionalScaledValueEx(GetScheme(), PING_WIDTH));
+//    //}
+//    //else if (teamType == TYPE_SPECTATORS)
+//    //{
+//    //    m_pPlayerList->AddSection(m_iSectionId, "");
+//
+//    //    // Avatars are always displayed at 32x32 regardless of resolution
+//    //    if (ShowAvatars())
+//    //    {
+//    //        m_pPlayerList->AddColumnToSection(m_iSectionId, "avatar", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, m_iAvatarWidth);
+//    //    }
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "name", "#Spectators", 0, scheme()->GetProportionalScaledValueEx(GetScheme(), NAME_WIDTH) - m_iAvatarWidth);
+//    //    m_pPlayerList->AddColumnToSection(m_iSectionId, "frags", "", 0, scheme()->GetProportionalScaledValueEx(GetScheme(), SCORE_WIDTH));
+//    //}
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Used for sorting players
+////-----------------------------------------------------------------------------
+//bool CClientTimesDisplay::StaticPlayerSortFunc(vgui::SectionedListPanel *list, int itemID1, int itemID2)
+//{
+//    //KeyValues *it1 = list->GetItemData(itemID1);
+//    //KeyValues *it2 = list->GetItemData(itemID2);
+//    //Assert(it1 && it2);
+//
+//    //// first compare frags
+//    //int v1 = it1->GetInt("frags");
+//    //int v2 = it2->GetInt("frags");
+//    //if (v1 > v2)
+//    //    return true;
+//    //else if (v1 < v2)
+//    //    return false;
+//
+//    //// next compare deaths
+//    //v1 = it1->GetInt("deaths");
+//    //v2 = it2->GetInt("deaths");
+//    //if (v1 > v2)
+//    //    return false;
+//    //else if (v1 < v2)
+//    //    return true;
+//
+//    //// the same, so compare itemID's (as a sentinel value to get deterministic sorts)
+//    return itemID1 < itemID2;
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Adds a new row to the scoreboard, from the playerinfo structure
+////-----------------------------------------------------------------------------
+//bool CClientTimesDisplay::GetPlayerScoreInfo(int playerIndex, KeyValues *kv)
+//{
+//    //IGameResources *gr = GameResources();
+//
+//    //if (!gr)
+//    //    return false;
+//
+//    //kv->SetInt("deaths", gr->GetDeaths(playerIndex));
+//    //kv->SetInt("frags", gr->GetFrags(playerIndex));
+//    //kv->SetInt("ping", gr->GetPing(playerIndex));
+//    //kv->SetString("name", gr->GetPlayerName(playerIndex));
+//    //kv->SetInt("playerIndex", playerIndex);
+//
+//    return true;
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: 
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::UpdatePlayerAvatar(int playerIndex, KeyValues *kv)
+//{
+//    // Update their avatar
+//    if (kv && ShowAvatars() && steamapicontext->SteamFriends() && steamapicontext->SteamUtils())
+//    {
+//        player_info_t pi;
+//        if (engine->GetPlayerInfo(playerIndex, &pi))
+//        {
+//            if (pi.friendsID)
+//            {
+//                CSteamID steamIDForPlayer(pi.friendsID, 1, steamapicontext->SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual);
+//
+//                // See if we already have that avatar in our list
+//                int iMapIndex = m_mapAvatarsToImageList.Find(steamIDForPlayer);
+//                int iImageIndex;
+//                if (iMapIndex == m_mapAvatarsToImageList.InvalidIndex())
+//                {
+//                    CAvatarImage *pImage = new CAvatarImage();
+//                    pImage->SetAvatarSteamID(steamIDForPlayer);
+//                    pImage->SetAvatarSize(32, 32);	// Deliberately non scaling
+//                    iImageIndex = m_pImageList->AddImage(pImage);
+//
+//                    m_mapAvatarsToImageList.Insert(steamIDForPlayer, iImageIndex);
+//                }
+//                else
+//                {
+//                    iImageIndex = m_mapAvatarsToImageList[iMapIndex];
+//                }
+//
+//                kv->SetInt("avatar", iImageIndex);
+//
+//                CAvatarImage *pAvIm = (CAvatarImage *)m_pImageList->GetImage(iImageIndex);
+//                pAvIm->UpdateFriendStatus();
+//            }
+//        }
+//    }
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: reload the player list on the scoreboard
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::FillScoreBoard(bool pFullUpdate)
+//{
+//    // update player info
+//    if (pFullUpdate)
+//        UpdatePlayerInfo();
+//    if (m_lPlayerName)
+//        m_lPlayerName->SetText(m_kvPlayerData->GetString("name","Undefined"));
+//
+//    if (m_lPlayerMapRank)
+//    {
+//        char *mapRank = "Map rank:";
+//        /* Q_strcat(mapRank,(const char *)m_kvPlayerData->GetInt("mapRank", -1), 50);
+//        Q_strcat(mapRank, "/", 50);
+//        Q_strcat(mapRank, (const char *)m_kvPlayerData->GetInt("mapCount", -1), 50);*/
+//        m_lPlayerMapRank->SetText(mapRank);
+//    }
+//
+//    if (m_lPlayerGlobalRank)
+//    {
+//        char *globalRank = "Global rank:";
+//        /*Q_strcat(mapRank, (const char *)m_kvPlayerData->GetInt("globalRank", -1), 50);
+//        Q_strcat(mapRank, "/", 50);
+//        Q_strcat(mapRank, (const char *)m_kvPlayerData->GetInt("globalCount", -1), 50);*/
+//        m_lPlayerGlobalRank->SetText(globalRank);
+//    }
+//    if (pFullUpdate)
+//        Reset(true);
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: searches for the player in the scoreboard
+////-----------------------------------------------------------------------------
+//int CClientTimesDisplay::FindItemIDForPlayerIndex(int playerIndex)
+//{
+//    return 0;
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Sets the text of a control by name
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::MoveLabelToFront(const char *textEntryName)
+//{
+//    Label *entry = dynamic_cast<Label *>(FindChildByName(textEntryName));
+//    if (entry)
+//    {
+//        entry->MoveToFront();
+//    }
+//}
+//
+////-----------------------------------------------------------------------------
+//// Purpose: Center the dialog on the screen.  (vgui has this method on
+////			Frame, but we're an EditablePanel, need to roll our own.)
+////-----------------------------------------------------------------------------
+//void CClientTimesDisplay::MoveToCenterOfScreen()
+//{
+//    int wx, wy, ww, wt;
+//    surface()->GetWorkspaceBounds(wx, wy, ww, wt);
+//    SetPos((ww - GetWide()) / 2, (wt - GetTall()) / 2);
+//}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ClientTimesDisplay.h b/mp/src/game/client/momentum/ClientTimesDisplay.h
new file mode 100644
index 000000000..245ccff93
--- /dev/null
+++ b/mp/src/game/client/momentum/ClientTimesDisplay.h
@@ -0,0 +1,128 @@
+//#ifndef CLIENTTIMESDISPLAY_H
+//#define CLIENTTIMESDISPLAY_H
+//#ifdef _WIN32
+//#pragma once
+//#endif
+//
+//#include <vgui_controls/EditablePanel.h>
+//#include <game/client/iviewport.h>
+//#include "GameEventListener.h"
+//
+//#define TYPE_NOTEAM			0	// NOTEAM must be zero :)
+//#define TYPE_TEAM			1	// a section for a single team	
+//#define TYPE_PLAYERS		2
+//#define TYPE_SPECTATORS		3	// a section for a spectator group
+//#define TYPE_BLANK			4
+//
+//
+////-----------------------------------------------------------------------------
+//// Purpose: TimeDisplay ScoreBoard
+////-----------------------------------------------------------------------------
+//class CClientTimesDisplay : public vgui::EditablePanel, public IViewPortPanel, public CGameEventListener
+//{
+//private:
+//    DECLARE_CLASS_SIMPLE(CClientTimesDisplay, vgui::EditablePanel);
+//
+//protected:
+//    // column widths at 640
+//    enum { NAME_WIDTH = 160, SCORE_WIDTH = 60, DEATH_WIDTH = 60, PING_WIDTH = 80, VOICE_WIDTH = 0, FRIENDS_WIDTH = 0 };
+//    // total = 340
+//
+//public:
+//    // TEMPORAL
+//    CClientTimesDisplay(IViewPort *pViewPort);
+//    ~CClientTimesDisplay();
+//
+//    virtual const char *GetName(void) { return PANEL_SCOREBOARD; }
+//    virtual void SetData(KeyValues *data) {};
+//    virtual void Reset();
+//    void Reset(bool);
+//    virtual void Update();
+//    void Update(bool);
+//    virtual bool NeedsUpdate(void);
+//    virtual bool HasInputElements(void) { return true; }
+//    virtual void ShowPanel(bool bShow);
+//
+//    virtual bool ShowAvatars()
+//    {
+//#ifdef CSS_PERF_TEST
+//        return false;
+//#endif
+//        return IsPC();
+//    }
+//
+//    // both vgui::Frame and IViewPortPanel define these, so explicitly define them here as passthroughs to vgui
+//    vgui::VPANEL GetVPanel(void) { return BaseClass::GetVPanel(); }
+//    virtual bool IsVisible() { return BaseClass::IsVisible(); }
+//    virtual void SetParent(vgui::VPANEL parent) { BaseClass::SetParent(parent); }
+//
+//    // IGameEventListener interface:
+//    virtual void FireGameEvent(IGameEvent *event);
+//
+//    virtual void UpdatePlayerAvatar(int playerIndex, KeyValues *kv);
+//
+//protected:
+//    MESSAGE_FUNC_INT(OnPollHideCode, "PollHideCode", code);
+//
+//    // functions to override
+//    virtual bool GetPlayerScoreInfo(int playerIndex, KeyValues *outPlayerInfo);
+//    virtual void InitScoreboardSections();
+//    virtual void UpdatePlayerInfo();
+//    virtual void OnThink();
+//    virtual void AddHeader(); // add the start header of the scoreboard
+//    virtual void AddSection(int teamType, int teamNumber); // add a new section header for a team
+//    virtual int GetAdditionalHeight() { return 0; }
+//
+//    // sorts players within a section
+//    static bool StaticPlayerSortFunc(vgui::SectionedListPanel *list, int itemID1, int itemID2);
+//
+//    virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+//
+//    virtual void PostApplySchemeSettings(vgui::IScheme *pScheme);
+//
+//    // finds the player in the scoreboard
+//    int FindItemIDForPlayerIndex(int playerIndex);
+//
+//    vgui::Panel *m_pHeader, *m_pPlayerStats, *m_pLeaderboards;
+//    vgui::Label *m_lMapSummary, *m_lPlayerName, *m_lPlayerMapRank, *m_lPlayerGlobalRank;
+//    vgui::SectionedListPanel *m_pOnlineLeaderboards, *m_pLocalBests;
+//    vgui::ImagePanel *m_pPlayerAvatar;
+//
+//    KeyValues *m_kvPlayerData;
+//
+//    int m_iSectionId;
+//
+//    int s_VoiceImage[5];
+//    int TrackerImage;
+//    int	m_HLTVSpectators;
+//    int m_ReplaySpectators;
+//    float m_fNextUpdateTime;
+//
+//    void MoveLabelToFront(const char *textEntryName);
+//    void MoveToCenterOfScreen();
+//
+//    vgui::ImageList				*m_pImageList;
+//    CUtlMap<CSteamID, int>		m_mapAvatarsToImageList;
+//
+//    CPanelAnimationVar(int, m_iAvatarWidth, "avatar_width", "34");		// Avatar width doesn't scale with resolution
+//    CPanelAnimationVarAliasType(int, m_iNameWidth, "name_width", "136", "proportional_int");
+//    CPanelAnimationVarAliasType(int, m_iClassWidth, "class_width", "35", "proportional_int");
+//    CPanelAnimationVarAliasType(int, m_iScoreWidth, "score_width", "35", "proportional_int");
+//    CPanelAnimationVarAliasType(int, m_iDeathWidth, "death_width", "35", "proportional_int");
+//    CPanelAnimationVarAliasType(int, m_iPingWidth, "ping_width", "23", "proportional_int");
+//
+//private:
+//    int			m_iPlayerIndexSymbol;
+//    int			m_iDesiredHeight;
+//    IViewPort	*m_pViewPort;
+//    ButtonCode_t m_nCloseKey;
+//
+//
+//    // methods
+//    void FillScoreBoard(bool);
+//};
+//
+//
+//#endif // CLIENTTIMESDISPLAY_H
+//
+////MOM_TODO: Create a header for the custom leaderboard
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/c_mom_player.cpp b/mp/src/game/client/momentum/c_mom_player.cpp
new file mode 100644
index 000000000..fdb8ff381
--- /dev/null
+++ b/mp/src/game/client/momentum/c_mom_player.cpp
@@ -0,0 +1,54 @@
+#include "cbase.h"
+#include "c_mom_player.h"
+
+#include "tier0/memdbgon.h"
+
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_MomentumPlayer, DT_MOM_Player, CMomentumPlayer)
+RecvPropInt(RECVINFO(m_iShotsFired)),
+RecvPropInt(RECVINFO(m_iDirection)),
+RecvPropBool(RECVINFO(m_bResumeZoom)),
+RecvPropInt(RECVINFO(m_iLastZoom)),
+//RecvPropDataTable(RECVINFO_DT(m_HL2Local), 0, &REFERENCE_RECV_TABLE(DT_HL2Local)),
+//RecvPropBool(RECVINFO(m_fIsSprinting)),
+END_RECV_TABLE()
+
+
+C_MomentumPlayer::C_MomentumPlayer()
+{
+
+}
+
+C_MomentumPlayer::~C_MomentumPlayer()
+{
+
+}
+
+void C_MomentumPlayer::SurpressLadderChecks(const Vector& pos, const Vector& normal)
+{
+    m_ladderSurpressionTimer.Start(1.0f);
+    m_lastLadderPos = pos;
+    m_lastLadderNormal = normal;
+}
+
+bool C_MomentumPlayer::CanGrabLadder(const Vector& pos, const Vector& normal)
+{
+    if (m_ladderSurpressionTimer.GetRemainingTime() <= 0.0f)
+    {
+        return true;
+    }
+
+    const float MaxDist = 64.0f;
+    if (pos.AsVector2D().DistToSqr(m_lastLadderPos.AsVector2D()) < MaxDist * MaxDist)
+    {
+        return false;
+    }
+
+    if (normal != m_lastLadderNormal)
+    {
+        return true;
+    }
+
+    return false;
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/c_mom_player.h b/mp/src/game/client/momentum/c_mom_player.h
new file mode 100644
index 000000000..6066ba132
--- /dev/null
+++ b/mp/src/game/client/momentum/c_mom_player.h
@@ -0,0 +1,68 @@
+#ifndef C_MOMPLAYER_H
+#define C_MOMPLAYER_H
+#ifdef WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+#include "momentum/mom_shareddefs.h"
+
+class C_MomentumPlayer : public C_BasePlayer
+{
+public:
+    DECLARE_CLASS(C_MomentumPlayer, C_BasePlayer);
+    
+    C_MomentumPlayer();
+    ~C_MomentumPlayer();
+
+    DECLARE_CLIENTCLASS();
+
+    Vector m_lastStandingPos; // used by the gamemovement code for finding ladders
+
+    void SurpressLadderChecks(const Vector& pos, const Vector& normal);
+    bool CanGrabLadder(const Vector& pos, const Vector& normal);
+
+
+
+    int m_iShotsFired;
+    int m_iDirection;
+    bool m_bResumeZoom;
+    int m_iLastZoom;
+
+    void GetBulletTypeParameters(
+        int iBulletType,
+        float &fPenetrationPower,
+        float &flPenetrationDistance);
+
+    void FireBullet(
+        Vector vecSrc,
+        const QAngle &shootAngles,
+        float vecSpread,
+        float flDistance,
+        int iPenetration,
+        int iBulletType,
+        int iDamage,
+        float flRangeModifier,
+        CBaseEntity *pevAttacker,
+        bool bDoEffects,
+        float x,
+        float y);
+
+    void KickBack(
+        float up_base,
+        float lateral_base,
+        float up_modifier,
+        float lateral_modifier,
+        float up_max,
+        float lateral_max,
+        int direction_change);
+
+private:
+    CountdownTimer m_ladderSurpressionTimer;
+    Vector m_lastLadderNormal;
+    Vector m_lastLadderPos;
+
+    friend class CMomentumGameMovement;
+};
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/c_te_shotgun_shot.cpp b/mp/src/game/client/momentum/c_te_shotgun_shot.cpp
new file mode 100644
index 000000000..919936cb1
--- /dev/null
+++ b/mp/src/game/client/momentum/c_te_shotgun_shot.cpp
@@ -0,0 +1,56 @@
+#include "cbase.h"
+#include "momentum/fx_cs_shared.h"
+#include "momentum/c_mom_player.h"
+#include "c_basetempentity.h"
+#include <cliententitylist.h>
+
+
+class C_TEFireBullets : public C_BaseTempEntity
+{
+public:
+    DECLARE_CLASS(C_TEFireBullets, C_BaseTempEntity);
+    DECLARE_CLIENTCLASS();
+
+    virtual void	PostDataUpdate(DataUpdateType_t updateType);
+
+public:
+    int		m_iPlayer;
+    Vector	m_vecOrigin;
+    QAngle	m_vecAngles;
+    int		m_iWeaponID;
+    int		m_iMode;
+    int		m_iSeed;
+    float	m_flSpread;
+};
+
+
+void C_TEFireBullets::PostDataUpdate(DataUpdateType_t updateType)
+{
+    // Create the effect.
+
+    m_vecAngles.z = 0;
+
+    FX_FireBullets(
+        m_iPlayer + 1,
+        m_vecOrigin,
+        m_vecAngles,
+        m_iWeaponID,
+        m_iMode,
+        m_iSeed,
+        m_flSpread);
+}
+
+
+IMPLEMENT_CLIENTCLASS_EVENT(C_TEFireBullets, DT_TEFireBullets, CTEFireBullets);
+
+
+BEGIN_RECV_TABLE_NOBASE(C_TEFireBullets, DT_TEFireBullets)
+RecvPropVector(RECVINFO(m_vecOrigin)),
+RecvPropFloat(RECVINFO(m_vecAngles[0])),
+RecvPropFloat(RECVINFO(m_vecAngles[1])),
+RecvPropInt(RECVINFO(m_iWeaponID)),
+RecvPropInt(RECVINFO(m_iMode)),
+RecvPropInt(RECVINFO(m_iSeed)),
+RecvPropInt(RECVINFO(m_iPlayer)),
+RecvPropFloat(RECVINFO(m_flSpread)),
+END_RECV_TABLE()
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/client_events.cpp b/mp/src/game/client/momentum/client_events.cpp
new file mode 100644
index 000000000..a2151f527
--- /dev/null
+++ b/mp/src/game/client/momentum/client_events.cpp
@@ -0,0 +1,59 @@
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "filesystem.h"
+#include "movevars_shared.h"
+#include "client_events.h"
+
+#include "tier0/memdbgon.h"
+
+extern IFileSystem *filesystem;
+
+namespace Momentum {
+
+	void OnClientDLLInit()
+	{
+		// enable console by default
+		ConVarRef con_enable("con_enable");
+		con_enable.SetValue(true);
+		// mount CSS content even if it's on a different drive than SDK
+#ifdef _WIN32
+		HKEY hKey;
+		if (VCRHook_RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+			"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 240",
+			0,
+			KEY_READ,
+			&hKey) == ERROR_SUCCESS)
+		{
+			char installPath[MAX_PATH];
+			DWORD len = sizeof(installPath);
+			if (VCRHook_RegQueryValueEx(hKey,
+				"InstallLocation",
+				NULL,
+				NULL,
+				(LPBYTE)installPath,
+				&len) == ERROR_SUCCESS)
+			{
+				char path[MAX_PATH];
+				Q_strncpy(path, installPath, sizeof(path));
+
+				Q_strncat(path, "\\cstrike", sizeof(path));
+				filesystem->AddSearchPath(path, "GAME");
+
+				Q_strncat(path, "\\download", sizeof(path));
+				filesystem->AddSearchPath(path, "GAME");
+
+				Q_strncpy(path, installPath, sizeof(path));
+				Q_strncat(path, "\\cstrike\\cstrike_pak.vpk", sizeof(path));
+				filesystem->AddSearchPath(path, "GAME");
+
+				filesystem->PrintSearchPaths();
+			}
+
+			VCRHook_RegCloseKey(hKey);
+		}
+#endif
+	}
+
+} // namespace Momentum
diff --git a/mp/src/game/client/momentum/client_events.h b/mp/src/game/client/momentum/client_events.h
new file mode 100644
index 000000000..302cbc8bd
--- /dev/null
+++ b/mp/src/game/client/momentum/client_events.h
@@ -0,0 +1,13 @@
+#ifndef CLIENT_EVENTS_H
+#define CLIENT_EVENTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+namespace Momentum {
+
+	void OnClientDLLInit();
+
+} // namespace Momentum
+
+#endif // CLIENT_EVENTS_H
diff --git a/mp/src/game/client/momentum/fx_cs_impacts.cpp b/mp/src/game/client/momentum/fx_cs_impacts.cpp
new file mode 100644
index 000000000..eaf4859b7
--- /dev/null
+++ b/mp/src/game/client/momentum/fx_cs_impacts.cpp
@@ -0,0 +1,37 @@
+#include "cbase.h"
+#include "fx_impact.h"
+#include "engine/IEngineSound.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle weapon impacts
+//-----------------------------------------------------------------------------
+void ImpactCallback(const CEffectData &data)
+{
+    trace_t tr;
+    Vector vecOrigin, vecStart, vecShotDir;
+    int iMaterial, iDamageType, iHitbox;
+    short nSurfaceProp;
+
+    C_BaseEntity *pEntity = ParseImpactData(data, &vecOrigin, &vecStart, &vecShotDir, nSurfaceProp, iMaterial, iDamageType, iHitbox);
+
+    if (!pEntity)
+        return;
+
+    // If we hit, perform our custom effects and play the sound
+    if (Impact(vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr))
+    {
+        // Check for custom effects based on the Decal index
+        PerformCustomEffects(vecOrigin, tr, vecShotDir, iMaterial, 1.0);
+
+        //Play a ricochet sound some of the time
+        if (random->RandomInt(1, 10) <= 3 && (iDamageType == DMG_BULLET))
+        {
+            CLocalPlayerFilter filter;
+            C_BaseEntity::EmitSound(filter, SOUND_FROM_WORLD, "Bounce.Shrapnel", &vecOrigin);
+        }
+    }
+
+    PlayImpactSound(pEntity, tr, vecOrigin, nSurfaceProp);
+}
+
+DECLARE_CLIENT_EFFECT("Impact", ImpactCallback);
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/fx_cs_muzzleflash.cpp b/mp/src/game/client/momentum/fx_cs_muzzleflash.cpp
new file mode 100644
index 000000000..94768f7a7
--- /dev/null
+++ b/mp/src/game/client/momentum/fx_cs_muzzleflash.cpp
@@ -0,0 +1,133 @@
+#include "cbase.h"
+#include "particles_simple.h"
+#include "particles_localspace.h"
+#include "c_te_effect_dispatch.h"
+#include "clienteffectprecachesystem.h"
+
+// Precache our effects
+CLIENTEFFECT_REGISTER_BEGIN(PrecacheEffect_CS_MuzzleFlash)
+CLIENTEFFECT_MATERIAL("effects/muzzleflashX")	//.vmt
+CLIENTEFFECT_MATERIAL("sprites/muzzleflash4")	//.vmt
+CLIENTEFFECT_REGISTER_END()
+
+void TE_DynamicLight(IRecipientFilter& filter, float delay,
+const Vector* org, int r, int g, int b, int exponent, float radius, float time, float decay, int nLightIndex = LIGHT_INDEX_TE_DYNAMIC);
+
+void CS_MuzzleFlashCallback(const CEffectData &data)
+{
+    CSmartPtr<CLocalSpaceEmitter> pEmitter =
+        CLocalSpaceEmitter::Create("CS_MuzzleFlash", data.m_hEntity, data.m_nAttachmentIndex, 0);
+
+    if (!pEmitter)
+        return;
+
+    // SetBBox() manually on the particle system so it doesn't have to be recalculated more than once.
+    Vector vCenter(0.0f, 0.0f, 0.0f);
+    C_BaseEntity *pEnt = data.GetEntity();
+    if (pEnt)
+    {
+        vCenter = pEnt->WorldSpaceCenter();
+    }
+    else
+    {
+        IClientRenderable *pRenderable = data.GetRenderable();
+        if (pRenderable)
+        {
+            Vector vecMins, vecMaxs;
+            pRenderable->GetRenderBoundsWorldspace(vecMins, vecMaxs);
+            VectorAdd(vecMins, vecMaxs, vCenter);
+            vCenter *= 0.5f;
+        }
+    }
+
+    Assert(pEmitter);
+    pEmitter->GetBinding().SetBBox(vCenter - Vector(3, 3, 3), vCenter + Vector(3, 3, 3));
+
+    // haxors - make the clip much shorter so the alpha is not 
+    // changed based on large clip distances
+    pEmitter->SetNearClip(0, 5);
+
+    PMaterialHandle hFlashMaterial = pEmitter->GetPMaterial("sprites/muzzleflash4");
+
+    for (int i = 0; i<3; i++)
+    {
+        SimpleParticle *pParticle = (SimpleParticle *) pEmitter->AddParticle(sizeof(SimpleParticle),
+            hFlashMaterial,
+            vec3_origin);
+        if (pParticle)
+        {
+            pParticle->m_flLifetime = 0.0f;
+            pParticle->m_flDieTime = 0.08f;
+
+            pParticle->m_vecVelocity = vec3_origin;
+
+            pParticle->m_uchColor[0] = 255;
+            pParticle->m_uchColor[1] = 255;
+            pParticle->m_uchColor[2] = 255;
+
+            pParticle->m_uchStartAlpha = 80;
+            pParticle->m_uchEndAlpha = 30;
+
+            pParticle->m_uchStartSize = (3.0 + 3.0*i) * data.m_flScale;
+
+            pParticle->m_uchEndSize = pParticle->m_uchStartSize * 0.8;
+            pParticle->m_flRoll = random->RandomInt(0, 3);
+
+            pParticle->m_flRollDelta = 0.0f;
+        }
+    }
+
+    // dynamic light temporary entity for the muzzle flash
+    CPVSFilter filter(pEmitter->GetSortOrigin());
+    TE_DynamicLight(filter, 0.0, &(pEmitter->GetSortOrigin()), 255, 192, 64, 5, 70, 0.05, 768);
+}
+
+DECLARE_CLIENT_EFFECT("CS_MuzzleFlash", CS_MuzzleFlashCallback);
+
+
+// 'X' shaped muzzleflash used by certain weapons
+void CS_MuzzleFlashXCallback(const CEffectData &data)
+{
+    CSmartPtr<CLocalSpaceEmitter> pEmitter =
+        CLocalSpaceEmitter::Create("CS_MuzzleFlashX", data.m_hEntity, data.m_nAttachmentIndex, 0);
+
+    Assert(pEmitter);
+
+    // haxors - make the clip much shorter so the alpha is not 
+    // changed based on large clip distances
+    pEmitter->SetNearClip(0, 5);
+
+    PMaterialHandle hFlashMaterial = pEmitter->GetPMaterial("effects/muzzleflashX");
+
+    SimpleParticle *pParticle = (SimpleParticle *) pEmitter->AddParticle(sizeof(SimpleParticle),
+        hFlashMaterial,
+        vec3_origin);
+    if (pParticle)
+    {
+        pParticle->m_flLifetime = 0.0f;
+        pParticle->m_flDieTime = 0.08f;
+
+        pParticle->m_vecVelocity = vec3_origin;
+
+        pParticle->m_uchColor[0] = 255;
+        pParticle->m_uchColor[1] = 255;
+        pParticle->m_uchColor[2] = 255;
+
+        pParticle->m_uchStartAlpha = 130;
+        pParticle->m_uchEndAlpha = 80;
+
+        pParticle->m_uchStartSize = 6.0f * data.m_flScale * random->RandomFloat(0.9, 1.1);
+
+        pParticle->m_uchEndSize = pParticle->m_uchStartSize * 0.8;
+
+        pParticle->m_flRoll = random->RandomFloat(-0.25, 0.25);
+
+        pParticle->m_flRollDelta = 0.0f;
+    }
+
+    // dynamic light temporary entity for the muzzle flash
+    CPVSFilter filter(pEmitter->GetSortOrigin());
+    TE_DynamicLight(filter, 0.0, &(pEmitter->GetSortOrigin()), 255, 192, 64, 5, 70, 0.05, 768);
+}
+
+DECLARE_CLIENT_EFFECT("CS_MuzzleFlash_X", CS_MuzzleFlashXCallback);
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/fx_cs_weaponfx.cpp b/mp/src/game/client/momentum/fx_cs_weaponfx.cpp
new file mode 100644
index 000000000..a39e71e97
--- /dev/null
+++ b/mp/src/game/client/momentum/fx_cs_weaponfx.cpp
@@ -0,0 +1,56 @@
+#include "cbase.h"
+#include "fx_impact.h"
+#include "tempent.h"
+#include "c_te_effect_dispatch.h"
+#include "c_te_legacytempents.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle weapon effect callbacks
+//-----------------------------------------------------------------------------
+void CStrike_EjectBrass(int shell, const CEffectData &data)
+{
+    C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+
+    if (!pPlayer)
+        return;
+
+    tempents->CSEjectBrass(data.m_vOrigin, data.m_vAngles, data.m_fFlags, shell, pPlayer);
+}
+
+void CStrike_FX_EjectBrass_9mm_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_9MM, data);
+}
+
+void CStrike_FX_EjectBrass_57_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_57, data);
+}
+
+void CStrike_FX_EjectBrass_12Gauge_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_12GAUGE, data);
+}
+
+void CStrike_FX_EjectBrass_556_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_556, data);
+}
+
+void CStrike_FX_EjectBrass_762Nato_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_762NATO, data);
+}
+
+void CStrike_FX_EjectBrass_338Mag_Callback(const CEffectData &data)
+{
+    CStrike_EjectBrass(CS_SHELL_338MAG, data);
+}
+
+DECLARE_CLIENT_EFFECT("EjectBrass_9mm", CStrike_FX_EjectBrass_9mm_Callback);
+DECLARE_CLIENT_EFFECT("EjectBrass_12Gauge", CStrike_FX_EjectBrass_12Gauge_Callback);
+DECLARE_CLIENT_EFFECT("EjectBrass_57", CStrike_FX_EjectBrass_57_Callback);
+DECLARE_CLIENT_EFFECT("EjectBrass_556", CStrike_FX_EjectBrass_556_Callback);
+DECLARE_CLIENT_EFFECT("EjectBrass_762Nato", CStrike_FX_EjectBrass_762Nato_Callback);
+DECLARE_CLIENT_EFFECT("EjectBrass_338Mag", CStrike_FX_EjectBrass_338Mag_Callback);
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.cpp b/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.cpp
new file mode 100644
index 000000000..f8cd90d61
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.cpp
@@ -0,0 +1,1250 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+
+#define FILTER_ALLSERVERS			0
+#define FILTER_SECURESERVERSONLY	1
+#define FILTER_INSECURESERVERSONLY	2
+
+#define UNIVERSE_OFFICIAL			0
+#define UNIVERSE_CUSTOMGAMES		1
+
+#undef wcscat
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CGameListPanel::CGameListPanel(CBaseMapsPage *pOuter, const char *pName) :
+BaseClass(pOuter, pName)
+{
+    m_pOuter = pOuter;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Forward KEY_ENTER to the CBaseMapsPage.
+//-----------------------------------------------------------------------------
+void CGameListPanel::OnKeyCodeTyped(vgui::KeyCode code)
+{
+    // Let the outer class handle it.
+    if (code == KEY_ENTER && m_pOuter->OnGameListEnterPressed())
+        return;
+
+    BaseClass::OnKeyCodeTyped(code);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CBaseMapsPage::CBaseMapsPage(vgui::Panel *parent, const char *name, const char *pCustomResFilename)
+    : PropertyPage(parent, name), m_pCustomResFilename(pCustomResFilename)
+{
+    SetSize(624, 278);
+
+    
+    m_iGameModeFilter = 0;
+    m_szMapFilter[0] = 0;
+    m_iDifficultyFilter = 0;
+    m_bFilterHideCompleted = false;
+    m_iMapLayoutFilter = 0;
+    m_iServerRefreshCount = 0;
+
+    m_hFont = NULL;
+
+    // get the 'all' text
+    wchar_t *all = g_pVGuiLocalize->Find("#MOM_MapSelector_All");
+    Q_UnicodeToUTF8(all, m_szComboAllText, sizeof(m_szComboAllText));
+
+    // Init UI
+    m_pStartMap = new Button(this, "StartMapButton", "#MOM_MapSelector_StartMap");
+    m_pStartMap->SetEnabled(false);
+    m_pRefreshAll = new Button(this, "RefreshButton", "#ServerBrowser_Refresh");//Needed for online maps
+    m_pRefreshQuick = new Button(this, "RefreshQuickButton", "#ServerBrowser_RefreshQuick");//Needed for online maps
+    m_pGameList = new CGameListPanel(this, "gamelist");
+    m_pGameList->SetAllowUserModificationOfColumns(true);
+    
+    // Add the column headers
+    m_pGameList->AddColumnHeader(HEADER_COMPLETED, "HasCompleted", "#MOM_MapSelector_Completed", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE);
+    m_pGameList->AddColumnHeader(HEADER_MAPLAYOUT, "MapLayout", "#MOM_MapSelector_MapLayout", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE);
+    //m_pGameList->AddColumnHeader(HEADER_STAGEDMAP, "IsStaged", "#MOM_MapSelector_IsStaged", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE);
+    //m_pGameList->AddColumnHeader(1, "Bots", "#ServerBrowser_Bots", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_HIDDEN);//Don't need
+    //m_pGameList->AddColumnHeader(2, "Secure", "#ServerBrowser_Secure", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE);//Don't need
+    m_pGameList->AddColumnHeader(HEADER_MAPNAME, "Name", "#MOM_MapSelector_Maps", 50, ListPanel::COLUMN_RESIZEWITHWINDOW | ListPanel::COLUMN_UNHIDABLE);//Map name column
+    //m_pGameList->AddColumnHeader(4, "IPAddr", "#ServerBrowser_IPAddress", 64, ListPanel::COLUMN_HIDDEN);
+    m_pGameList->AddColumnHeader(HEADER_GAMEMODE, "gamemode", "#MOM_MapSelector_GameMode", 112,
+        112,	// minwidth
+        300,	// maxwidth
+        0		// flags
+        );
+    m_pGameList->AddColumnHeader(HEADER_DIFFICULTY, "difficulty", "#MOM_MapSelector_Difficulty", 55, 0);//ListPanel::COLUMN_FIXEDSIZE);
+    m_pGameList->AddColumnHeader(HEADER_BESTTIME, "time", "#MOM_MapSelector_BestTime", 90,
+        90,		// minwidth
+        300,	// maxwidth
+        0		// flags
+        );
+    
+    //Tooltips
+    m_pGameList->SetColumnHeaderTooltip(HEADER_COMPLETED, "#MOM_MapSelector_Completed_Tooltip");
+    m_pGameList->SetColumnHeaderTooltip(HEADER_MAPLAYOUT, "#MOM_MapSelector_MapLayout_Tooltip");
+    //MOM_TODO: do we want more tooltips?
+    //m_pGameList->SetColumnHeaderTooltip(1, "#ServerBrowser_BotColumn_Tooltip");
+    //m_pGameList->SetColumnHeaderTooltip(2, "#ServerBrowser_SecureColumn_Tooltip");
+    
+    // setup fast sort functions
+    //MOM_TODO: Make sorting by map names, difficulty, all of the columns
+    /*
+    m_pGameList->SetSortFunc(0, PasswordCompare);
+    m_pGameList->SetSortFunc(1, BotsCompare);
+    m_pGameList->SetSortFunc(2, SecureCompare);
+    m_pGameList->SetSortFunc(3, ServerNameCompare);
+    m_pGameList->SetSortFunc(4, IPAddressCompare);
+    m_pGameList->SetSortFunc(5, GameCompare);
+    m_pGameList->SetSortFunc(6, PlayersCompare);
+    m_pGameList->SetSortFunc(7, MapCompare);
+    m_pGameList->SetSortFunc(8, PingCompare);
+    */
+    // Sort by ping time by default
+    //m_pGameList->SetSortColumn(8);
+
+    CreateFilters();
+    LoadFilterSettings();
+
+    m_bAutoSelectFirstItemInGameList = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CBaseMapsPage::~CBaseMapsPage()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseMapsPage::GetInvalidMapListID()
+{
+    return m_pGameList->InvalidItemID();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::PerformLayout()
+{
+    BaseClass::PerformLayout();
+
+    if (m_pGameList->GetSelectedItemsCount() < 1)
+    {
+        m_pStartMap->SetEnabled(false);
+    }
+    else
+    {
+        m_pStartMap->SetEnabled(true);
+    }
+
+
+    if (SupportsItem(IMapList::GETNEWLIST))
+    {
+        m_pRefreshQuick->SetVisible(true);
+        m_pRefreshAll->SetText("#ServerBrowser_RefreshAll");
+    }
+    else
+    {
+        m_pRefreshQuick->SetVisible(false);
+        m_pRefreshAll->SetVisible(false);//Because local maps won't be searching
+        //m_pRefreshAll->SetText("#ServerBrowser_Refresh");
+    }
+
+    if (IsRefreshing())
+    {
+        m_pRefreshAll->SetText("#ServerBrowser_StopRefreshingList");
+    }
+
+    if (m_pGameList->GetItemCount() > 0)
+    {
+        m_pRefreshQuick->SetEnabled(true);
+    }
+    else
+    {
+        m_pRefreshQuick->SetEnabled(false);
+    }
+    m_pGameList->SetEmptyListText("#MOM_MapSelector_NoMaps");
+#ifndef NO_STEAM
+    //if (!SteamMatchmakingServers() || !SteamMatchmaking())
+    {
+        m_pRefreshQuick->SetEnabled(false);
+        m_pStartMap->SetEnabled(false);
+        m_pRefreshAll->SetEnabled(false);
+        //m_pGameList->SetEmptyListText("#ServerBrowser_SteamRunning");
+    }
+#endif
+    Repaint();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::ApplySchemeSettings(IScheme *pScheme)
+{
+    BaseClass::ApplySchemeSettings(pScheme);
+
+    OnButtonToggled(m_pFilter, false);
+
+    // Images
+    ImageList *imageList = new ImageList(false);
+    //MOM_TODO: Load custom images for the map selector
+    imageList->AddImage(scheme()->GetImage("servers/icon_password", false));//Completed icon (index 1)
+    imageList->AddImage(scheme()->GetImage("servers/icon_bots", false));//Linear map icon (index 2)
+    imageList->AddImage(scheme()->GetImage("servers/icon_robotron", false));//Staged map icon (index 3)
+    //imageList->AddImage(scheme()->GetImage("servers/icon_secure_deny", false));
+
+    int passwordColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_password_column", false));//Completed column header image
+    int botColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_bots_column", false));//Map layout (staged/linear) column header image
+    //int secureColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_robotron_column", false));
+    m_pGameList->SetImageList(imageList, true);
+    m_pGameList->SetColumnHeaderImage(HEADER_COMPLETED, passwordColumnImage);
+    m_pGameList->SetColumnHeaderImage(HEADER_MAPLAYOUT, botColumnImage);
+    //m_pGameList->SetColumnHeaderImage(HEADER_STAGEDMAP, secureColumnImage);
+
+    //Font
+    m_hFont = pScheme->GetFont("ListSmall", IsProportional());
+    if (!m_hFont)
+        m_hFont = pScheme->GetFont("DefaultSmall", IsProportional());
+    m_pGameList->SetFont(m_hFont);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: gets information about specified map
+//-----------------------------------------------------------------------------
+mapstruct_t *CBaseMapsPage::GetMap(unsigned int serverID)
+{
+    //MOM_TODO: This may not be needed
+    /*
+#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+    return NULL;
+
+    if (serverID >= 0)
+    {
+    return SteamMatchmakingServers()->GetServerDetails(m_eMatchMakingType, serverID);
+    }
+    else
+    {
+    Assert(!"Unable to return a useful entry");
+    return NULL; // bugbug Alfred: temp Favorites/History objects won't return a good value here...
+    }
+    #else*/
+    return NULL;
+    //#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::CreateFilters()
+{
+    m_bFiltersVisible = false;
+    m_pFilter = new ToggleButton(this, "Filter", "#MOM_MapSelector_Filter");
+    m_pFilterString = new Label(this, "FilterString", "");
+
+    // filter controls
+    m_pGameModeFilter = new ComboBox(this, "GameModeFilter", 3, false);//"Game mode"
+    m_pGameModeFilter->AddItem("#MOM_MapSelector_All", NULL);//All
+    m_pGameModeFilter->AddItem("#MOM_MapSelector_SurfOnly", NULL);//Surf only
+    m_pGameModeFilter->AddItem("#MOM_MapSelector_BhopOnly", NULL);//Bhop only
+    m_pGameModeFilter->AddActionSignalTarget(this);
+    //MOM_TODO: add extra game mode filter types?
+
+
+    m_pMapFilter = new TextEntry(this, "MapFilter");//As-is, people can search by map name
+    m_pMapFilter->AddActionSignalTarget(this);
+
+    //Difficulty filter
+    m_pDifficultyFilter = new ComboBox(this, "DifficultyFilter", 6, false);
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_All", NULL);
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_LessThanDiff2", NULL);//"Less than Tier 2"
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_LessThanDiff3", NULL);//"Less than Tier 3" 
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_LessThanDiff4", NULL);//etc
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_LessThanDiff5", NULL);//etc
+    m_pDifficultyFilter->AddItem("#MOM_MapSelector_LessThanDiff6", NULL);//MOM_TODO: Is "tier 6" difficulty the highest?
+    m_pDifficultyFilter->AddActionSignalTarget(this);
+
+    //Hide completed maps
+    m_pHideCompletedFilterCheck = new CheckButton(this, "HideCompletedFilterCheck", ""); //for Maps the player has not completed
+    m_pHideCompletedFilterCheck->AddActionSignalTarget(this);
+
+    //Filter staged/linear
+    m_pMapLayoutFilter = new ComboBox(this, "MapLayoutFilter", 3, false);
+    m_pMapLayoutFilter->AddItem("#MOM_MapSelector_All", NULL);
+    m_pMapLayoutFilter->AddItem("#MOM_MapSelector_StagedOnly", NULL);
+    m_pMapLayoutFilter->AddItem("#MOM_MapSelector_LinearOnly", NULL);
+    m_pMapLayoutFilter->AddActionSignalTarget(this);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: loads filter settings (from disk) from the keyvalues
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::LoadFilterSettings()
+{
+    KeyValues *filter = MapSelectorDialog().GetFilterSaveData(GetName());
+
+    //Game-mode selection
+    m_iGameModeFilter = filter->GetInt("gamemode", 0);
+    m_pGameModeFilter->ActivateItemByRow(m_iGameModeFilter);
+
+    //"Map"
+    Q_strncpy(m_szMapFilter, filter->GetString("map"), sizeof(m_szMapFilter));
+    m_pMapFilter->SetText(m_szMapFilter);
+
+    //Map layout
+    m_iMapLayoutFilter = filter->GetInt("maplayout", 0);
+    m_pMapLayoutFilter->ActivateItemByRow(m_iMapLayoutFilter);
+
+    //HideCompleted maps
+    m_bFilterHideCompleted = filter->GetBool("HideCompleted", false);
+    m_pHideCompletedFilterCheck->SetSelected(m_bFilterHideCompleted);
+
+    //Difficulty
+    m_iDifficultyFilter = filter->GetInt("difficulty");
+    if (m_iDifficultyFilter)
+    {
+        char buf[32];
+        Q_snprintf(buf, sizeof(buf), "< %d", m_iDifficultyFilter);
+        m_pDifficultyFilter->SetText(buf);
+    }
+
+    // apply to the controls
+    OnLoadFilter(filter);
+    UpdateFilterSettings();
+    ApplyGameFilters();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles incoming server refresh data
+//			updates the server browser with the refreshed information from the server itself
+//-----------------------------------------------------------------------------
+/*void CBaseMapsPage::ServerResponded(gameserveritem_t &server)
+{
+int nIndex = -1; // start at -1 and work backwards to find the next free slot for this adhoc query
+while (m_mapServers.Find(nIndex) != m_mapServers.InvalidIndex())
+nIndex--;
+ServerResponded(nIndex, &server);
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for ISteamMatchmakingServerListResponse
+//-----------------------------------------------------------------------------
+/*void CBaseMapsPage::ServerResponded(int iServer)
+{
+/*
+#ifndef NO_STEAM
+gameserveritem_t *pServerItem = SteamMatchmakingServers()->GetServerDetails(m_eMatchMakingType, iServer);
+if (!pServerItem)
+{
+Assert(!"Missing server response");
+return;
+}
+ServerResponded(iServer, pServerItem);
+#endif
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles incoming server refresh data
+//			updates the server browser with the refreshed information from the server itself
+//-----------------------------------------------------------------------------
+//MOM_TODO: Use custom Steam HTML callbacks to handle data to parse from API
+
+
+//*******
+
+//THIS WILL BE USED FOR ONLINE!! DO NOT REMOVE!!!!!!!!!!
+
+//********
+/*void CBaseMapsPage::ServerResponded(int iServer, gameserveritem_t *pServerItem)
+{
+int iServerMap = m_mapServers.Find(iServer);
+if (iServerMap == m_mapServers.InvalidIndex())
+{
+netadr_t netAdr(pServerItem->m_NetAdr.GetIP(), pServerItem->m_NetAdr.GetQueryPort());
+int iServerIP = m_mapServerIP.Find(netAdr);
+if (iServerIP != m_mapServerIP.InvalidIndex())
+{
+// if we already had this entry under another index remove the old entry
+int iServerMap = m_mapServers.Find(m_mapServerIP[iServerIP]);
+if (iServerMap != m_mapServers.InvalidIndex())
+{
+serverdisplay_t &server = m_mapServers[iServerMap];
+if (m_pGameList->IsValidItemID(server.m_iListID))
+m_pGameList->RemoveItem(server.m_iListID);
+m_mapServers.RemoveAt(iServerMap);
+}
+m_mapServerIP.RemoveAt(iServerIP);
+}
+
+serverdisplay_t serverFind;
+serverFind.m_iListID = -1;
+serverFind.m_bDoNotRefresh = false;
+iServerMap = m_mapServers.Insert(iServer, serverFind); // MOM_TODO : ADDS TO
+m_mapServerIP.Insert(netAdr, iServer);
+}
+
+serverdisplay_t *pServer = &m_mapServers[iServerMap];
+pServer->m_iServerID = iServer;
+Assert(pServerItem->m_NetAdr.GetIP() != 0);
+
+// check filters
+bool removeItem = false;
+if (!CheckPrimaryFilters(*pServerItem))
+{
+// server has been filtered at a primary level
+// remove from lists
+pServer->m_bDoNotRefresh = true;
+
+// remove from UI list
+removeItem = true;
+}
+else if (!CheckSecondaryFilters(*pServerItem))
+{
+// we still ping this server in the future; however it is removed from UI list
+removeItem = true;
+}
+
+if (removeItem)
+{
+if (m_pGameList->IsValidItemID(pServer->m_iListID))
+{
+m_pGameList->RemoveItem(pServer->m_iListID);
+pServer->m_iListID = GetInvalidServerListID();
+}
+return;
+}
+
+// update UI
+KeyValues *kv;
+if (m_pGameList->IsValidItemID(pServer->m_iListID))
+{
+// we're updating an existing entry
+kv = m_pGameList->GetItem(pServer->m_iListID);
+m_pGameList->SetUserData(pServer->m_iListID, pServer->m_iServerID);
+}
+else
+{
+// new entry
+kv = new KeyValues("Server");
+}
+
+kv->SetString("name", pServerItem->GetName());
+kv->SetString("map", pServerItem->m_szMap);
+kv->SetString("GameDir", pServerItem->m_szGameDir);
+kv->SetString("GameDesc", pServerItem->m_szGameDescription);
+kv->SetInt("password", pServerItem->m_bPassword ? 1 : 0);
+
+if (pServerItem->m_nBotPlayers > 0)
+kv->SetInt("bots", pServerItem->m_nBotPlayers);
+else
+kv->SetString("bots", "");
+
+//if (pServerItem->m_bSecure)
+//{
+// show the denied icon if banned from secure servers, the secure icon otherwise
+//    kv->SetInt("secure", ServerBrowser().IsVACBannedFromGame(pServerItem->m_nAppID) ? 4 : 3);
+//}
+//else
+{
+kv->SetInt("secure", 0);
+}
+
+kv->SetString("IPAddr", pServerItem->m_NetAdr.GetConnectionAddressString());
+
+int nAdjustedForBotsPlayers = max(0, pServerItem->m_nPlayers - pServerItem->m_nBotPlayers);
+int nAdjustedForBotsMaxPlayers = max(0, pServerItem->m_nMaxPlayers - pServerItem->m_nBotPlayers);
+
+char buf[32];
+Q_snprintf(buf, sizeof(buf), "%d / %d", nAdjustedForBotsPlayers, nAdjustedForBotsMaxPlayers);
+kv->SetString("Players", buf);
+
+kv->SetInt("Ping", pServerItem->m_nPing);
+
+kv->SetString("Tags", pServerItem->m_szGameTags);
+
+if (pServerItem->m_ulTimeLastPlayed)
+{
+// construct a time string for last played time
+struct tm *now;
+now = localtime((time_t*) &pServerItem->m_ulTimeLastPlayed);
+
+if (now)
+{
+char buf[64];
+strftime(buf, sizeof(buf), "%a %d %b %I:%M%p", now);
+Q_strlower(buf + strlen(buf) - 4);
+kv->SetString("LastPlayed", buf);
+}
+}
+
+if (pServer->m_bDoNotRefresh)
+{
+// clear out the vars
+kv->SetString("Ping", "");
+kv->SetWString("GameDesc", g_pVGuiLocalize->Find("#ServerBrowser_NotResponding"));
+kv->SetString("Players", "");
+kv->SetString("map", "");
+}
+
+if (!m_pGameList->IsValidItemID(pServer->m_iListID))
+{
+// new server, add to list
+pServer->m_iListID = m_pGameList->AddItem(kv, pServer->m_iServerID, false, false);
+if (m_bAutoSelectFirstItemInGameList && m_pGameList->GetItemCount() == 1)
+{
+m_pGameList->AddSelectedItem(pServer->m_iListID);
+}
+
+kv->deleteThis();
+}
+else
+{
+// tell the list that we've changed the data
+m_pGameList->ApplyItemChanges(pServer->m_iListID);
+m_pGameList->SetItemVisible(pServer->m_iListID, true);
+}
+
+UpdateStatus();
+m_iServerRefreshCount++;
+}*/
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles filter dropdown being toggled
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnButtonToggled(Panel *panel, int state)
+{
+    if (panel == m_pFilter)
+    {
+        int wide, tall;
+        GetSize(wide, tall);
+        SetSize(624, 278);
+        if (m_pCustomResFilename)//MOM_TODO: this will never happen, consider removing?
+        {
+            m_bFiltersVisible = false;
+        }
+        else
+        {
+            if (m_pFilter->IsSelected())
+            {
+                // drop down
+                m_bFiltersVisible = true;
+            }
+            else
+            {
+                // hide filter area
+                m_bFiltersVisible = false;
+            }
+        }
+
+        UpdateDerivedLayouts();
+        m_pFilter->SetSelected(m_bFiltersVisible);
+
+        if (m_hFont)
+        {
+            SETUP_PANEL(m_pGameList);
+            m_pGameList->SetFont(m_hFont);
+        }
+
+        SetSize(wide, tall);
+
+        InvalidateLayout();
+    }
+    else if (panel == m_pHideCompletedFilterCheck)
+    {
+        // treat changing these buttons like any other filter has changed
+        OnTextChanged(panel, "");
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::UpdateDerivedLayouts(void)
+{
+    char rgchControlSettings[MAX_PATH];
+    if (m_pCustomResFilename)//MOM_TODO: this will never be custom, look into removing this?
+    {
+        Q_snprintf(rgchControlSettings, sizeof(rgchControlSettings), "%s", m_pCustomResFilename);
+    }
+    else
+    {
+        if (m_pFilter->IsSelected())
+        {
+            // drop down
+            Q_snprintf(rgchControlSettings, sizeof(rgchControlSettings), "resource/ui/%sPage_Filters.res", GetName());
+        }
+        else
+        {
+            // hide filter area
+            Q_snprintf(rgchControlSettings, sizeof(rgchControlSettings), "resource/ui/%sPage.res", GetName());
+        }
+    }
+
+    LoadControlSettings(rgchControlSettings);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the game dir combo box is changed
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnTextChanged(Panel *panel, const char *text)
+{
+    if (!Q_stricmp(text, m_szComboAllText))
+    {
+        ComboBox *box = dynamic_cast<ComboBox *>(panel);
+        if (box)
+        {
+            box->SetText("");
+            text = "";
+        }
+    }
+
+    // get filter settings from controls
+    UpdateFilterSettings();
+    // apply settings
+    ApplyGameFilters();
+
+    if (m_bFiltersVisible && (panel == m_pGameModeFilter || panel == m_pDifficultyFilter || panel == m_pMapFilter
+         || panel == m_pMapLayoutFilter))
+    {
+        // if they changed filter settings then cancel the refresh because the old list they are getting
+        // will be for the wrong map or gametype, so stop and start a refresh
+        StopRefresh();
+        //If the filters have changed, we'll want to send a new request with the new data
+        //MOM_TODO: uncomment this: StartRefresh()
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: applies only the game filter to the current list
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::ApplyGameFilters()
+{
+    // loop through all the maps checking filters
+    FOR_EACH_VEC(m_vecMaps, i)
+    {
+        mapdisplay_t &map = m_vecMaps[i];
+        mapstruct_t* mapinfo = &map.m_mMap;
+        //DevLog("CURRENTLY FILTERING %s\n", mapinfo->m_szMapName);
+        if (!CheckPrimaryFilters(*mapinfo) || !CheckSecondaryFilters(*mapinfo))//MOM_TODO: change this to just one filter check?
+        {
+            //Failed filters, remove the map
+            map.m_bDoNotRefresh = true;
+            if (m_pGameList->IsValidItemID(map.m_iListID))
+            {
+                m_pGameList->SetItemVisible(map.m_iListID, false);
+            }
+        }
+        else if (BShowMap(map))
+        {
+            map.m_bDoNotRefresh = false;
+            if (!m_pGameList->IsValidItemID(map.m_iListID))
+            {
+                //DevLog("ADDING MAP TO LIST! %s\n ", mapinfo->m_szMapName);
+                KeyValues *kv = new KeyValues("Map");
+                kv->SetString("name", mapinfo->m_szMapName);
+                kv->SetString("map", mapinfo->m_szMapName);
+                kv->SetInt("gamemode", mapinfo->m_iGameMode);
+                kv->SetInt("difficulty", mapinfo->m_iDifficulty);
+                kv->SetInt("MapLayout", ((int)mapinfo->m_bHasStages) + 2);//+ 2 so the picture sets correctly
+                kv->SetBool("HasCompleted", mapinfo->m_bCompleted);
+                kv->SetString("time", mapinfo->m_szBestTime);
+
+                map.m_iListID = m_pGameList->AddItem(kv, NULL, false, false);
+                kv->deleteThis();
+            }
+            // make sure the map is visible
+            m_pGameList->SetItemVisible(map.m_iListID, true);
+        }
+    }
+
+    UpdateStatus();
+    m_pGameList->SortList();
+    InvalidateLayout();
+    Repaint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets UI map count
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::UpdateStatus()
+{
+    if (m_pGameList->GetItemCount() > 1)
+    {
+        wchar_t header[256];
+        wchar_t count[128];
+
+        V_snwprintf(count, ARRAYSIZE(count), L"%d", m_pGameList->GetItemCount());
+        g_pVGuiLocalize->ConstructString(header, sizeof(header), g_pVGuiLocalize->Find("#MOM_MapSelector_MapCount"), 1, count);
+        m_pGameList->SetColumnHeaderText(HEADER_MAPNAME, header);
+    }
+    else
+    {
+        m_pGameList->SetColumnHeaderText(HEADER_MAPNAME, g_pVGuiLocalize->Find("#MOM_MapSelector_Maps"));
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: gets filter settings from controls
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::UpdateFilterSettings()
+{
+    //Gamemode
+    m_iGameModeFilter = m_pGameModeFilter->GetActiveItem();
+
+    // map
+    m_pMapFilter->GetText(m_szMapFilter, sizeof(m_szMapFilter) - 1);
+    Q_strlower(m_szMapFilter);
+
+    // Difficulty
+    char buf[256];
+    m_pDifficultyFilter->GetText(buf, sizeof(buf));
+    if (buf[0])
+    {
+        //"< #"
+        //The + 2 goes over the '<' and ' '
+        m_iDifficultyFilter = Q_atoi(buf + 2);
+    }
+    else
+    {
+        m_iDifficultyFilter = 0;
+    }
+
+    // Hide completed maps
+    m_bFilterHideCompleted = m_pHideCompletedFilterCheck->IsSelected();
+    // Showing specfic map layouts?
+    m_iMapLayoutFilter = m_pMapLayoutFilter->GetActiveItem();
+
+    // copy filter settings into filter file
+    KeyValues *filter = MapSelectorDialog().GetFilterSaveData(GetName());
+
+    filter->SetInt("gamemode", m_iGameModeFilter);
+    filter->SetString("map", m_szMapFilter);
+    filter->SetInt("difficulty", m_iDifficultyFilter);
+    filter->SetBool("HideCompleted", m_bFilterHideCompleted);
+    filter->SetInt("maplayout", m_iMapLayoutFilter);
+
+    MapSelectorDialog().SaveUserData();
+    OnSaveFilter(filter);
+
+    RecalculateFilterString();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: allow derived classes access to the saved filter string
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnSaveFilter(KeyValues *filter)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: allow derived classes access to the saved filter string
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnLoadFilter(KeyValues *filter)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: reconstructs the filter description string from the current filter settings
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::RecalculateFilterString()
+{
+    //MOM_TODO: What is the purpose of this function?
+
+
+    /*wchar_t unicode[2048], tempUnicode[128], spacerUnicode[8];
+    unicode[0] = 0;
+    int iTempUnicodeSize = sizeof(tempUnicode);
+
+    Q_UTF8ToUnicode("; ", spacerUnicode, sizeof(spacerUnicode));
+
+    if (m_szGameFilter[0])
+    {
+    //Q_UTF8ToUnicode(ModList().GetModNameForModDir(m_szGameFilter, m_iLimitToAppID), tempUnicode, iTempUnicodeSize);
+    //wcscat(unicode, tempUnicode);
+    //wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_iSecureFilter == FILTER_SECURESERVERSONLY)
+    {
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescSecureOnly"));
+    wcscat(unicode, spacerUnicode);
+    }
+    else if (m_iSecureFilter == FILTER_INSECURESERVERSONLY)
+    {
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescInsecureOnly"));
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_pLocationFilter->GetActiveItem() > 0)
+    {
+    m_pLocationFilter->GetText(tempUnicode, sizeof(tempUnicode));
+    wcscat(unicode, tempUnicode);
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_iDifficultyFilter)
+    {
+    char tmpBuf[16];
+    Q_snprintf(tmpBuf, sizeof(tmpBuf), "%d", m_iDifficultyFilter);
+
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescLatency"));
+    Q_UTF8ToUnicode(" < ", tempUnicode, iTempUnicodeSize);
+    wcscat(unicode, tempUnicode);
+    Q_UTF8ToUnicode(tmpBuf, tempUnicode, iTempUnicodeSize);
+    wcscat(unicode, tempUnicode);
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_bFilterNoFullServers)
+    {
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescNotFull"));
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_bFilterNoEmptyServers)
+    {
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescNotEmpty"));
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_bFilterNoPasswordedServers)
+    {
+    wcscat(unicode, g_pVGuiLocalize->Find("#ServerBrowser_FilterDescNoPassword"));
+    wcscat(unicode, spacerUnicode);
+    }
+
+    if (m_szMapFilter[0])
+    {
+    Q_UTF8ToUnicode(m_szMapFilter, tempUnicode, iTempUnicodeSize);
+    wcscat(unicode, tempUnicode);
+    }
+
+    m_pFilterString->SetText(unicode);*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks to see if the map passes the primary filters
+//			if the server fails the filters, it will not be refreshed again
+//-----------------------------------------------------------------------------
+bool CBaseMapsPage::CheckPrimaryFilters(mapstruct_t &map)
+{
+    // Needs to pass map name filter
+    // compare the first few characters of the filter
+    int count = Q_strlen(m_szMapFilter);
+
+    if (!Q_strnicmp(map.m_szMapName, "credits", Q_strlen(map.m_szMapName)))
+    {
+        DevLog("Ignoring credits map\n");
+        return false;
+    }
+    if (!Q_strnicmp(map.m_szMapName, "background_01", Q_strlen(map.m_szMapName)))
+    {
+        DevLog("Ignoring background map\n");
+        return false;
+    }
+
+    if (count && Q_strnicmp(map.m_szMapName, m_szMapFilter, count))
+    {
+        DevLog("Map %s does not pass filter %s \n", map.m_szMapName, m_szMapFilter);
+        return false;
+    }
+
+    //Difficulty needs to pass as well
+    if (m_iDifficultyFilter != 0 && map.m_iDifficulty >= m_iDifficultyFilter)
+    {
+        DevLog("Map %s's difficulty %i is greater than difficulty %i !\n", map.m_szMapName, map.m_iDifficulty, m_iDifficultyFilter);
+        return false;
+    }
+    //Game mode (if it's a surf/bhop/etc map or not)
+    if (m_iGameModeFilter != 0 && m_iGameModeFilter != map.m_iGameMode)
+    {
+        DevLog("Map %s's gamemode %i is not filter gamemode %i !\n", map.m_szMapName, map.m_iGameMode, m_iGameModeFilter);
+        return false;
+    }
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks to see if a server passes the secondary set of filters
+//			server will be continued to be pinged if it fails the filter, since
+//			the relvent server data is dynamic
+//-----------------------------------------------------------------------------
+bool CBaseMapsPage::CheckSecondaryFilters(mapstruct_t &map)
+{
+    //Completion is only secondary
+    if (m_bFilterHideCompleted && map.m_bCompleted)//If we're HIDING completed maps and we've completed it
+    {
+        DevLog("Map is completed %i and the player is filtering maps %i \n", map.m_bCompleted, m_bFilterHideCompleted);
+        return false;//It fails the filter, hide it
+    }
+
+    // Map layout (0 = all, 1 = show staged maps only, 2 = show linear maps only)
+    if (m_iMapLayoutFilter && ((int) map.m_bHasStages) + 1 == m_iMapLayoutFilter)
+    {
+        DevLog("Map has stages %i and the user is filtering maps %i\n", map.m_bHasStages, m_iMapLayoutFilter);
+        return false;
+    }
+
+    return CheckTagFilter(map);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: call to let the UI now whether the game list is currently refreshing
+// MOM_TODO: Use this method for OnlineMaps
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::SetRefreshing(bool state)
+{
+    //MOM_TODO: The OnlineMaps tab will have its own "search" using the filter
+    // that is the same filter as the one in LocalMaps, asking the API (using filter data)
+    // and populating the list with the map data from API.
+
+    if (state)
+    {
+        MapSelectorDialog().UpdateStatusText("#MOM_MapSelector_SearchingForMaps");
+
+        // clear message in panel
+        m_pGameList->SetEmptyListText("");
+        m_pRefreshAll->SetText("#MOM_MapSelector_StopSearching");
+        m_pRefreshAll->SetCommand("stoprefresh");
+        m_pRefreshQuick->SetEnabled(false);
+    }
+    else
+    {
+        MapSelectorDialog().UpdateStatusText("");
+        if (SupportsItem(IMapList::GETNEWLIST))
+        {
+            m_pRefreshAll->SetText("#MOM_MapSelector_Search");
+        }
+        else
+        {
+            //MOM_TODO: hide the button? This else branch is specifically the LocalMaps one
+            m_pRefreshAll->SetVisible(false);
+            //m_pRefreshAll->SetText("#ServerBrowser_Refresh");
+        }
+        m_pRefreshAll->SetCommand("GetNewList");
+
+        // 'refresh quick' button is only enabled if there are servers in the list
+        if (m_pGameList->GetItemCount() > 0)
+        {
+            m_pRefreshQuick->SetEnabled(true);
+        }
+        else
+        {
+            m_pRefreshQuick->SetEnabled(false);
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnCommand(const char *command)
+{
+    if (!Q_stricmp(command, "StartMap"))
+    {
+        OnMapStart();
+    }
+    else if (!Q_stricmp(command, "stoprefresh"))
+    {
+        // cancel the existing refresh
+        StopRefresh();
+    }
+    else if (!Q_stricmp(command, "refresh"))
+    {
+#ifndef NO_STEAM
+        //if (SteamMatchmakingServers())
+        //    SteamMatchmakingServers()->RefreshQuery(m_eMatchMakingType);
+        SetRefreshing(true);
+        m_iServerRefreshCount = 0;
+#endif
+    }
+    else if (!Q_stricmp(command, "GetNewList"))
+    {
+        GetNewMapList();
+    }
+    else
+    {
+        BaseClass::OnCommand(command);
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a row gets selected in the list
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnItemSelected()
+{
+    if (m_pGameList->GetSelectedItemsCount() < 1)
+    {
+        m_pStartMap->SetEnabled(false);
+    }
+    else
+    {
+        m_pStartMap->SetEnabled(true);
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes server list on F5
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnKeyCodePressed(vgui::KeyCode code)
+{
+    if (code == KEY_F5)
+    {
+        StartRefresh();
+    }
+    else
+    {
+        BaseClass::OnKeyCodePressed(code);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle enter pressed in the games list page. Return true
+// to intercept the message instead of passing it on through vgui.
+//-----------------------------------------------------------------------------
+bool CBaseMapsPage::OnGameListEnterPressed()
+{
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the # items selected in the game list.
+//-----------------------------------------------------------------------------
+int CBaseMapsPage::GetSelectedItemsCount()
+{
+    return m_pGameList->GetSelectedItemsCount();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+/*void CBaseMapsPage::ServerFailedToRespond(int iServer)
+{
+ServerResponded(iServer);
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: removes the server from the UI list
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::RemoveMap(mapdisplay_t &map)
+{
+    if (m_pGameList->IsValidItemID(map.m_iListID))
+    {
+        // don't remove the server from list, just hide since this is a lot faster
+        m_pGameList->SetItemVisible(map.m_iListID, false);
+
+        // find the row in the list and kill
+        //	m_pGameList->RemoveItem(server.listEntryID);
+        //	server.listEntryID = GetInvalidServerListID();
+    }
+
+    UpdateStatus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes a single server
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnRefreshServer(int serverID)
+{
+    //MOM_TODO: for the mp/ port?
+    /*
+#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+    return;
+
+    // walk the list of selected servers refreshing them
+    for (int i = 0; i < m_pGameList->GetSelectedItemsCount(); i++)
+    {
+    int serverID = m_pGameList->GetItemUserData(m_pGameList->GetSelectedItem(i));
+
+    // refresh this server
+    SteamMatchmakingServers()->RefreshServer(m_eMatchMakingType, serverID);
+    }
+
+    SetRefreshing(IsRefreshing());
+    #endif
+    */
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: starts the servers refreshing
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::StartRefresh()
+{
+    //ClearServerList();
+    //SetRefreshing(true);
+    //MOM_TODO: Update this to request maps from main server
+    /*
+#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+    return;
+
+    ClearServerList();
+    MatchMakingKeyValuePair_t *pFilters;
+    int nFilters = GetServerFilters(&pFilters);
+
+    switch (m_eMatchMakingType)
+    {
+    case eFavoritesServer:
+    SteamMatchmakingServers()->RequestFavoritesServerList(GetFilterAppID(), &pFilters, nFilters, this);
+    break;
+    case eHistoryServer:
+    SteamMatchmakingServers()->RequestHistoryServerList(GetFilterAppID(), &pFilters, nFilters, this);
+    break;
+    case eInternetServer:
+    SteamMatchmakingServers()->RequestInternetServerList(GetFilterAppID(), &pFilters, nFilters, this);
+    break;
+    case eSpectatorServer:
+    SteamMatchmakingServers()->RequestSpectatorServerList(GetFilterAppID(), &pFilters, nFilters, this);
+    break;
+    case eFriendsServer:
+    SteamMatchmakingServers()->RequestFriendsServerList(GetFilterAppID(), &pFilters, nFilters, this);
+    break;
+    case eLANServer:
+    SteamMatchmakingServers()->RequestLANServerList(GetFilterAppID(), this);
+    break;
+    default:
+    Assert(!"Unknown server type");
+    break;
+    }
+
+    SetRefreshing(true);
+    #endif
+    */
+    m_iServerRefreshCount = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove all the maps we currently have
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::ClearMapList()
+{
+    m_vecMaps.RemoveAll();
+
+    //m_mapServers.RemoveAll();//MOM_TODO: remove this?
+    //m_mapServerIP.RemoveAll();
+    m_pGameList->RemoveAll();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: get a new list of maps from the backend
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::GetNewMapList()
+{
+    StartRefresh();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: stops current refresh/GetNewMapList()
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::StopRefresh()
+{
+    // clear update states
+    m_iServerRefreshCount = 0;
+#ifndef NO_STEAM
+    // Stop the server list refreshing
+    //MOM_TODO: implement the following by HTTP request for online maps?
+    // steamapicontext->SteamHTTP()->ReleaseHTTPRequest()
+
+    //if (SteamMatchmakingServers())
+    //    SteamMatchmakingServers()->CancelQuery(m_eMatchMakingType);
+#endif
+    // update UI
+    //RefreshComplete(eServerResponded);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the list is currently searching for maps
+//-----------------------------------------------------------------------------
+bool CBaseMapsPage::IsRefreshing()
+{
+    //MOM_TODO: 
+    // steamapicontext->SteamUtils()->IsAPICallCompleted() on the HTTP request for the online
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates the page, starts refresh
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnPageShow()
+{
+    StartRefresh();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called on page hide, stops any refresh
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnPageHide()
+{
+    StopRefresh();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: initiates map loading
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnMapStart()
+{
+    if (!m_pGameList->GetSelectedItemsCount())
+        return;
+
+    // get the map
+    //MOM_TODO: get the mapstruct_t data instead of KVs here
+    KeyValues *kv = m_pGameList->GetItem(m_pGameList->GetSelectedItem(0));
+    // Stop the current search (online maps)
+    StopRefresh();
+    
+    //MOM_TODO: set global gamemode, which sets tick settings etc
+    //TickSet::SetTickrate(MOMGM_BHOP);
+    //engine->ServerCmd(VarArgs("mom_gamemode %i", MOMGM_BHOP));//MOM_TODO this is testing, replace with m.m_iGamemode
+
+    // Start the map
+    engine->ExecuteClientCmd("progress_enable\n");
+    engine->ExecuteClientCmd(VarArgs("map %s\n", kv->GetString("map")));
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays the current map info (from contextmenu)
+//-----------------------------------------------------------------------------
+void CBaseMapsPage::OnViewMapInfo()
+{
+    if (!m_pGameList->GetSelectedItemsCount())
+        return;
+
+    // get the map
+    KeyValues *pMap = m_pGameList->GetItem(m_pGameList->GetSelectedItem(0));
+
+    //MOM_TODO: pass mapstruct_t data over to the map info dialog!
+    //m_vecMaps.
+
+    //This is how the ServerBrowser did it, they used UserData from the list,
+    //and called the CUtlMap<int <---(ID), mapstruct_t> Get() method
+    //int serverID = m_pGameList->GetItemUserData(m_pGameList->GetSelectedItem(0));
+
+    // Stop the current refresh
+    StopRefresh();
+    // View the map info
+    MapSelectorDialog().OpenMapInfoDialog(this, pMap);
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.h b/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.h
new file mode 100644
index 000000000..91c15c607
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.h
@@ -0,0 +1,200 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef BASEGAMESPAGE_H
+#define BASEGAMESPAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CBaseMapsPage;
+
+//-----------------------------------------------------------------------------
+// Purpose: Acts like a regular ListPanel but forwards enter key presses
+// to its outer control.
+//-----------------------------------------------------------------------------
+class CGameListPanel : public vgui::ListPanel
+{
+public:
+    DECLARE_CLASS_SIMPLE(CGameListPanel, vgui::ListPanel);
+
+    CGameListPanel(CBaseMapsPage *pOuter, const char *pName);
+
+    virtual void OnKeyCodeTyped(vgui::KeyCode code);
+
+private:
+    CBaseMapsPage *m_pOuter;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Base property page for all the games lists (internet/favorites/lan/etc.)
+//-----------------------------------------------------------------------------
+class CBaseMapsPage : public vgui::PropertyPage, public IMapList
+{
+    DECLARE_CLASS_SIMPLE(CBaseMapsPage, vgui::PropertyPage);
+
+public:
+    CBaseMapsPage(vgui::Panel *parent, const char *name, const char *pCustomResFilename = NULL);
+    ~CBaseMapsPage();
+
+    virtual void PerformLayout();
+    virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+
+    // gets information about specified map
+    //MOM_TODO: consider how we're going to ID maps for handling 
+    //(creating CMapInfoDialog and actually starting/downloading map)
+    //PropertyPages have some sort of unsigned int IDs assigned to
+    //things added into the list (see , and ServerBrowser used the Matchmaking ID of the
+    //server as the handle, but since we don't have that, all we have is map name?
+    virtual mapstruct_t *GetMap(unsigned int serverID);
+
+    //uint32 GetServerFilters(MatchMakingKeyValuePair_t **pFilters); Used by server browser, this will translate
+    //into API call filters
+
+    
+
+    // loads filter settings from disk
+    virtual void LoadFilterSettings();
+
+    // Called by CGameList when the enter key is pressed.
+    // This is overridden in the add server dialog - since there is no Connect button, the message
+    // never gets handled, but we want to add a server when they dbl-click or press enter.
+    virtual bool OnGameListEnterPressed();
+
+    int GetSelectedItemsCount();
+
+    
+
+    virtual void UpdateDerivedLayouts(void);
+    //STEAM_CALLBACK(CBaseMapsPage, OnFavoritesMsg, FavoritesListChanged_t, m_CallbackFavoritesMsg);
+    //MOM_TODO: STEAM_CALLBACK for the HTTP requests for maps
+protected:
+    virtual void OnCommand(const char *command);
+    virtual void OnKeyCodePressed(vgui::KeyCode code);
+    virtual int GetRegionCodeToFilter() { return -1; }
+    
+    MESSAGE_FUNC(OnItemSelected, "ItemSelected");
+
+    // applies games filters to current list
+    void ApplyGameFilters();
+    // updates server count UI
+    void UpdateStatus();
+
+    //MOM_TODO: Look into custom HTTP callbacks for the below
+
+    // ISteamMatchmakingServerListResponse callbacks
+    /*virtual void ServerResponded(HServerListRequest hReq, int iServer);
+    virtual void ServerFailedToRespond(HServerListRequest hRequest, int iServer);
+    virtual void RefreshComplete(HServerListRequest hRequest, EMatchMakingServerResponse response) = 0;
+
+    virtual void ServerResponded(int iServer, gameserveritem_t *pServerItem);
+
+    // ISteamMatchmakingPingResponse callbacks
+    virtual void ServerResponded(gameserveritem_t &server);
+    virtual void ServerFailedToRespond() {}*/
+
+    // Removes map from list
+    void RemoveMap(mapdisplay_t&);
+
+    //MOM_TODO: Correlate this to online maps
+    virtual bool BShowMap(mapdisplay_t &server) { return server.m_bDoNotRefresh; }
+
+    //Clears the list of maps
+    void ClearMapList();
+
+    // filtering methods
+    // returns true if filters passed; false if failed
+    virtual bool CheckPrimaryFilters(mapstruct_t &);
+    virtual bool CheckSecondaryFilters(mapstruct_t &);
+    virtual bool CheckTagFilter(mapstruct_t &) { return true; }
+    virtual int GetInvalidMapListID();
+
+    virtual void OnSaveFilter(KeyValues *filter);
+    virtual void OnLoadFilter(KeyValues *filter);
+    virtual void UpdateFilterSettings();
+
+    virtual void GetNewMapList();
+    //MOM_TODO: Make these methods "search" for maps based on filter data
+    virtual void StartRefresh();
+    virtual void StopRefresh();
+    virtual bool IsRefreshing();
+    virtual void SetRefreshing(bool state);
+    virtual void OnPageShow();
+    virtual void OnPageHide();
+
+    // called when Connect button is pressed
+    MESSAGE_FUNC(OnMapStart, "StartMap");
+    // called to look at game info
+    MESSAGE_FUNC(OnViewMapInfo, "ViewMapInfo");
+    // refreshes a single server
+    MESSAGE_FUNC_INT(OnRefreshServer, "RefreshServer", serverID);
+
+    // If true, then we automatically select the first item that comes into the games list.
+    bool m_bAutoSelectFirstItemInGameList;
+
+    CGameListPanel *m_pGameList;
+
+    // command buttons
+    vgui::Button *m_pStartMap;
+    vgui::Button *m_pRefreshAll;//MOM_TODO: change to "m_pSearchMaps"
+    vgui::Button *m_pRefreshQuick;
+    vgui::ToggleButton *m_pFilter;
+
+    CUtlVector<mapdisplay_t> m_vecMaps;
+
+    int m_iServerRefreshCount;//MOM_TODO: change this to "maps found online" ?
+
+
+protected:
+    virtual void CreateFilters();
+
+    MESSAGE_FUNC_PTR_CHARPTR(OnTextChanged, "TextChanged", panel, text);
+    MESSAGE_FUNC_PTR_INT(OnButtonToggled, "ButtonToggled", panel, state);
+
+private:
+    void RequestServersResponse(int iServer, EMatchMakingServerResponse response, bool bLastServer); // callback for matchmaking interface
+
+    void RecalculateFilterString();
+
+    // If set, it uses the specified resfile name instead of its default one.
+    const char *m_pCustomResFilename;
+
+    // filter controls
+    vgui::ComboBox *m_pGameModeFilter;
+    vgui::TextEntry *m_pMapFilter;
+    vgui::ComboBox *m_pDifficultyFilter;
+    vgui::CheckButton *m_pHideCompletedFilterCheck;//Used for local maps only
+    vgui::ComboBox *m_pMapLayoutFilter;//0 = ALL, 1 = LINEAR ONLY, 2 = STAGED ONLY
+    vgui::Label *m_pFilterString;//MOM_TODO: determine what this is and if we need it
+    char m_szComboAllText[64];
+
+    KeyValues *m_pFilters; // base filter data
+    bool m_bFiltersVisible;	// true if filter section is currently visible
+    vgui::HFont m_hFont;
+
+    // filter data
+    int m_iGameModeFilter;
+    char m_szMapFilter[32];
+    int	m_iDifficultyFilter;//What tier the map should be under
+    bool m_bFilterHideCompleted;//Hide completed maps
+    int m_iMapLayoutFilter;//Map is non-linear (has stages)
+
+    typedef enum
+    {
+        HEADER_COMPLETED =0,
+        HEADER_MAPLAYOUT,
+        //HEADER_STAGEDMAP,
+        HEADER_MAPNAME,
+        HEADER_GAMEMODE,
+        HEADER_DIFFICULTY,
+        HEADER_BESTTIME
+    } HEADERS;
+
+};
+
+#endif // BASEGAMESPAGE_H
diff --git a/mp/src/game/client/momentum/ui/MapSelection/IMapList.h b/mp/src/game/client/momentum/ui/MapSelection/IMapList.h
new file mode 100644
index 000000000..cb5d75056
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/IMapList.h
@@ -0,0 +1,75 @@
+#ifndef IMAPLIST_H
+#define IMAPLIST_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//Used by mapdisplay_t, holds map information for filtering and displaying
+struct mapstruct_t
+{
+    char m_szMapName[MAX_PATH];//map name to use for "map m_cMapName"
+    int m_iGameMode;//GAMEMODE (Surf/Bhop/KZ/etc)
+    bool m_bHasStages;//True if the map has stages
+    bool m_bCompleted;//If the player has completed this map or not (read .tim files to set this)
+    int m_iDifficulty;//Difficulty of map (Tier 1, 2 etc)
+    char m_szBestTime[64];//Best time for the map (MOM_TODO: determine best size for this)
+};
+
+//Used by the MapSelectorDialog, encapsulates a map object for the list
+struct mapdisplay_t
+{
+    mapdisplay_t()
+    {
+        m_iListID = -1;
+        m_iServerID = -1;
+        m_bDoNotRefresh = true;
+    }
+    mapstruct_t m_mMap;         // the map struct, containing the information for the map
+    int			m_iListID;		// the VGUI2 list panel index for displaying this server
+    int			m_iServerID;	// the matchmaking interface index for this server MOM_TODO: remove this
+    bool		m_bDoNotRefresh;
+    bool operator==(const mapdisplay_t &rhs) const { return rhs.m_iServerID == m_iServerID; }
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Interface to accessing a game list
+//-----------------------------------------------------------------------------
+class IMapList
+{
+public:
+
+    enum InterfaceItem_e
+    {
+        FILTERS,
+        GETNEWLIST,//MOM_TODO: Change this to be "MAPSEARCH" ? Local uses its own update methods
+        ADDSERVER,//MOM_TODO: remove?
+        ADDCURRENTSERVER,//MOM_TODO: remove?
+    };
+
+    // returns true if the game list supports the specified ui elements
+    virtual bool SupportsItem(InterfaceItem_e item) = 0;
+
+    // starts the servers refreshing
+    virtual void StartRefresh() = 0;
+
+    // gets a new map list
+    virtual void GetNewMapList() = 0;
+
+    // stops current refresh/GetNewServerList()
+    virtual void StopRefresh() = 0;
+
+    // returns true if the list is currently refreshing servers
+    virtual bool IsRefreshing() = 0;
+
+    // gets information about specified server
+    virtual mapstruct_t *GetMap(unsigned int serverID) = 0;
+
+    // called when Connect button is pressed
+    virtual void OnMapStart() = 0;
+
+    // invalid server index
+    virtual int GetInvalidMapListID() = 0;
+};
+
+
+#endif // IMAPLIST_H
diff --git a/mp/src/game/client/momentum/ui/MapSelection/IMapSelector.h b/mp/src/game/client/momentum/ui/MapSelection/IMapSelector.h
new file mode 100644
index 000000000..ab3228c10
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/IMapSelector.h
@@ -0,0 +1,20 @@
+#ifndef IMAPSELECTOR_H
+#define IMAPSELECTOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui/IVGui.h"
+
+class IMapSelector
+{
+public:
+    virtual void Create(vgui::VPANEL) = 0;
+    virtual void Destroy() = 0;
+    virtual void Activate() = 0;
+    virtual void Deactivate() = 0;
+};
+
+extern IMapSelector* mapselector;
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.cpp b/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.cpp
new file mode 100644
index 000000000..4b6eec96a
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.cpp
@@ -0,0 +1,241 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CLocalMaps::CLocalMaps(vgui::Panel *parent) :
+CBaseMapsPage(parent, "LocalMaps")
+{
+    m_bLoadedMaps = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CLocalMaps::~CLocalMaps()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates the page, starts refresh
+//-----------------------------------------------------------------------------
+void CLocalMaps::OnPageShow()
+{
+    if (!m_bLoadedMaps)
+        GetNewMapList();
+
+    StartRefresh();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the game list supports the specified ui elements
+//-----------------------------------------------------------------------------
+bool CLocalMaps::SupportsItem(InterfaceItem_e item)
+{
+    switch (item)
+    {
+    case FILTERS:
+        return true;
+
+    case GETNEWLIST:
+    default:
+        return false;
+    }
+}
+
+
+inline bool MapHasStages(const char* szMap)
+{
+    bool found = false;
+    KeyValues *kvMap = new KeyValues("Map");
+    if (kvMap->LoadFromFile(g_pFullFileSystem, VarArgs("maps/%s.zon", szMap), "MOD"))
+    {
+        found = (kvMap->FindKey("stage") != NULL);
+    }
+    kvMap->deleteThis();
+    return found;
+}
+
+void CLocalMaps::FillMapstruct(mapstruct_t *m)
+{
+    //Game mode
+    m->m_iGameMode = MOMGM_UNKNOWN;
+    if (!Q_strnicmp(m->m_szMapName, "surf_", 5))
+    {
+        m->m_iGameMode = MOMGM_SURF;
+    }
+    else if (!Q_strnicmp(m->m_szMapName, "bhop_", 5))
+    {
+        m->m_iGameMode = MOMGM_BHOP;
+    }
+
+    // MOM_TODO: Determine difficulty
+    m->m_iDifficulty = 1;
+
+    //Map layout (liner/staged)
+    m->m_bHasStages = MapHasStages(m->m_szMapName);
+
+    //Completed/Best time
+    KeyValues *kvMap = new KeyValues("Map");
+    if (kvMap->LoadFromFile(g_pFullFileSystem, VarArgs("maps/%s.tim", m->m_szMapName), "MOD"))
+    {
+        if (!kvMap->IsEmpty())
+        {
+            m->m_bCompleted = true;
+
+            CUtlSortVector<KeyValues*, CTimeSortFunc> sortedTimes;
+            for (KeyValues *kv = kvMap->GetFirstSubKey(); kv; kv = kv->GetNextKey())
+            {
+                sortedTimes.InsertNoSort(kv);
+            }
+
+            sortedTimes.RedoSort();
+
+            KeyValues *pBestTime = sortedTimes[0];
+            if (pBestTime)
+                mom_UTIL.FormatTime(Q_atoi(pBestTime->GetName()), pBestTime->GetFloat("rate"), m->m_szBestTime);
+        }
+    }
+    kvMap->deleteThis();
+}
+
+
+void CLocalMaps::GetNewMapList()
+{
+    ClearMapList();
+    //Populate the main list
+    FileFindHandle_t found;
+    //MOM_TODO: make this by *.mom
+    const char *pMapName = g_pFullFileSystem->FindFirstEx("maps/*.bsp", "MOD", &found);
+    while (pMapName)
+    {       
+        DevLog("FOUND MAP %s!\n", pMapName);
+        
+        mapdisplay_t map = mapdisplay_t();
+        mapstruct_t m = mapstruct_t();
+        map.m_bDoNotRefresh = true;
+
+        //Map name
+        Q_FileBase(pMapName, m.m_szMapName, MAX_PATH);
+        DevLog("Stripped name: %s\n", m.m_szMapName);
+
+        FillMapstruct(&m);
+
+        map.m_mMap = m;
+        m_vecMaps.AddToTail(map);
+
+        pMapName = g_pFullFileSystem->FindNext(found);
+    }
+    g_pFullFileSystem->FindClose(found);
+
+    ApplyGameFilters();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: starts the maps refreshing
+//-----------------------------------------------------------------------------
+void CLocalMaps::StartRefresh()
+{
+    FOR_EACH_VEC(m_vecMaps, i)
+    {
+        mapdisplay_t *pMap = &m_vecMaps[0];
+        if (!pMap) continue;
+        mapstruct_t pMapInfo = pMap->m_mMap;
+        // check filters
+        bool removeItem = false;
+        if (!CheckPrimaryFilters(pMapInfo))
+        {
+            // map has been filtered at a primary level
+            // remove from lists
+            pMap->m_bDoNotRefresh = true;
+
+            // remove from UI list
+            removeItem = true;
+        }
+        else if (!CheckSecondaryFilters(pMapInfo))
+        {
+            // we still ping this server in the future; however it is removed from UI list
+            removeItem = true;
+        }
+
+        if (removeItem)
+        {
+            if (m_pGameList->IsValidItemID(pMap->m_iListID))
+            {
+                m_pGameList->RemoveItem(pMap->m_iListID);
+                pMap->m_iListID = GetInvalidMapListID();
+            }
+            return;
+        }
+
+        // update UI
+        KeyValues *kv;
+        if (m_pGameList->IsValidItemID(pMap->m_iListID))
+        {
+            // we're updating an existing entry
+            kv = m_pGameList->GetItem(pMap->m_iListID);
+        }
+        else
+        {
+            // new entry
+            kv = new KeyValues("Map");
+        }
+
+        kv->SetString("name", pMapInfo.m_szMapName);
+        kv->SetInt("MapLayout", ((int)pMapInfo.m_bHasStages) + 2);//+ 2 so the picture sets correctly
+        kv->SetBool("completed", pMapInfo.m_bCompleted);
+        kv->SetInt("difficulty", pMapInfo.m_iDifficulty);
+        kv->SetInt("gamemode", pMapInfo.m_iGameMode);
+        kv->SetString("time", pMapInfo.m_szBestTime);
+
+        if (!m_pGameList->IsValidItemID(pMap->m_iListID))
+        {
+            // new map, add to list
+            pMap->m_iListID = m_pGameList->AddItem(kv, NULL, false, false);
+            if (m_bAutoSelectFirstItemInGameList && m_pGameList->GetItemCount() == 1)
+            {
+                m_pGameList->AddSelectedItem(pMap->m_iListID);
+            }
+
+            kv->deleteThis();
+        }
+        else
+        {
+            // tell the list that we've changed the data
+            m_pGameList->ApplyItemChanges(pMap->m_iListID);
+            m_pGameList->SetItemVisible(pMap->m_iListID, true);
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Control which button are visible.
+//-----------------------------------------------------------------------------
+void CLocalMaps::ManualShowButtons(bool bShowConnect, bool bShowRefreshAll, bool bShowFilter)
+{
+    m_pStartMap->SetVisible(bShowConnect);
+    m_pRefreshAll->SetVisible(bShowRefreshAll);
+    m_pFilter->SetVisible(bShowFilter);
+}
+
+void CLocalMaps::SetEmptyListText()
+{
+    m_pGameList->SetEmptyListText("#MOM_MapSelector_NoMaps");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: opens context menu (user right clicked on a map)
+//-----------------------------------------------------------------------------
+void CLocalMaps::OnOpenContextMenu(int row)
+{
+    if (!m_pGameList->GetSelectedItemsCount())
+        return;
+
+    // Activate context menu
+    CMapContextMenu *menu = MapSelectorDialog().GetContextMenu(m_pGameList);
+    menu->ShowMenu(this, true, true);
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.h b/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.h
new file mode 100644
index 000000000..3919757cd
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/LocalMaps.h
@@ -0,0 +1,61 @@
+#ifndef LOCALMAPS_H
+#define LOCALMAPS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Local maps list
+//-----------------------------------------------------------------------------
+class CLocalMaps : public CBaseMapsPage
+{
+    DECLARE_CLASS_SIMPLE(CLocalMaps, CBaseMapsPage);
+
+public: 
+
+    CLocalMaps(vgui::Panel *parent);
+    ~CLocalMaps();
+
+    // property page handlers
+    virtual void OnPageShow();
+
+    // IGameList handlers
+    // returns true if the game list supports the specified ui elements
+    virtual bool SupportsItem(InterfaceItem_e item);
+
+    // Control which button are visible.
+    void ManualShowButtons(bool bShowConnect, bool bShowRefreshAll, bool bShowFilter);
+
+    //Filters based on the filter data
+    virtual void StartRefresh();
+    void GetNewMapList();//called upon loading
+
+    virtual void OnMapStart() { BaseClass::OnMapStart(); }
+
+    // Tell the game list what to put in there when there are no games found.
+    virtual void SetEmptyListText();
+
+    //virtual void LoadFilterSettings() {};//MOM_TODO: Make this sort by name/gametype/difficulty?
+
+private:
+    // context menu message handlers
+    MESSAGE_FUNC_INT(OnOpenContextMenu, "OpenContextMenu", itemID);
+
+    // true if we're broadcasting for servers
+    bool m_bLoadedMaps;
+
+    //Fills a mapstruct with data read from local files
+    void FillMapstruct(mapstruct_t *);
+};
+
+class CTimeSortFunc
+{
+public:
+    bool Less(KeyValues* lhs, KeyValues* rhs, void *)
+    {
+        return (((float) Q_atoi(lhs->GetName())) * lhs->GetFloat("rate") <
+            (float) Q_atoi(rhs->GetName()) * rhs->GetFloat("rate"));
+    }
+};
+
+#endif // LOCALMAPS_H
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.cpp b/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.cpp
new file mode 100644
index 000000000..50c67ccd0
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.cpp
@@ -0,0 +1,47 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CMapContextMenu::CMapContextMenu(Panel *parent) : Menu(parent, "MapContextMenu")
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CMapContextMenu::~CMapContextMenu()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates the menu
+//-----------------------------------------------------------------------------
+void CMapContextMenu::ShowMenu(
+    Panel *target,
+    bool showStart,
+    bool showViewGameInfo)
+{
+    if (showStart)
+    {
+        AddMenuItem("StartMap", "#MOM_MapSelector_StartMap", new KeyValues("StartMap"), target);
+    }
+
+    if (showViewGameInfo)
+    {
+        AddMenuItem("ViewMapInfo", "#MOM_MapSelector_ShowMapInfo", new KeyValues("ViewMapInfo"), target);
+    }
+
+    //if (showRefresh)
+    //{
+    //    AddMenuItem("RefreshServer", "#ServerBrowser_RefreshServer", new KeyValues("RefreshServer", "serverID", serverID), target);
+    //}
+
+    int x, y, gx, gy;
+    input()->GetCursorPos(x, y);
+    ipanel()->GetPos(surface()->GetEmbeddedPanel(), gx, gy);
+    SetPos(x - gx, y - gy);
+    SetVisible(true);
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.h b/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.h
new file mode 100644
index 000000000..117448c50
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.h
@@ -0,0 +1,24 @@
+#ifndef MAPCONTEXTMENU_H
+#define MAPCONTEXTMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Basic right-click context menu for servers
+//-----------------------------------------------------------------------------
+class CMapContextMenu : public vgui::Menu
+{
+public:
+    CMapContextMenu(vgui::Panel *parent);
+    ~CMapContextMenu();
+
+    // call this to Activate the menu
+    void ShowMenu(
+        vgui::Panel *target,
+        bool showMapStart,
+        bool showViewGameInfo);
+};
+
+
+#endif // MAPCONTEXTMENU_H
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.cpp b/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.cpp
new file mode 100644
index 000000000..e6c9cdcba
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.cpp
@@ -0,0 +1,804 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+//extern class IAppInformation *g_pAppInformation; // may be NULL
+
+static const long RETRY_TIME = 10000;		// refresh server every 10 seconds
+static const long CHALLENGE_ENTRIES = 1024;
+
+extern "C"
+{
+    DLL_EXPORT bool JoiningSecureServerCall()
+    {
+        return true;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Comparison function used in query redblack tree
+//-----------------------------------------------------------------------------
+/*bool QueryLessFunc(const struct challenge_s &item1, const struct challenge_s &item2)
+{
+    return false;
+    // compare port then ip
+    if (item1.addr.GetPort() < item2.addr.GetPort())
+        return true;
+    else if (item1.addr.GetPort() > item2.addr.GetPort())
+        return false;
+
+    //int ip1 = item1.addr.GetIP();
+    //int ip2 = item2.addr.GetIP();
+    //  return ip1 < ip2;
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CDialogMapInfo::CDialogMapInfo(vgui::Panel *parent, const char *mapname) :
+Frame(parent, "DialogMapInfo")
+#ifndef NO_STEAM
+, m_CallbackPersonaStateChange(this, &CDialogMapInfo::OnPersonaStateChange)
+#endif
+{
+    SetBounds(0, 0, 512, 512);
+    SetMinimumSize(416, 340);
+    SetDeleteSelfOnClose(true);
+    m_bConnecting = false;
+    m_bServerFull = false;
+    m_bShowAutoRetryToggle = false;
+    m_bServerNotResponding = false;
+    m_bShowingExtendedOptions = false;
+    m_SteamIDFriend = 0;
+    m_hPingQuery = HSERVERQUERY_INVALID;
+    m_hPlayersQuery = HSERVERQUERY_INVALID;
+    m_bPlayerListUpdatePending = false;
+
+    m_szPassword[0] = 0;
+
+    m_pConnectButton = new Button(this, "Connect", "#ServerBrowser_JoinGame");
+    m_pCloseButton = new Button(this, "Close", "#ServerBrowser_Close");
+    m_pRefreshButton = new Button(this, "Refresh", "#ServerBrowser_Refresh");
+    m_pInfoLabel = new Label(this, "InfoLabel", "");
+    m_pAutoRetry = new ToggleButton(this, "AutoRetry", "#ServerBrowser_AutoRetry");
+    m_pAutoRetry->AddActionSignalTarget(this);
+
+    m_pAutoRetryAlert = new RadioButton(this, "AutoRetryAlert", "#ServerBrowser_AlertMeWhenSlotOpens");
+    m_pAutoRetryJoin = new RadioButton(this, "AutoRetryJoin", "#ServerBrowser_JoinWhenSlotOpens");
+    m_pPlayerList = new ListPanel(this, "PlayerList");
+    m_pPlayerList->AddColumnHeader(0, "PlayerName", "#ServerBrowser_PlayerName", 156);
+    m_pPlayerList->AddColumnHeader(1, "Score", "#ServerBrowser_Score", 64);
+    m_pPlayerList->AddColumnHeader(2, "Time", "#ServerBrowser_Time", 64);
+
+    m_pPlayerList->SetSortFunc(2, &PlayerTimeColumnSortFunc);
+
+    // set the defaults for sorting
+    // hack, need to make this more explicit functions in ListPanel
+    PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 2));
+    PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 1));
+    PostMessage(m_pPlayerList, new KeyValues("SetSortColumn", "column", 1));
+
+    m_pAutoRetryAlert->SetSelected(true);
+
+    m_pConnectButton->SetCommand(new KeyValues("Connect"));
+    m_pCloseButton->SetCommand(new KeyValues("Close"));
+    m_pRefreshButton->SetCommand(new KeyValues("Refresh"));
+
+    m_iRequestRetry = 0;
+
+    // create a new server to watch
+    //memset(&m_Server, 0, sizeof(m_Server));
+    //m_Server.m_NetAdr.Init(serverIP, queryPort, connectionPort);
+
+    // refresh immediately
+    RequestInfo();
+
+    // let us be ticked every frame
+    ivgui()->AddTickSignal(this->GetVPanel());
+
+    LoadControlSettings("resource/ui/DialogMapInfo.res");
+    //LoadControlSettings("Servers/DialogGameInfo.res");
+    //RegisterControlSettingsFile("Servers/DialogGameInfo_SinglePlayer.res");
+    //RegisterControlSettingsFile("Servers/DialogGameInfo_AutoRetry.res");
+    MoveToCenterOfScreen();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CDialogMapInfo::~CDialogMapInfo()
+{
+    //MOM_TODO: Cancel any queries sent out
+/*#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+        return;
+
+    if (m_hPingQuery != HSERVERQUERY_INVALID)
+        SteamMatchmakingServers()->CancelServerQuery(m_hPingQuery);
+    if (m_hPlayersQuery != HSERVERQUERY_INVALID)
+        SteamMatchmakingServers()->CancelServerQuery(m_hPlayersQuery);
+#endif*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: send a player query to a server
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::SendPlayerQuery(uint32 unIP, uint16 usQueryPort)
+{
+    //MOM_TODO: 
+    /*
+#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+        return;
+
+    if (m_hPlayersQuery != HSERVERQUERY_INVALID)
+        SteamMatchmakingServers()->CancelServerQuery(m_hPlayersQuery);
+    m_hPlayersQuery = SteamMatchmakingServers()->PlayerDetails(unIP, usQueryPort, this);
+    m_bPlayerListUpdatePending = true;
+#endif*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates the dialog
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::Run(const char *titleName)
+{
+    if (titleName)
+    {
+        SetTitle("#ServerBrowser_GameInfoWithNameTitle", true);
+    }
+    else
+    {
+        SetTitle("#ServerBrowser_GameInfoWithNameTitle", true);
+    }
+    SetDialogVariable("game", titleName);
+
+    // get the info from the user
+    //RequestInfo();
+    //MOM_TODO: LoadLocalInfo(); //Loads the local information (local PBs, local replays)
+    Activate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Changes which server to watch
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ChangeGame(int serverIP, int queryPort, unsigned short connectionPort)
+{
+    memset(&m_Server, 0x0, sizeof(m_Server));
+
+    m_Server.m_NetAdr.Init(serverIP, queryPort, connectionPort);
+
+    // remember the dialogs position so we can keep it the same
+    int x, y;
+    GetPos(x, y);
+
+    // see if we need to change dialog state
+    if (!m_Server.m_NetAdr.GetIP() || !m_Server.m_NetAdr.GetQueryPort())
+    {
+        // not in a server, load the simple settings dialog
+        SetMinimumSize(0, 0);
+        SetSizeable(false);
+        LoadControlSettings("Servers/DialogGameInfo_SinglePlayer.res");
+    }
+    else
+    {
+        // moving from a single-player game -> multiplayer, reset dialog
+        SetMinimumSize(416, 340);
+        SetSizeable(true);
+        LoadControlSettings("Servers/DialogGameInfo.res");
+    }
+    SetPos(x, y);
+
+    // Start refresh immediately
+    m_iRequestRetry = 0;
+    RequestInfo();
+    InvalidateLayout();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: updates the dialog if it's watching a friend who changes servers
+//-----------------------------------------------------------------------------
+#ifndef NO_STEAM
+void CDialogMapInfo::OnPersonaStateChange(PersonaStateChange_t *pPersonaStateChange)
+{
+#if 0 // TBD delete this func
+    if (m_SteamIDFriend && m_SteamIDFriend == pPersonaStateChange->m_ulSteamID)
+    {
+        // friend may have changed servers
+        uint64 nGameID;
+        uint32 unGameIP;
+        uint16 usGamePort;
+        uint16 usQueryPort;
+
+        if (SteamFriends()->GetFriendGamePlayed(m_SteamIDFriend, &nGameID, &unGameIP, &usGamePort, &usQueryPort))
+        {
+            if (pPersonaStateChange->m_nGameIDPrevious != nGameID
+                || pPersonaStateChange->m_unGameServerIPPrevious != unGameIP
+                || pPersonaStateChange->m_usGameServerPortPrevious != usGamePort
+                || pPersonaStateChange->m_usGameServerQueryPortPrevious != usQueryPort)
+            {
+                ChangeGame(unGameIP, usQueryPort, usGamePort);
+            }
+        }
+    }
+#endif
+}
+#endif // NO_STEAM
+
+//-----------------------------------------------------------------------------
+// Purpose: Associates a user with this dialog
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::SetFriend(uint64 ulSteamIDFriend)
+{
+    //MOM_TODO: What is this void?
+/*#ifndef NO_STEAM
+    // set the title to include the friends name
+    SetTitle("#ServerBrowser_GameInfoWithNameTitle", true);
+
+    SetDialogVariable("game", SteamFriends()->GetFriendPersonaName(ulSteamIDFriend));
+    SetDialogVariable("friend", SteamFriends()->GetFriendPersonaName(ulSteamIDFriend));
+
+    // store the friend we're associated with
+    m_SteamIDFriend = ulSteamIDFriend;
+
+    uint64 nGameID;
+    uint32 unGameIP;
+    uint16 usGamePort;
+    uint16 usQueryPort;
+    if (SteamFriends()->GetFriendGamePlayed(ulSteamIDFriend, &nGameID, &unGameIP, &usGamePort, &usQueryPort))
+    {
+        uint16 usConnPort = usGamePort;
+        if (usQueryPort < QUERY_PORT_ERROR)
+            usConnPort = usGamePort;
+        ChangeGame(unGameIP, usConnPort, usGamePort);
+    }
+#endif*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: data access
+//-----------------------------------------------------------------------------
+uint64 CDialogMapInfo::GetAssociatedFriend()
+{
+    return m_SteamIDFriend;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: lays out the data
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::PerformLayout()
+{
+    BaseClass::PerformLayout();
+
+    SetControlString("ServerText", m_Server.GetName());
+    SetControlString("GameText", m_Server.m_szGameDescription);
+    SetControlString("MapText", m_Server.m_szMap);
+
+    /*if (!Q_strlen(m_Server.m_szGameDescription) && m_SteamIDFriend && g_pAppInformation)
+    {
+        // no game description set yet
+        // get the game from the friends info if we can
+        uint64 nGameID = 0;
+#ifndef NO_STEAM
+        //SteamFriends()->GetFriendGamePlayed(m_SteamIDFriend, &nGameID, NULL, NULL, NULL);
+#endif
+        if (nGameID)
+        {
+            //SetControlString("GameText", g_pAppInformation->GetAppName(g_pAppInformation->GetIAppForAppID(nGameID)));
+        }
+        else
+        {
+            SetControlString("GameText", "#ServerBrowser_NotInGame");
+        }
+    }*/
+
+    if (!m_Server.m_bHadSuccessfulResponse)
+    {
+        SetControlString("SecureText", "");
+    }
+    else if (m_Server.m_bSecure)
+    {
+        SetControlString("SecureText", "#ServerBrowser_Secure");
+    }
+    else
+    {
+        SetControlString("SecureText", "#ServerBrowser_NotSecure");
+    }
+
+    char buf[128];
+    if (m_Server.m_nMaxPlayers > 0)
+    {
+        Q_snprintf(buf, sizeof(buf), "%d / %d", m_Server.m_nPlayers, m_Server.m_nMaxPlayers);
+    }
+    else
+    {
+        buf[0] = 0;
+    }
+    SetControlString("PlayersText", buf);
+
+    if (m_Server.m_NetAdr.GetIP() && m_Server.m_NetAdr.GetQueryPort())
+    {
+        SetControlString("ServerIPText", m_Server.m_NetAdr.GetConnectionAddressString());
+        m_pConnectButton->SetEnabled(true);
+        if (m_pAutoRetry->IsSelected())
+        {
+            m_pAutoRetryAlert->SetVisible(true);
+            m_pAutoRetryJoin->SetVisible(true);
+        }
+        else
+        {
+            m_pAutoRetryAlert->SetVisible(false);
+            m_pAutoRetryJoin->SetVisible(false);
+        }
+    }
+    else
+    {
+        SetControlString("ServerIPText", "");
+        m_pConnectButton->SetEnabled(false);
+    }
+
+    if (m_Server.m_bHadSuccessfulResponse)
+    {
+        Q_snprintf(buf, sizeof(buf), "%d", m_Server.m_nPing);
+        SetControlString("PingText", buf);
+    }
+    else
+    {
+        SetControlString("PingText", "");
+    }
+
+    // set the info text
+    if (m_pAutoRetry->IsSelected())
+    {
+        if (m_Server.m_nPlayers < m_Server.m_nMaxPlayers)
+        {
+            m_pInfoLabel->SetText("#ServerBrowser_PressJoinToConnect");
+        }
+        else if (m_pAutoRetryJoin->IsSelected())
+        {
+            m_pInfoLabel->SetText("#ServerBrowser_JoinWhenSlotIsFree");
+        }
+        else
+        {
+            m_pInfoLabel->SetText("#ServerBrowser_AlertWhenSlotIsFree");
+        }
+    }
+    else if (m_bServerFull)
+    {
+        m_pInfoLabel->SetText("#ServerBrowser_CouldNotConnectServerFull");
+    }
+    else if (m_bServerNotResponding)
+    {
+        m_pInfoLabel->SetText("#ServerBrowser_ServerNotResponding");
+    }
+    else
+    {
+        // clear the status
+        m_pInfoLabel->SetText("");
+    }
+
+    if (m_Server.m_bHadSuccessfulResponse && !(m_Server.m_nPlayers + m_Server.m_nBotPlayers))
+    {
+        m_pPlayerList->SetEmptyListText("#ServerBrowser_ServerHasNoPlayers");
+    }
+    else
+    {
+        m_pPlayerList->SetEmptyListText("#ServerBrowser_ServerNotResponding");
+    }
+
+    // auto-retry layout
+    m_pAutoRetry->SetVisible(m_bShowAutoRetryToggle);
+
+    Repaint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Forces the game info dialog to try and connect
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::Connect()
+{
+    OnConnect();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Connects the user to this game
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnConnect()
+{
+    // flag that we are attempting connection
+    m_bConnecting = true;
+
+    // reset state
+    m_bServerFull = false;
+    m_bServerNotResponding = false;
+
+    InvalidateLayout();
+
+    // need to refresh server before attempting to connect, to make sure there is enough room on the server
+    m_iRequestRetry = 0;
+    RequestInfo();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cancel auto-retry if we connect to the game by other means
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnConnectToGame(int ip, int port)
+{
+    // if we just connected to the server we were looking at, close the dialog
+    // important so that we don't auto-retry a server that we are already on
+    if (m_Server.m_NetAdr.GetIP() == (uint32) ip && m_Server.m_NetAdr.GetConnectionPort() == (uint16) port)
+    {
+        // close this dialog
+        Close();
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles Refresh button press, starts a re-ping of the server
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnRefresh()
+{
+    m_iRequestRetry = 0;
+    // re-ask the server for the game info
+    RequestInfo();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Forces the whole dialog to redraw when the auto-retry button is toggled
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnButtonToggled(Panel *panel)
+{
+    if (panel == m_pAutoRetry)
+    {
+        ShowAutoRetryOptions(m_pAutoRetry->IsSelected());
+    }
+
+    InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets whether the extended auto-retry options are visible or not
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ShowAutoRetryOptions(bool state)
+{
+    // we need to extend the dialog
+    int growSize = 60;
+    if (!state)
+    {
+        growSize = -growSize;
+    }
+
+    // alter the dialog size accordingly
+    int x, y, wide, tall;
+    GetBounds(x, y, wide, tall);
+
+    // load a new layout file depending on the state
+    SetMinimumSize(416, 340);
+    if (state)
+        LoadControlSettings("Servers/DialogGameInfo_AutoRetry.res");
+    else
+        LoadControlSettings("Servers/DialogGameInfo.res");
+
+    // restore size and position as 
+    // load control settings will override them
+    SetBounds(x, y, wide, tall + growSize);
+
+    // restore other properties of the dialog
+    PerformLayout();
+
+    m_pAutoRetryAlert->SetSelected(true);
+
+    InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Requests the right info from the server
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::RequestInfo()
+{
+    //MOM_TODO: Request info from our website/API
+/*#ifndef NO_STEAM
+    if (!SteamMatchmakingServers())
+        return;
+
+    if (m_iRequestRetry == 0)
+    {
+        // reset the time at which we auto-refresh
+        m_iRequestRetry = system()->GetTimeMillis() + RETRY_TIME;
+        if (m_hPingQuery != HSERVERQUERY_INVALID)
+            SteamMatchmakingServers()->CancelServerQuery(m_hPingQuery);
+        m_hPingQuery = SteamMatchmakingServers()->PingServer(m_Server.m_NetAdr.GetIP(), m_Server.m_NetAdr.GetQueryPort(), this);
+    }
+#endif*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called every frame, handles resending network messages
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnTick()
+{
+    // check to see if we should perform an auto-refresh
+    if (m_iRequestRetry && m_iRequestRetry < system()->GetTimeMillis())
+    {
+        m_iRequestRetry = 0;
+        RequestInfo();
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the server has successfully responded
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ServerResponded(gameserveritem_t &server)
+{
+    m_hPingQuery = HSERVERQUERY_INVALID;
+    m_Server = server;
+
+    if (m_bConnecting)
+    {
+        ConnectToServer();
+    }
+    else if (m_pAutoRetry->IsSelected() && server.m_nPlayers < server.m_nMaxPlayers)
+    {
+        // there is a slot free, we can join
+
+        // make the sound
+        surface()->PlaySound("Servers/game_ready.wav");
+
+        // flash this window
+        FlashWindow();
+
+        // if it's set, connect right away
+        if (m_pAutoRetryJoin->IsSelected())
+        {
+            ConnectToServer();
+        }
+    }
+    else
+    {
+        SendPlayerQuery(server.m_NetAdr.GetIP(), server.m_NetAdr.GetQueryPort());
+    }
+
+    m_bServerNotResponding = false;
+
+    InvalidateLayout();
+    Repaint();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a server response has timed out
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ServerFailedToRespond()
+{
+    // the server didn't respond, mark that in the UI
+    // only mark if we haven't ever received a response
+    if (!m_Server.m_bHadSuccessfulResponse)
+    {
+        m_bServerNotResponding = true;
+    }
+
+    InvalidateLayout();
+    Repaint();
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructs a command to send a running game to connect to a server,
+// based on the server type
+//
+// TODO it would be nice to push this logic into the IRunGameEngine interface; that
+// way we could ask the engine itself to construct arguments in ways that fit.
+// Might be worth the effort as we start to add more engines.
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ApplyConnectCommand(const gameserveritem_t &server)
+{
+    char command[256];
+    // set the server password, if any
+    if (m_szPassword[0])
+    {
+        Q_snprintf(command, Q_ARRAYSIZE(command), "password \"%s\"\n", m_szPassword);
+        //engine->ExecuteClientCmd(command);
+        //g_pRunGameEngine->AddTextCommand(command);
+    }
+
+    // send engine command to change servers
+    Q_snprintf(command, Q_ARRAYSIZE(command), "connect %s\n", server.m_NetAdr.GetConnectionAddressString());
+    //engine->ExecuteClientCmd(command);
+    //g_pRunGameEngine->AddTextCommand(command);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructs game options to use when running a game to connect to a server
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ConstructConnectArgs(char *pchOptions, int cchOptions, const gameserveritem_t &server)
+{
+    Q_snprintf(pchOptions, cchOptions, " +connect %s", server.m_NetAdr.GetConnectionAddressString());
+    if (m_szPassword[0])
+    {
+        Q_strcat(pchOptions, " +password \"", cchOptions);
+        Q_strcat(pchOptions, m_szPassword, cchOptions);
+        Q_strcat(pchOptions, "\"", cchOptions);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Connects to the server
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ConnectToServer()
+{
+    m_bConnecting = false;
+
+    // check VAC status
+    /*if (m_Server.m_bSecure && ServerBrowser().IsVACBannedFromGame(m_Server.m_nAppID))
+    {
+        // refuse the user
+        CVACBannedConnRefusedDialog *pDlg = new CVACBannedConnRefusedDialog(GetVParent(), "VACBannedConnRefusedDialog");
+        pDlg->Activate();
+        Close();
+        return;
+    }*/
+
+
+    // check to see if we need a password
+    /*if (m_Server.m_bPassword && !m_szPassword[0])
+    {
+        CDialogServerPassword *box = new CDialogServerPassword(this);
+        box->AddActionSignalTarget(this);
+        box->Activate(m_Server.GetName(), 0);
+        return;
+    }*/
+
+    // check the player count
+    if (m_Server.m_nPlayers >= m_Server.m_nMaxPlayers)
+    {
+        // mark why we cannot connect
+        m_bServerFull = true;
+        // give them access to auto-retry options
+        m_bShowAutoRetryToggle = true;
+        InvalidateLayout();
+        return;
+    }
+
+    // tell the engine to connect
+    //const char *gameDir = m_Server.m_szGameDir;
+    //if (/*engine->IsActiveApp()*/)
+    {
+        ApplyConnectCommand(m_Server);
+    }
+    //else
+    {
+        //Log("ENGINE IS NOT RUNNING!\n");
+        /*char connectArgs[256];
+        ConstructConnectArgs(connectArgs, Q_ARRAYSIZE(connectArgs), m_Server);
+
+        if ((m_Server.m_bSecure && JoiningSecureServerCall()) || !m_Server.m_bSecure)
+        {
+            switch (g_pRunGameEngine->RunEngine(m_Server.m_nAppID, gameDir, connectArgs))
+            {
+            case IRunGameEngine::k_ERunResultModNotInstalled:
+            {
+                MessageBox *dlg = new MessageBox("#ServerBrowser_GameInfoTitle", "#ServerBrowser_ModNotInstalled");
+                dlg->DoModal();
+                SetVisible(false);
+                return;
+            }
+            break;
+            case IRunGameEngine::k_ERunResultAppNotFound:
+            {
+                MessageBox *dlg = new MessageBox("#ServerBrowser_GameInfoTitle", "#ServerBrowser_AppNotFound");
+                dlg->DoModal();
+                SetVisible(false);
+                return;
+            }
+            break;
+            case IRunGameEngine::k_ERunResultNotInitialized:
+            {
+                MessageBox *dlg = new MessageBox("#ServerBrowser_GameInfoTitle", "#ServerBrowser_NotInitialized");
+                dlg->DoModal();
+                SetVisible(false);
+                return;
+            }
+            break;
+            case IRunGameEngine::k_ERunResultOkay:
+            default:
+                break;
+            };
+        }*/
+    }
+
+    // close this dialog
+    PostMessage(this, new KeyValues("Close"));
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the current refresh list is complete
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::RefreshComplete(EMatchMakingServerResponse response)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: handles response from the get password dialog
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::OnJoinServerWithPassword(const char *password)
+{
+    // copy out the password
+    Q_strncpy(m_szPassword, password, sizeof(m_szPassword));
+
+    // retry connecting to the server again
+    OnConnect();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: player list received
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::ClearPlayerList()
+{
+    m_pPlayerList->DeleteAllItems();
+    Repaint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: on individual player added
+//-----------------------------------------------------------------------------
+void CDialogMapInfo::AddPlayerToList(const char *playerName, int score, float timePlayedSeconds)
+{
+    if (m_bPlayerListUpdatePending)
+    {
+        m_bPlayerListUpdatePending = false;
+        m_pPlayerList->RemoveAll();
+    }
+
+    KeyValues *player = new KeyValues("player");
+    player->SetString("PlayerName", playerName);
+    player->SetInt("Score", score);
+    player->SetInt("TimeSec", (int) timePlayedSeconds);
+
+    // construct a time string
+    int seconds = (int) timePlayedSeconds;
+    int minutes = seconds / 60;
+    int hours = minutes / 60;
+    seconds %= 60;
+    minutes %= 60;
+    char buf[64];
+    buf[0] = 0;
+    if (hours)
+    {
+        Q_snprintf(buf, sizeof(buf), "%dh %dm %ds", hours, minutes, seconds);
+    }
+    else if (minutes)
+    {
+        Q_snprintf(buf, sizeof(buf), "%dm %ds", minutes, seconds);
+    }
+    else
+    {
+        Q_snprintf(buf, sizeof(buf), "%ds", seconds);
+    }
+    player->SetString("Time", buf);
+
+    m_pPlayerList->AddItem(player, 0, false, true);
+    player->deleteThis();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sorting function for time column
+//-----------------------------------------------------------------------------
+int CDialogMapInfo::PlayerTimeColumnSortFunc(ListPanel *pPanel, const ListPanelItem &p1, const ListPanelItem &p2)
+{
+    int p1time = p1.kv->GetInt("TimeSec");
+    int p2time = p2.kv->GetInt("TimeSec");
+
+    if (p1time > p2time)
+        return -1;
+    if (p1time < p2time)
+        return 1;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.h b/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.h
new file mode 100644
index 000000000..b0691cf19
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.h
@@ -0,0 +1,119 @@
+#ifndef DIALOGGAMEINFO_H
+#define DIALOGGAMEINFO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+/*struct challenge_s
+{
+    netadr_t addr;
+    int challenge;
+};*/
+
+//-----------------------------------------------------------------------------
+// Purpose: Dialog for displaying information about a game server
+//-----------------------------------------------------------------------------
+class CDialogMapInfo : public vgui::Frame//, public ISteamMatchmakingPlayersResponse, public ISteamMatchmakingPingResponse
+{
+    DECLARE_CLASS_SIMPLE(CDialogMapInfo, vgui::Frame);
+
+public:
+    CDialogMapInfo(vgui::Panel *parent, const char*);
+    ~CDialogMapInfo();
+
+    void Run(const char *titleName);
+    void ChangeGame(int serverIP, int queryPort, unsigned short connectionPort);
+    void SetFriend(uint64 ulSteamIDFriend);
+    uint64 GetAssociatedFriend();
+
+    // forces the dialog to attempt to connect to the server
+    void Connect();
+
+    // implementation of IServerRefreshResponse interface
+    // called when the server has successfully responded
+    virtual void ServerResponded(gameserveritem_t &server);
+
+    // called when a server response has timed out
+    virtual void ServerFailedToRespond();
+
+    // on individual player added
+    virtual void AddPlayerToList(const char *playerName, int score, float timePlayedSeconds);
+    virtual void PlayersFailedToRespond() {}
+    virtual void PlayersRefreshComplete() { m_hPlayersQuery = HSERVERQUERY_INVALID; }
+
+    // called when the current refresh list is complete
+    virtual void RefreshComplete(EMatchMakingServerResponse response);
+
+    // player list received
+    virtual void ClearPlayerList();
+
+    //virtual void SendChallengeQuery( const netadr_t & to );
+    virtual void SendPlayerQuery(uint32 unIP, uint16 usQueryPort);
+    //virtual void InsertChallengeResponse( const netadr_t & to, int nChallenge );
+
+protected:
+    // message handlers
+    MESSAGE_FUNC(OnConnect, "Connect");
+    MESSAGE_FUNC(OnRefresh, "Refresh");
+    MESSAGE_FUNC_PTR(OnButtonToggled, "ButtonToggled", panel);
+    MESSAGE_FUNC_PTR(OnRadioButtonChecked, "RadioButtonChecked", panel)
+    {
+        OnButtonToggled(panel);
+    }
+
+    // response from the get password dialog
+    MESSAGE_FUNC_CHARPTR(OnJoinServerWithPassword, "JoinServerWithPassword", password);
+
+    MESSAGE_FUNC_INT_INT(OnConnectToGame, "ConnectedToGame", ip, port);
+
+    // vgui overrides
+    virtual void OnTick();
+    virtual void PerformLayout();
+
+private:
+#ifndef NO_STEAM
+    STEAM_CALLBACK(CDialogMapInfo, OnPersonaStateChange, PersonaStateChange_t, m_CallbackPersonaStateChange);
+#endif
+
+    long m_iRequestRetry;	// time at which to retry the request
+    static int PlayerTimeColumnSortFunc(vgui::ListPanel *pPanel, const vgui::ListPanelItem &p1, const vgui::ListPanelItem &p2);
+
+    // methods
+    void RequestInfo();
+    void ConnectToServer();
+    void ShowAutoRetryOptions(bool state);
+    void ConstructConnectArgs(char *pchOptions, int cchOptions, const gameserveritem_t &server);
+    void ApplyConnectCommand(const gameserveritem_t &server);
+
+    vgui::Button *m_pConnectButton;
+    vgui::Button *m_pCloseButton;
+    vgui::Button *m_pRefreshButton;
+    vgui::Label *m_pInfoLabel;
+    vgui::ToggleButton *m_pAutoRetry;
+    vgui::RadioButton *m_pAutoRetryAlert;
+    vgui::RadioButton *m_pAutoRetryJoin;
+    vgui::ListPanel *m_pPlayerList;
+
+    enum { PING_TIMES_MAX = 4 };
+
+    // true if we should try connect to the server when it refreshes
+    bool m_bConnecting;
+
+    // password, if entered
+    char m_szPassword[64];
+
+    // state
+    bool m_bServerNotResponding;
+    bool m_bServerFull;
+    bool m_bShowAutoRetryToggle;
+    bool m_bShowingExtendedOptions;
+    uint64 m_SteamIDFriend;
+
+    gameserveritem_t m_Server;
+    HServerQuery m_hPingQuery;
+    HServerQuery m_hPlayersQuery;
+    bool m_bPlayerListUpdatePending;
+};
+
+#endif // DIALOGGAMEINFO_H
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapSelector.cpp b/mp/src/game/client/momentum/ui/MapSelection/MapSelector.cpp
new file mode 100644
index 000000000..5b91b615e
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapSelector.cpp
@@ -0,0 +1,224 @@
+#include "pch_mapselection.h"
+
+
+static CMapSelector g_MapSelectorPanel;
+IMapSelector* mapselector = (CMapSelector*)&g_MapSelectorPanel;
+
+//
+CMapSelector::CMapSelector()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CMapSelector::~CMapSelector()
+{
+}
+
+static ConVar cl_showmapselection("cl_showmapselection", "0", FCVAR_CLIENTDLL | FCVAR_HIDDEN, "Sets the state of mapselection panel <state>");
+
+CON_COMMAND_F(ToggleMapSelectionPanel, "Toggles MapSelectorPanel", FCVAR_CLIENTDLL | FCVAR_HIDDEN)
+{
+    if (!cl_showmapselection.GetBool())
+    {
+        mapselector->Activate();
+        cl_showmapselection.SetValue(1);
+    }
+    else
+    {
+        cl_showmapselection.SetValue(0);
+        mapselector->Deactivate();
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapSelector::Create(vgui::VPANEL parent)
+{
+    if (!m_hMapsDlg.Get())
+    {
+        m_hMapsDlg = new CMapSelectorDialog(parent); // SetParent() call below fills this in
+        m_hMapsDlg->Initialize();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapSelector::Activate()
+{
+    static bool m_bfirstTimeOpening = true;
+    if (m_bfirstTimeOpening)
+    {
+        m_hMapsDlg->LoadUserData(); // reload the user data the first time the dialog is made visible, 
+        //helps with the lag between module load and steamui getting Deactivate() call
+        m_bfirstTimeOpening = false;
+    }
+
+    Open();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the server browser gets closed by the enduser
+//-----------------------------------------------------------------------------
+void CMapSelector::Deactivate()
+{
+    if (m_hMapsDlg.Get())
+    {
+        m_hMapsDlg->SaveUserData();
+        m_hMapsDlg->Close();
+        CloseAllMapInfoDialogs();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the server browser is no longer being used in the game
+//-----------------------------------------------------------------------------
+/*void CMapSelector::Reactivate()
+{
+    if (m_hInternetDlg.Get())
+    {
+        m_hInternetDlg->LoadUserData();
+        if (m_hInternetDlg->IsVisible())
+        {
+            m_hInternetDlg->RefreshCurrentPage();
+        }
+    }
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapSelector::Open()
+{
+    m_hMapsDlg->Open();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns direct handle to main server browser dialog
+//-----------------------------------------------------------------------------
+/*vgui::VPANEL CMapSelector::GetPanel()
+{
+    return m_hInternetDlg.Get() ? m_hInternetDlg->GetVPanel() : NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: sets the parent panel of the main module panel
+//-----------------------------------------------------------------------------
+void CMapSelector::SetParent(vgui::VPANEL parent)
+{
+    if (m_hInternetDlg.Get())
+    {
+        m_hInternetDlg->SetParent(parent);
+    }
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Closes down the server browser for good
+//-----------------------------------------------------------------------------
+void CMapSelector::Destroy()
+{
+    if (m_hMapsDlg.Get())
+    {
+        m_hMapsDlg->Close();
+        m_hMapsDlg->MarkForDeletion();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: opens a game info dialog to watch the specified server; associated with the friend 'userName'
+//-----------------------------------------------------------------------------
+/*bool CMapSelector::OpenGameInfoDialog(uint64 ulSteamIDFriend)
+{
+#if !defined( _X360 ) // X360TBD: SteamFriends()
+    if (m_hInternetDlg.Get())
+    {
+        // activate an already-existing dialog
+        CDialogGameInfo *pDialogGameInfo = m_hInternetDlg->GetDialogGameInfoForFriend(ulSteamIDFriend);
+        if (pDialogGameInfo)
+        {
+            pDialogGameInfo->Activate();
+            return true;
+        }
+
+        // none yet, create a new dialog
+        uint64 nGameID;
+        uint32 unGameIP;
+        uint16 usGamePort;
+        uint16 usQueryPort;
+#ifndef NO_STEAM
+        if (SteamFriends()->GetFriendGamePlayed(ulSteamIDFriend, &nGameID, &unGameIP, &usGamePort, &usQueryPort))
+        {
+            uint16 usConnPort = usGamePort;
+            if (usQueryPort < QUERY_PORT_ERROR)
+                usConnPort = usGamePort;
+            CDialogGameInfo *pDialogGameInfo = m_hInternetDlg->OpenGameInfoDialog(unGameIP, usGamePort, usConnPort);
+            pDialogGameInfo->SetFriend(ulSteamIDFriend);
+            return true;
+        }
+#endif
+    }
+#endif
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: joins a specified game - game info dialog will only be opened if the server is fully or passworded
+//-----------------------------------------------------------------------------
+bool CMapSelector::JoinGame(uint64 ulSteamIDFriend)
+{
+    if (OpenGameInfoDialog(ulSteamIDFriend))
+    {
+        CDialogGameInfo *pDialogGameInfo = m_hInternetDlg->GetDialogGameInfoForFriend(ulSteamIDFriend);
+        pDialogGameInfo->Connect();
+    }
+
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: joins a game by IP/Port
+//-----------------------------------------------------------------------------
+bool CMapSelector::JoinGame(uint32 unGameIP, uint16 usGamePort)
+{
+    m_hInternetDlg->JoinGame(unGameIP, usGamePort);
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: forces the game info dialog closed
+//-----------------------------------------------------------------------------
+void CMapSelector::CloseGameInfoDialog(uint64 ulSteamIDFriend)
+{
+    CDialogGameInfo *pDialogGameInfo = m_hInternetDlg->GetDialogGameInfoForFriend(ulSteamIDFriend);
+    if (pDialogGameInfo)
+    {
+        pDialogGameInfo->Close();
+    }
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose: closes all the game info dialogs
+//-----------------------------------------------------------------------------
+void CMapSelector::CloseAllMapInfoDialogs()
+{
+    if (m_hMapsDlg.Get())
+    {
+        m_hMapsDlg->CloseAllMapInfoDialogs();
+    }
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapSelector.h b/mp/src/game/client/momentum/ui/MapSelection/MapSelector.h
new file mode 100644
index 000000000..64a875ebd
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapSelector.h
@@ -0,0 +1,30 @@
+#ifndef MAPSELECTOR_H
+#define MAPSELECTOR_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CMapSelectorDialog;
+
+class CMapSelector : public IMapSelector
+{
+public:
+    CMapSelector();
+    ~CMapSelector();
+
+    void Create(vgui::VPANEL parent);
+    void Destroy();
+    void Activate();
+    void Deactivate();
+
+    void Open();
+    void CloseAllMapInfoDialogs();
+
+private:
+    vgui::DHANDLE<CMapSelectorDialog> m_hMapsDlg;
+};
+
+extern IMapSelector* mapselector;
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.cpp b/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.cpp
new file mode 100644
index 000000000..3f84beeff
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.cpp
@@ -0,0 +1,489 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+
+static CMapSelectorDialog *s_InternetDlg = NULL;
+
+CMapSelectorDialog &MapSelectorDialog()
+{
+    return *CMapSelectorDialog::GetInstance();
+}
+
+
+// Returns a list of the ports that we hit when looking for 
+void GetMostCommonQueryPorts(CUtlVector<uint16> &ports)
+{
+    for (int i = 0; i <= 5; i++)
+    {
+        ports.AddToTail(27015 + i);
+        ports.AddToTail(26900 + i);
+    }
+
+    ports.AddToTail(4242); //RDKF
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CMapSelectorDialog::CMapSelectorDialog(vgui::VPANEL parent) : Frame(NULL, "CMapSelectorDialog")//"CServerBrowserDialog")
+{
+    SetParent(parent);
+    s_InternetDlg = this;
+    m_pSavedData = NULL;
+    m_pFilterData = NULL;
+
+    LoadUserData();
+
+    m_pLocal = new CLocalMaps(this);
+    //MOM_TODO: uncomment this: m_pOnline = new COnlineMaps(this);
+
+    SetMinimumSize(640, 384);
+    SetSize(640, 384);
+
+    m_pGameList = (IMapList*) m_pLocal;
+
+    m_pContextMenu = new CMapContextMenu(this);
+
+    // property sheet
+    m_pTabPanel = new PropertySheet(this, "MapTabs");
+    m_pTabPanel->SetTabWidth(72);
+    m_pTabPanel->AddPage(m_pLocal, "#MOM_MapSelector_LocalMaps");
+    //MOM_TODO: uncomment: m_pTabPanel->AddPage(m_pOnline, "#MOM_MapSelector_OnlineMaps");
+
+    m_pTabPanel->AddActionSignalTarget(this);
+
+    m_pStatusLabel = new Label(this, "StatusLabel", "");
+
+    LoadControlSettingsAndUserConfig("resource/ui/DialogMapSelector.res");
+
+    m_pStatusLabel->SetText("");
+
+    // load current tab
+    const char *mapList = m_pSavedData->GetString("MapList", "local");
+    if (!Q_stricmp(mapList, "local"))
+    {
+        m_pTabPanel->SetActivePage(m_pLocal);
+    }
+    else if (!Q_stricmp(mapList, "online"))
+    {
+        m_pTabPanel->SetActivePage(m_pOnline);
+    }
+
+    ivgui()->AddTickSignal(GetVPanel());
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CMapSelectorDialog::~CMapSelectorDialog()
+{
+    delete m_pContextMenu;
+
+    SaveUserData();
+
+    if (m_pSavedData)
+    {
+        m_pSavedData->deleteThis();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called once to set up
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::Initialize()
+{
+    SetTitle("#MOM_MapSelector_Maps", true);
+    SetVisible(false);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns a map in the list
+//-----------------------------------------------------------------------------
+mapstruct_t *CMapSelectorDialog::GetMap(unsigned int serverID)
+{
+    return m_pGameList->GetMap(serverID);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates and gives the tab focus
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::Open()
+{
+    BaseClass::Activate();
+    m_pTabPanel->RequestFocus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called every frame, updates animations for this module
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::OnTick()
+{
+    BaseClass::OnTick();
+    vgui::GetAnimationController()->UpdateAnimations(system()->GetFrameTime());
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads filter settings from disk
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::LoadUserData()
+{
+    // free any old filters
+    if (m_pSavedData)
+    {
+        m_pSavedData->deleteThis();
+    }
+
+    m_pSavedData = new KeyValues("Filters");
+    if (!m_pSavedData->LoadFromFile(g_pFullFileSystem, "cfg/MapSelector.vdf", "MOD"))
+    {
+        // doesn't matter if the file is not found, defaults will work successfully and file will be created on exit
+    }
+
+    KeyValues *filters = m_pSavedData->FindKey("Filters", false);
+    if (filters)
+    {
+        m_pFilterData = filters->MakeCopy();
+        m_pSavedData->RemoveSubKey(filters);
+    }
+    else
+    {
+        m_pFilterData = new KeyValues("Filters");
+    }
+
+    int wide, tall;
+    surface()->GetScreenSize(wide, tall);
+
+    SetPos(wide / 2, tall / 3);
+
+    InvalidateLayout();
+    Repaint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::SaveUserData()
+{
+    m_pSavedData->Clear();
+    m_pSavedData->LoadFromFile(g_pFullFileSystem, "cfg/MapSelector.vdf", "MOD");
+
+    // set the current tab
+    if (m_pGameList == m_pLocal)
+    {
+        m_pSavedData->SetString("MapList", "local");
+    }
+    else if (m_pGameList == m_pOnline)
+    {
+        m_pSavedData->SetString("MapList", "online");//MOM_TODO
+    }
+
+    m_pSavedData->RemoveSubKey(m_pSavedData->FindKey("Filters")); // remove the saved subkey and add our subkey
+    m_pSavedData->AddSubKey(m_pFilterData->MakeCopy());
+    m_pSavedData->SaveToFile(g_pFullFileSystem, "cfg/MapSelector.vdf", "MOD");
+
+    // save per-page config
+    SaveUserConfig();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes the page currently visible
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::RefreshCurrentPage()
+{
+    if (m_pGameList)
+    {
+        m_pGameList->StartRefresh();
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates status test at bottom of window
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::UpdateStatusText(const char *fmt, ...)
+{
+    if (!m_pStatusLabel)
+        return;
+
+    if (fmt && strlen(fmt) > 0)
+    {
+        char str[1024];
+        va_list argptr;
+        va_start(argptr, fmt);
+        _vsnprintf(str, sizeof(str), fmt, argptr);
+        va_end(argptr);
+
+        m_pStatusLabel->SetText(str);
+    }
+    else
+    {
+        // clear
+        m_pStatusLabel->SetText("");
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates status test at bottom of window
+// Input  : wchar_t* (unicode string) - 
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::UpdateStatusText(wchar_t *unicode)
+{
+    if (!m_pStatusLabel)
+        return;
+
+    if (unicode && wcslen(unicode) > 0)
+    {
+        m_pStatusLabel->SetText(unicode);
+    }
+    else
+    {
+        // clear
+        m_pStatusLabel->SetText("");
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates when the tabs are changed (online->Local and vice versa)
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::OnGameListChanged()
+{
+    m_pGameList = dynamic_cast<IMapList *>(m_pTabPanel->GetActivePage());
+
+    UpdateStatusText("");
+
+    InvalidateLayout();
+    Repaint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns a pointer to a static instance of this dialog
+//-----------------------------------------------------------------------------
+CMapSelectorDialog *CMapSelectorDialog::GetInstance()
+{
+    return s_InternetDlg;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMapContextMenu *CMapSelectorDialog::GetContextMenu(vgui::Panel *pPanel)
+{
+    // create a drop down for this object's states
+    if (m_pContextMenu)
+        delete m_pContextMenu;
+    m_pContextMenu = new CMapContextMenu(this);
+    m_pContextMenu->SetAutoDelete(false);
+
+    if (!pPanel)
+    {
+        m_pContextMenu->SetParent(this);
+    }
+    else
+    {
+        m_pContextMenu->SetParent(pPanel);
+    }
+
+    m_pContextMenu->SetVisible(false);
+    return m_pContextMenu;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: begins the process of joining a server from a game list
+//			the game info dialog it opens will also update the game list
+//-----------------------------------------------------------------------------
+CDialogMapInfo *CMapSelectorDialog::JoinGame(IMapList *gameList, unsigned int serverIndex)
+{
+    // open the game info dialog, then mark it to attempt to connect right away
+    //CDialogMapInfo *gameDialog = OpenMapInfoDialog(gameList, serverIndex);
+
+    // set the dialog name to be the server name
+    //gameDialog->Connect();
+
+    // return gameDialog;
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: joins a game by a specified IP, not attached to any game list
+//-----------------------------------------------------------------------------
+CDialogMapInfo *CMapSelectorDialog::JoinGame(int serverIP, int serverPort)
+{
+    // open the game info dialog, then mark it to attempt to connect right away
+    CDialogMapInfo *gameDialog = OpenMapInfoDialog(serverIP, serverPort, serverPort);
+
+    // set the dialog name to be the server name
+    gameDialog->Connect();
+
+    return gameDialog;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: opens a game info dialog from a game list
+//-----------------------------------------------------------------------------
+CDialogMapInfo *CMapSelectorDialog::OpenMapInfoDialog(IMapList *gameList, KeyValues *pMap)
+{
+    //mapstruct_t *pServer = gameList->GetMap(serverIndex);
+    //if (!pServer)
+    
+
+    //MOM_TODO: complete the following so people can see information on the map 
+
+    //We're going to send just the map name to the CDialogMapInfo() constructor,
+    //then to the server and populate it with leaderboard times, replays, personal bests, etc
+    const char *pMapName = pMap->GetString("name", "");
+    CDialogMapInfo *gameDialog = new CDialogMapInfo(NULL, pMapName);
+    gameDialog->SetParent(GetVParent());
+    gameDialog->AddActionSignalTarget(this);
+    gameDialog->Run(pMapName);
+    int i = m_vecMapInfoDialogs.AddToTail();
+    m_vecMapInfoDialogs[i] = gameDialog;
+    return gameDialog;
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: opens a game info dialog by a specified IP, not attached to any game list
+//-----------------------------------------------------------------------------
+CDialogMapInfo *CMapSelectorDialog::OpenMapInfoDialog(int serverIP, uint16 connPort, uint16 queryPort)
+{
+    CDialogMapInfo *gameDialog = new CDialogMapInfo(NULL, "");
+    gameDialog->AddActionSignalTarget(this);
+    gameDialog->SetParent(GetVParent());
+    gameDialog->Run("");
+    int i = m_vecMapInfoDialogs.AddToTail();
+    m_vecMapInfoDialogs[i] = gameDialog;
+    return gameDialog;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: closes all the game info dialogs
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::CloseAllMapInfoDialogs()
+{
+    for (int i = 0; i < m_vecMapInfoDialogs.Count(); i++)
+    {
+        vgui::Panel *dlg = m_vecMapInfoDialogs[i];
+        if (dlg)
+        {
+            vgui::ivgui()->PostMessage(dlg->GetVPanel(), new KeyValues("Close"), NULL);
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: finds a dialog
+//-----------------------------------------------------------------------------
+CDialogMapInfo *CMapSelectorDialog::GetDialogGameInfoForFriend(uint64 ulSteamIDFriend)
+{
+    FOR_EACH_VEC(m_vecMapInfoDialogs, i)
+    {
+        CDialogMapInfo *pDlg = m_vecMapInfoDialogs[i];
+        if (pDlg && pDlg->GetAssociatedFriend() == ulSteamIDFriend)
+        {
+            return pDlg;
+        }
+    }
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: accessor to the filter save data
+//-----------------------------------------------------------------------------
+KeyValues *CMapSelectorDialog::GetFilterSaveData(const char *filterSet)
+{
+    return m_pFilterData->FindKey(filterSet, true);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: resets all pages filter settings
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::ReloadFilterSettings()
+{
+    m_pLocal->LoadFilterSettings();
+    m_pOnline->LoadFilterSettings();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds server to the history, saves as currently connected server
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::OnConnectToGame(KeyValues *pMessageValues)
+{
+    //MOM_TODO: Make this OnStartMap/OnDownloadMap or similar
+
+    int ip = pMessageValues->GetInt("ip");
+    int connectionPort = pMessageValues->GetInt("connectionport");
+    int queryPort = pMessageValues->GetInt("queryport");
+
+    if (!ip || !queryPort)
+        return;
+
+    memset(&m_CurrentConnection, 0, sizeof(gameserveritem_t));
+    m_CurrentConnection.m_NetAdr.SetIP(ip);
+    m_CurrentConnection.m_NetAdr.SetQueryPort(queryPort);
+    m_CurrentConnection.m_NetAdr.SetConnectionPort((unsigned short) connectionPort);
+#ifndef NO_STEAM
+    //if (m_pHistory && SteamMatchmaking())
+    //{
+    //    SteamMatchmaking()->AddFavoriteGame2(0, ::htonl(ip), connectionPort, queryPort, k_unFavoriteFlagHistory, time(NULL));
+    //    m_pHistory->SetRefreshOnReload();
+    //}
+#endif
+    // tell the game info dialogs, so they can cancel if we have connected
+    // to a server they were auto-retrying
+    for (int i = 0; i < m_vecMapInfoDialogs.Count(); i++)
+    {
+        vgui::Panel *dlg = m_vecMapInfoDialogs[i];
+        if (dlg)
+        {
+            KeyValues *kv = new KeyValues("ConnectedToGame", "ip", ip, "connectionport", connectionPort);
+            kv->SetInt("queryport", queryPort);
+            vgui::ivgui()->PostMessage(dlg->GetVPanel(), kv, NULL);
+        }
+    }
+
+    // forward to favorites
+    //m_pFavorites->OnConnectToGame();
+
+    m_bCurrentlyConnected = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Clears currently connected server
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::OnDisconnectFromGame(void)
+{
+    m_bCurrentlyConnected = false;
+    memset(&m_CurrentConnection, 0, sizeof(gameserveritem_t));
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Passes build mode activation down into the pages
+//-----------------------------------------------------------------------------
+void CMapSelectorDialog::ActivateBuildMode()
+{
+    // no subpanel, no build mode
+    EditablePanel *panel = dynamic_cast<EditablePanel *>(m_pTabPanel->GetActivePage());
+    if (!panel)
+        return;
+
+    panel->ActivateBuildMode();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: gets the default position and size on the screen to appear the first time
+//-----------------------------------------------------------------------------
+bool CMapSelectorDialog::GetDefaultScreenPosition(int &x, int &y, int &wide, int &tall)
+{
+    int wx, wy, ww, wt;
+    surface()->GetWorkspaceBounds(wx, wy, ww, wt);
+    x = wx + (int) (ww * 0.05);
+    y = wy + (int) (wt * 0.4);
+    wide = (int) (ww * 0.5);
+    tall = (int) (wt * 0.55);
+    return true;
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.h b/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.h
new file mode 100644
index 000000000..c1a1bc4ba
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.h
@@ -0,0 +1,132 @@
+#ifndef SERVERBROWSERDIALOG_H
+#define SERVERBROWSERDIALOG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//extern class IRunGameEngine *g_pRunGameEngine;
+//extern class IAppInformation *g_pAppInformation; // can be NULL
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CMapSelectorDialog : public vgui::Frame
+{
+    DECLARE_CLASS_SIMPLE(CMapSelectorDialog, vgui::Frame);
+
+public:
+    // Construction/destruction
+    CMapSelectorDialog(vgui::VPANEL parent);
+    ~CMapSelectorDialog(void);
+
+    void		Initialize(void);
+
+    // displays the dialog, moves it into focus, updates if it has to
+    void		Open(void);
+    void        Close(void)
+    {
+        ConVar *pCvar = g_pCVar->FindVar("cl_showmapselection");
+        if (pCvar) pCvar->SetValue(0);
+        BaseClass::Close();
+    }
+
+    // gets server info
+    mapstruct_t *GetMap(unsigned int serverID);
+    // called every frame
+    virtual void OnTick();
+
+    // updates status text at bottom of window
+    void UpdateStatusText(const char *format, ...);
+
+    // updates status text at bottom of window
+    void UpdateStatusText(wchar_t *unicode);
+
+    // context menu access
+    CMapContextMenu *GetContextMenu(vgui::Panel *pParent);
+
+    // returns a pointer to a static instance of this dialog
+    // valid for use only in sort functions
+    static CMapSelectorDialog *GetInstance();
+
+    // begins the process of joining a server from a game list
+    // the game info dialog it opens will also update the game list
+    CDialogMapInfo *JoinGame(IMapList *gameList, unsigned int serverIndex);
+
+    // joins a game by a specified IP, not attached to any game list
+    CDialogMapInfo *JoinGame(int serverIP, int serverPort);
+
+    // opens a game info dialog from a game list
+    CDialogMapInfo *OpenMapInfoDialog(IMapList *gameList, KeyValues *pMap);
+
+    // opens a game info dialog by a specified IP, not attached to any game list
+    CDialogMapInfo *OpenMapInfoDialog(int serverIP, uint16 connPort, uint16 queryPort);
+
+    // closes all the game info dialogs
+    void CloseAllMapInfoDialogs();
+    CDialogMapInfo *GetDialogGameInfoForFriend(uint64 ulSteamIDFriend);
+
+    // accessor to the filter save data
+    KeyValues *GetFilterSaveData(const char *filterSet);
+
+    // load/saves filter & favorites settings from disk
+    void		LoadUserData();
+    void		SaveUserData();
+
+    // forces the currently active page to refresh
+    void		RefreshCurrentPage();
+
+    virtual gameserveritem_t *GetCurrentConnectedServer()
+    {
+        return &m_CurrentConnection;
+    }
+
+private:
+
+    // current game list change
+    MESSAGE_FUNC(OnGameListChanged, "PageChanged");
+    void ReloadFilterSettings();
+
+    // notification that we connected / disconnected
+    MESSAGE_FUNC_PARAMS(OnConnectToGame, "ConnectedToGame", kv);
+    MESSAGE_FUNC(OnDisconnectFromGame, "DisconnectedFromGame");
+
+    virtual bool GetDefaultScreenPosition(int &x, int &y, int &wide, int &tall);
+    virtual void ActivateBuildMode();
+
+private:
+    // list of all open game info dialogs
+    CUtlVector<vgui::DHANDLE<CDialogMapInfo> > m_vecMapInfoDialogs;
+
+    // pointer to current game list
+    IMapList *m_pGameList;
+
+    // Status text
+    vgui::Label	*m_pStatusLabel;
+
+    // property sheet
+    vgui::PropertySheet *m_pTabPanel;
+
+    //Map tabs
+    CLocalMaps *m_pLocal;
+    COnlineMaps *m_pOnline;
+
+    //Filter data
+    KeyValues *m_pSavedData;//Saved on disk filter data
+    KeyValues *m_pFilterData;//Current filter data in the Dialog
+
+    // context menu
+    CMapContextMenu *m_pContextMenu;
+
+    // currently connected game
+    bool m_bCurrentlyConnected;
+    gameserveritem_t m_CurrentConnection;
+};
+
+// singleton accessor
+extern CMapSelectorDialog &MapSelectorDialog();
+
+// Used by the LAN tab and the add server dialog when trying to find servers without having
+// been given any ports to look for servers on.
+void GetMostCommonQueryPorts(CUtlVector<uint16> &ports);
+
+#endif // SERVERBROWSERDIALOG_H
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.cpp b/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.cpp
new file mode 100644
index 000000000..540da0972
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.cpp
@@ -0,0 +1,304 @@
+#include "pch_mapselection.h"
+
+using namespace vgui;
+
+// How often to re-sort the server list
+const float MINIMUM_SORT_TIME = 1.5f;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//			NOTE:	m_Servers can not use more than 96 sockets, else it will
+//					cause internet explorer to Stop working under win98 SE!
+//-----------------------------------------------------------------------------
+COnlineMaps::COnlineMaps(vgui::Panel *parent, const char *panelName) : CBaseMapsPage(parent, panelName)
+{
+    m_fLastSort = 0.0f;
+    m_bDirty = false;
+    m_bRequireUpdate = true;
+    m_bOfflineMode = !IsSteamGameServerBrowsingEnabled();
+
+    m_bAnyServersRetrievedFromMaster = false;
+    m_bNoServersListedOnMaster = false;
+    m_bAnyServersRespondedToQuery = false;
+
+    //m_pLocationFilter->DeleteAllItems();
+    KeyValues *kv = new KeyValues("Regions");
+    if (kv->LoadFromFile(g_pFullFileSystem, "servers/Regions.vdf", NULL))
+    {
+        // iterate the list loading all the servers
+        for (KeyValues *srv = kv->GetFirstSubKey(); srv != NULL; srv = srv->GetNextKey())
+        {
+            struct regions_s region;
+
+            region.name = srv->GetString("text");
+            region.code = srv->GetInt("code");
+            KeyValues *regionKV = new KeyValues("region", "code", region.code);
+            //m_pLocationFilter->AddItem(region.name.String(), regionKV);
+            regionKV->deleteThis();
+            m_Regions.AddToTail(region);
+        }
+    }
+    else
+    {
+        Assert(!("Could not load file servers/Regions.vdf; server browser will not function."));
+    }
+    kv->deleteThis();
+
+    LoadFilterSettings();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+COnlineMaps::~COnlineMaps()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void COnlineMaps::PerformLayout()
+{
+    if (!m_bOfflineMode && m_bRequireUpdate && MapSelectorDialog().IsVisible())
+    {
+        PostMessage(this, new KeyValues("GetNewServerList"), 0.1f);
+        m_bRequireUpdate = false;
+    }
+
+    if (m_bOfflineMode)
+    {
+        m_pGameList->SetEmptyListText("#ServerBrowser_OfflineMode");
+        m_pStartMap->SetEnabled(false);
+        m_pRefreshAll->SetEnabled(false);
+        m_pRefreshQuick->SetEnabled(false);
+        m_pFilter->SetEnabled(false);
+    }
+
+    BaseClass::PerformLayout();
+    //m_pLocationFilter->SetEnabled(true);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Activates the page, starts refresh if needed
+//-----------------------------------------------------------------------------
+void COnlineMaps::OnPageShow()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called every frame, maintains sockets and runs refreshes
+//-----------------------------------------------------------------------------
+void COnlineMaps::OnTick()
+{
+    if (m_bOfflineMode)
+    {
+        BaseClass::OnTick();
+        return;
+    }
+
+    BaseClass::OnTick();
+
+    CheckRedoSort();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles incoming server refresh data
+//			updates the server browser with the refreshed information from the server itself
+//-----------------------------------------------------------------------------
+void COnlineMaps::ServerResponded(int iServer)
+{
+    m_bDirty = true;
+    //BaseClass::ServerResponded(iServer);
+    m_bAnyServersRespondedToQuery = true;
+    m_bAnyServersRetrievedFromMaster = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void COnlineMaps::ServerFailedToRespond(int iServer)
+{
+    /*
+#ifndef NO_STEAM
+    m_bDirty = true;
+    gameserveritem_t *pServer = SteamMatchmakingServers()->GetServerDetails(m_eMatchMakingType, iServer);
+    Assert(pServer);
+
+    if (pServer->m_bHadSuccessfulResponse)
+    {
+        // if it's had a successful response in the past, leave it on
+        ServerResponded(iServer);
+    }
+    else
+    {
+        int iServerMap = m_mapServers.Find(iServer);
+        if (iServerMap != m_mapServers.InvalidIndex())
+            RemoveServer(m_mapServers[iServerMap]);
+        // we've never had a good response from this server, remove it from the list
+        m_iServerRefreshCount++;
+    }
+#endif*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when server refresh has been completed
+//-----------------------------------------------------------------------------
+void COnlineMaps::RefreshComplete(EMatchMakingServerResponse response)
+{
+    SetRefreshing(false);
+    UpdateFilterSettings();
+
+    if (response != eServerFailedToRespond)
+    {
+        if (m_bAnyServersRespondedToQuery)
+        {
+            m_pGameList->SetEmptyListText(GetStringNoUnfilteredServers());
+        }
+        else if (response == eNoServersListedOnMasterServer)
+        {
+            m_pGameList->SetEmptyListText(GetStringNoUnfilteredServersOnMaster());
+        }
+        else
+        {
+            m_pGameList->SetEmptyListText(GetStringNoServersResponded());
+        }
+    }
+    else
+    {
+        m_pGameList->SetEmptyListText("#ServerBrowser_MasterServerNotResponsive");
+    }
+
+    // perform last sort
+    m_bDirty = false;
+    m_fLastSort = Plat_FloatTime();
+    if (IsVisible())
+    {
+        m_pGameList->SortList();
+    }
+
+    UpdateStatus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void COnlineMaps::GetNewMapList()
+{
+    BaseClass::GetNewMapList();
+    UpdateStatus();
+
+    m_bRequireUpdate = false;
+    m_bAnyServersRetrievedFromMaster = false;
+    m_bAnyServersRespondedToQuery = false;
+
+    m_pGameList->DeleteAllItems();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the game list supports the specified ui elements
+//-----------------------------------------------------------------------------
+bool COnlineMaps::SupportsItem(IMapList::InterfaceItem_e item)
+{
+    switch (item)
+    {
+    case FILTERS:
+    case GETNEWLIST:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void COnlineMaps::CheckRedoSort(void)
+{
+    float fCurTime;
+
+    // No changes detected
+    if (!m_bDirty)
+        return;
+
+    fCurTime = Plat_FloatTime();
+    // Not time yet
+    if (fCurTime - m_fLastSort < MINIMUM_SORT_TIME)
+        return;
+
+    // postpone sort if mouse button is down
+    if (input()->IsMouseDown(MOUSE_LEFT) || input()->IsMouseDown(MOUSE_RIGHT))
+    {
+        // don't sort for at least another second
+        m_fLastSort = fCurTime - MINIMUM_SORT_TIME + 1.0f;
+        return;
+    }
+
+    // Reset timer
+    m_bDirty = false;
+    m_fLastSort = fCurTime;
+
+    // Force sort to occur now!
+    m_pGameList->SortList();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: opens context menu (user right clicked on a server)
+//-----------------------------------------------------------------------------
+void COnlineMaps::OnOpenContextMenu(int itemID)
+{
+    if (!m_pGameList->GetSelectedItemsCount())
+        return;
+
+    // get the server
+    //int serverID = m_pGameList->GetItemData(m_pGameList->GetSelectedItem(0))->userData;
+
+    // Activate context menu
+    CMapContextMenu *menu = MapSelectorDialog().GetContextMenu(m_pGameList);
+    menu->ShowMenu(this, true, true);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes a single server
+//-----------------------------------------------------------------------------
+void COnlineMaps::OnRefreshServer(int serverID)
+{
+    BaseClass::OnRefreshServer(serverID);
+
+    MapSelectorDialog().UpdateStatusText("#ServerBrowser_GettingNewServerList");
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: get the region code selected in the ui
+// Output: returns the region code the user wants to filter by
+//-----------------------------------------------------------------------------
+int COnlineMaps::GetRegionCodeToFilter()
+{
+    //KeyValues *kv = m_pLocationFilter->GetActiveItemUserData();
+    //if (kv)
+     //   return kv->GetInt("code");
+    //else
+        return 255;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool COnlineMaps::CheckTagFilter(gameserveritem_t &server)
+{
+    // Servers without tags go in the official games, servers with tags go in custom games
+    bool bOfficialServer = !(server.m_szGameTags && server.m_szGameTags[0]);
+    if (!bOfficialServer)
+        return false;
+
+    return true;
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.h b/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.h
new file mode 100644
index 000000000..62997b90a
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.h
@@ -0,0 +1,75 @@
+#ifndef INTERNETGAMES_H
+#define INTERNETGAMES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Internet games list
+//-----------------------------------------------------------------------------
+class COnlineMaps : public CBaseMapsPage
+{
+
+    DECLARE_CLASS_SIMPLE(COnlineMaps, CBaseMapsPage);
+
+public:
+    COnlineMaps(vgui::Panel *parent, const char *panelName = "OnlineMaps");
+    ~COnlineMaps();
+
+    // property page handlers
+    virtual void OnPageShow();
+
+    // returns true if the game list supports the specified ui elements
+    virtual bool SupportsItem(IMapList::InterfaceItem_e item);
+
+    // gets a new server list
+    MESSAGE_FUNC(GetNewMapList, "GetNewMapList");
+
+    // serverlist refresh responses
+    virtual void ServerResponded(int iServer);
+    virtual void ServerFailedToRespond(int iServer);
+    virtual void RefreshComplete(EMatchMakingServerResponse response);
+    MESSAGE_FUNC_INT(OnRefreshServer, "RefreshServer", serverID);
+
+    virtual int GetRegionCodeToFilter();
+    virtual bool CheckTagFilter(gameserveritem_t &server);
+    //virtual void LoadFilterSettings() {};//MOM_TODO: make this filter online maps (by name/gametype/difficulty?)
+
+protected:
+    // vgui overrides
+    virtual void PerformLayout();
+    virtual void OnTick();
+
+    virtual const char *GetStringNoUnfilteredServers() { return "#ServerBrowser_NoInternetGames"; }
+    virtual const char *GetStringNoUnfilteredServersOnMaster() { return "#ServerBrowser_MasterServerHasNoServersListed"; }
+    virtual const char *GetStringNoServersResponded() { return "#ServerBrowser_NoInternetGamesResponded"; }
+
+private:
+    // Called once per frame to see if sorting needs to occur again
+    void CheckRedoSort();
+    // Called once per frame to check re-send request to master server
+    //void CheckRetryRequest(ESteamServerType serverType);
+    // opens context menu (user right clicked on a server)
+    MESSAGE_FUNC_INT(OnOpenContextMenu, "OpenContextMenu", itemID);
+
+    struct regions_s
+    {
+        CUtlSymbol name;
+        unsigned char code;
+    };
+
+    CUtlVector<struct regions_s> m_Regions;	// list of the different regions you can query for
+
+    float				m_fLastSort;	// Time of last re-sort
+    bool				m_bDirty;	// Has the list been modified, thereby needing re-sort
+    bool				m_bRequireUpdate;	// checks whether we need an update upon opening
+
+    // error cases for if no servers are listed
+    bool				m_bAnyServersRetrievedFromMaster;
+    bool				m_bAnyServersRespondedToQuery;
+    bool				m_bNoServersListedOnMaster;
+
+    bool m_bOfflineMode;
+};
+
+#endif // INTERNETGAMES_H
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/MapSelection/pch_mapselection.h b/mp/src/game/client/momentum/ui/MapSelection/pch_mapselection.h
new file mode 100644
index 000000000..abda33db8
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/MapSelection/pch_mapselection.h
@@ -0,0 +1,56 @@
+#include <winlite.h>
+#undef CreateDialog
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef _WIN32
+#include <direct.h>
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <time.h>
+
+#include "vstdlib/pch_vstdlib.h"
+#include "vgui_controls/pch_vgui_controls.h"
+#include "vgui_controls/Frame.h"
+
+#include "tier3/tier3.h"
+
+// steam3 API
+//#include "steam/isteammasterserverupdater.h"
+//#include "steam/steam_querypackets.h"
+#include "steam/steam_api.h"
+#include "steam/isteamuser.h"
+#include "steam/isteammatchmaking.h"
+#include "steam/isteamfriends.h"
+
+#include "momentum/ui/MapSelection/IMapSelector.h"
+//#include "ServerBrowser/IServerBrowser.h"
+//#include "IVGuiModule.h"
+//#include "vgui_controls/Controls.h"
+
+//#include "tier1/netadr.h"
+//#include "FileSystem.h"
+//#include "iappinformation.h"
+//#include "proto_oob.h"
+//#include "modlist.h"
+//#include "IRunGameEngine.h"
+#include "momentum/mom_shareddefs.h"
+#include "momentum/mom_gamerules.h"
+#include "momentum/util/mom_util.h"
+#include "OfflineMode.h"
+
+//VGUI
+#include <vgui_controls/pch_vgui_controls.h>
+
+//MapSelection headers
+#include "IMapList.h"
+#include "MapSelector.h"
+#include "MapContextMenu.h"
+#include "MapInfoDialog.h"
+#include "BaseMapsPage.h"
+#include "LocalMaps.h"
+#include "OnlineMaps.h"
+#include "MapSelectorDialog.h"
+#include "cbase.h"
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/hud_cp_menu.cpp b/mp/src/game/client/momentum/ui/hud_cp_menu.cpp
new file mode 100644
index 000000000..06b61d1ff
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/hud_cp_menu.cpp
@@ -0,0 +1,367 @@
+#include "cbase.h"
+#include "hud_cp_menu.h"
+
+#include "tier0/memdbgon.h"
+/*This class was needed because the base CHudMenu has
+a timer on it for when no option is made in 5 seconds.
+We override the class here, and to be honest, this can
+probably be created into a sub-menu class if we need
+other similar menus in the future.
+
+MOM_TODO:
+make creating a checkpoint stop your timer
+make checkpoints available for output to files
+*/
+using namespace vgui;
+
+C_CP_Menu::C_CP_Menu(const char *pElementName) : CHudElement(pElementName), Panel(g_pClientMode->GetViewport(), "CPMenu")
+{
+    SetHiddenBits(HIDEHUD_WEAPONSELECTION);
+};
+
+DECLARE_HUDELEMENT(C_CP_Menu);
+
+//Override
+bool C_CP_Menu::ShouldDraw()
+{
+    return CHudElement::ShouldDraw() && m_bMenuDisplayed;
+}
+
+//OVERRIDE
+void C_CP_Menu::Init(void)
+{
+    m_nSelectedItem = -1;
+    m_bMenuTakesInput = false;
+    m_bMenuDisplayed = false;
+    m_bitsValidSlots = 0;
+    m_Processed.RemoveAll();
+    m_nMaxPixels = 0;
+    m_nHeight = 0;
+    Reset();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_CP_Menu::Reset(void)
+{
+    g_szPrelocalisedMenuString[0] = 0;
+    m_fWaitingForMore = false;
+}
+
+void C_CP_Menu::VidInit(void)
+{
+}
+
+
+CON_COMMAND(showCPmenu, "Opens the Checkpoint Menu.\n")
+{
+    C_CP_Menu *cpMenu = (C_CP_Menu *) gHUD.FindElement("C_CP_Menu");
+    if (!cpMenu || cpMenu->ShouldDraw()) return;
+    else
+    {
+        engine->ServerCmd("cpmenu");
+        KeyValues* pKv = new KeyValues("CP Menu");
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_CreateCP"));
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_ToPreviousCP"));
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_ToNextCP"));
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_ToLastCP"));
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_RemoveCurrentCP"));
+        pKv->AddSubKey(new KeyValues("#MOM_Menu_RemoveEveryCP"));
+        cpMenu->ShowMenu_KeyValueItems(pKv);
+        pKv->deleteThis();
+    }
+}
+
+void C_CP_Menu::OnThink()
+{
+    if (m_bMenuDisplayed)
+    {
+        if (m_nSelectedItem > 0)
+        {
+            if (gpGlobals->realtime - m_flSelectionTime >= 1.0f)
+                m_nSelectedItem = -1;//reset the selection so colors are fine
+        }
+
+        if (m_flShutoffTime > 0 && m_flShutoffTime <= gpGlobals->realtime)
+        {
+            m_bMenuDisplayed = false;
+        }
+    }
+}
+
+void C_CP_Menu::HideMenu(void)
+{
+    m_bMenuTakesInput = false;
+    m_flShutoffTime = gpGlobals->realtime + m_flOpenCloseTime;
+    g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("MenuClose");
+}
+
+//Overridden because we want the menu to stay up after selection
+void C_CP_Menu::SelectMenuItem(int menu_item)
+{
+    m_nSelectedItem = menu_item;
+    g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("MenuPulse");
+    C_BasePlayer *cPlayer = C_BasePlayer::GetLocalPlayer();
+    if (cPlayer != NULL)
+    {
+        cPlayer->EmitSound("Momentum.UIMenuSelection");
+    }
+    if (menu_item == 0)
+        HideMenu();
+
+    engine->ServerCmd(VarArgs("cpmenu %i", menu_item));
+}
+
+int	C_CP_Menu::KeyInput(int down, ButtonCode_t keynum, const char *pszCurrentBinding)
+{
+    if (!m_bMenuDisplayed) return 1;
+    if (down >= 1 && keynum >= KEY_0 && keynum <= KEY_9)
+    {
+        SelectMenuItem(keynum - KEY_0);
+        m_flSelectionTime = gpGlobals->realtime;
+        return 0;
+    }
+    else
+    {
+        return 1;
+    }
+}
+
+void C_CP_Menu::Paint()
+{
+    if (!m_bMenuDisplayed)
+    {
+        return;
+    }
+
+    // center it
+    int x = 20;
+
+    Color	menuColor = m_MenuColor;
+    Color itemColor = m_ItemColor;
+
+    int c = m_Processed.Count();
+
+    int border = 20;
+
+    int wide = m_nMaxPixels + border;
+    int tall = m_nHeight + border;
+
+    int y = (ScreenHeight() - tall) * 0.5f;
+
+    DrawBox(x - border / 2, y - border / 2, wide, tall, GetBgColor(), 1);
+
+    menuColor[3] = menuColor[3] * (m_flSelectionAlphaOverride / 255.0f);
+    itemColor[3] = itemColor[3] * (m_flSelectionAlphaOverride / 255.0f);
+
+    for (int i = 0; i < c; i++)
+    {
+        ProcessedLine *line = &m_Processed[i];
+        if (!line) continue;
+
+        Color clr = line->menuitem != 0 ? itemColor : menuColor;
+
+        bool canblur = false;
+        if (line->menuitem != 0 &&
+            m_nSelectedItem >= 0 &&
+            m_nSelectedItem != m_Processed.Count() &&//Saves the zero from flashing
+            (line->menuitem == m_nSelectedItem))
+        {
+            canblur = true;
+        }
+
+        vgui::surface()->DrawSetTextColor(GetFgColor());
+
+        int drawLen = line->length;
+        if (line->menuitem != 0)
+        {
+            drawLen *= m_flTextScan;
+        }
+
+        vgui::surface()->DrawSetTextFont(textFont);
+
+        PaintString(&g_szMenuString[line->startchar], drawLen,
+            line->menuitem != 0 ? m_hItemFont : textFont, x, y);
+
+        if (canblur)
+        {
+            // draw the overbright blur
+            for (float fl = m_flBlur; fl > 0.0f; fl -= 1.0f)
+            {
+                if (fl >= 1.0f)
+                {
+                    PaintString(&g_szMenuString[line->startchar], drawLen, m_hItemFontPulsing, x, y);
+                }
+                else
+                {
+                    // draw a percentage of the last one
+                    Color col = clr;
+                    col[3] *= fl;
+                    vgui::surface()->DrawSetTextColor(col);
+                    PaintString(&g_szMenuString[line->startchar], drawLen, m_hItemFontPulsing, x, y);
+                }
+            }
+        }
+
+        y += line->height;
+    }
+}
+
+void C_CP_Menu::PaintString(const wchar_t *text, int textlen, vgui::HFont& font, int x, int y)
+{
+    vgui::surface()->DrawSetTextFont(font);
+    vgui::surface()->DrawSetTextPos(x, y);
+    for (int ch = 0; ch < textlen; ch++)
+    {
+        vgui::surface()->DrawUnicodeChar(text[ch]);
+    }
+}
+
+void C_CP_Menu::ProcessText(void)
+{
+    m_Processed.RemoveAll();
+    m_nMaxPixels = 0;
+    m_nHeight = 0;
+
+    int i = 0;
+    int startpos = i;
+    //int menuitem = 0;
+    int menuitem = 1;
+    while (i < 512)
+    {
+        wchar_t ch = g_szMenuString[i];
+        if (ch == 0)
+            break;
+
+        // Skip to end of line
+        while (i < 512 && g_szMenuString[i] != 0 && g_szMenuString[i] != L'\n')
+        {
+            i++;
+        }
+
+        // Store off line
+        if ((i - startpos) >= 1)
+        {
+            ProcessedLine line;
+            line.menuitem = menuitem;
+            line.startchar = startpos;
+            line.length = i - startpos;
+            line.pixels = 0;
+            line.height = 0;
+
+            m_Processed.AddToTail(line);
+        }
+
+        //menuitem = 0;
+        menuitem++;
+        // Skip delimiter
+        if (g_szMenuString[i] == '\n')
+        {
+            i++;
+        }
+        startpos = i;
+    }
+    menuitem = 0;
+    // Add final block
+    if (i - startpos >= 1)
+    {
+        ProcessedLine line;
+        line.menuitem = menuitem;
+        line.startchar = startpos;
+        line.length = i - startpos;
+        line.pixels = 0;
+        line.height = 0;
+
+        m_Processed.AddToTail(line);
+    }
+
+    // Now compute pixels needed
+    int c = m_Processed.Count();
+    for (i = 0; i < c; i++)
+    {
+        ProcessedLine *l = &m_Processed[i];
+        Assert(l);
+
+        int pixels = 0;
+        vgui::HFont font = textFont;//l->menuitem != 0 ? m_hItemFont : m_hTextFont;
+        for (int ch = 0; ch < l->length; ch++)
+        {
+            pixels += vgui::surface()->GetCharacterWidth(font, g_szMenuString[ch + l->startchar]);
+        }
+
+        l->pixels = pixels;
+        l->height = vgui::surface()->GetFontTall(font);
+        if (pixels > m_nMaxPixels)
+        {
+            m_nMaxPixels = pixels;
+        }
+        m_nHeight += l->height;
+    }
+}
+
+void C_CP_Menu::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+    BaseClass::ApplySchemeSettings(pScheme);
+
+    SetPaintBackgroundEnabled(false);
+    textFont = pScheme->GetFont("Default", true);
+    // set our size
+    int screenWide, screenTall;
+    int x, y;
+    GetPos(x, y);
+    GetHudSize(screenWide, screenTall);
+    SetBounds(0, y, screenWide, screenTall - y);
+
+    ProcessText();
+}
+
+void C_CP_Menu::ShowMenu_KeyValueItems(KeyValues *pKV)
+{
+    m_flShutoffTime = -1;
+    m_fWaitingForMore = 0;
+    m_bitsValidSlots = 0;
+
+    g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("MenuOpen");
+    m_nSelectedItem = -1;
+
+    g_szMenuString[0] = '\0';
+    wchar_t *pWritePosition = g_szMenuString;
+    int		nRemaining = sizeof(g_szMenuString) / sizeof(wchar_t);
+    int		nCount;
+
+    int i = 0;
+    for (KeyValues *item = pKV->GetFirstSubKey(); item != NULL; item = item->GetNextKey())
+    {
+        // Set this slot valid
+        m_bitsValidSlots |= (1 << i);
+        const char *pszItem = item->GetName();
+
+        wchar_t wLocalizedItem[512];
+        wchar_t *wLocalizedItemPtr = g_pVGuiLocalize->Find(pszItem);
+        if (!wLocalizedItemPtr)
+        {
+            // Try to find the localized string of the token. If null, we display pszItem instead.
+            g_pVGuiLocalize->ConvertANSIToUnicode(pszItem, wLocalizedItem, 512);
+            DevWarning("Missing localization for %s\n", pszItem);
+        }
+        else Q_wcsncpy(wLocalizedItem, wLocalizedItemPtr, 512);
+
+        nCount = _snwprintf(pWritePosition, nRemaining, L"%d. %ls\n", i + 1, wLocalizedItem);
+        nRemaining -= nCount;
+        pWritePosition += nCount;
+
+        i++;
+    }
+    // put a cancel on the end
+    m_bitsValidSlots |= (1 << 9);
+
+    nCount = _snwprintf(pWritePosition, nRemaining, L"0. %ls\n", g_pVGuiLocalize->Find("#MOM_Menu_Cancel"));
+    nRemaining -= nCount;
+    pWritePosition += nCount;
+
+    ProcessText();
+
+    m_bMenuDisplayed = true;
+    m_bMenuTakesInput = true;
+}
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/hud_cp_menu.h b/mp/src/game/client/momentum/ui/hud_cp_menu.h
new file mode 100644
index 000000000..475651c70
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/hud_cp_menu.h
@@ -0,0 +1,91 @@
+#include "cbase.h"
+#include "view.h"
+#include "iclientmode.h"
+#include "utlvector.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include "text_message.h"
+#include "hud_macros.h"
+#include "weapon_selection.h"
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Frame.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include <vgui/VGUI.h>
+#include <KeyValues.h>
+#include <vgui_controls/AnimationController.h>
+
+
+
+class C_CP_Menu : public CHudElement, public vgui::Panel {
+
+	DECLARE_CLASS_SIMPLE(C_CP_Menu, vgui::Panel);
+
+public:
+	C_CP_Menu(const char*);
+
+	wchar_t g_szMenuString[512];
+	char g_szPrelocalisedMenuString[512];
+	
+	void Init(void);
+	void VidInit(void);
+	void Reset(void);
+	virtual bool ShouldDraw(void);
+	void HideMenu(void);
+	virtual void Paint();
+	void OnThink();
+
+	//Overrides
+	void SelectMenuItem(int menu_item);
+
+	virtual int KeyInput(int down, ButtonCode_t keynum, const char *pszCurrentBinding);
+
+	void		ProcessText(void);
+	void ShowMenu_KeyValueItems(KeyValues *pKV);
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	void PaintString(const wchar_t *text, int textlen, vgui::HFont& font, int x, int y);
+
+private:
+	struct ProcessedLine
+	{
+		int	menuitem; // -1 for just text
+		int startchar;
+		int length;
+		int pixels;
+		int height;
+	};
+
+	CUtlVector< ProcessedLine >	m_Processed;
+
+	int				m_nMaxPixels;
+	int				m_nHeight;
+
+	bool			m_bMenuDisplayed;
+	int				m_bitsValidSlots;
+	float			m_flShutoffTime;
+	int				m_fWaitingForMore;
+	int				m_nSelectedItem;
+	bool			m_bMenuTakesInput;
+    float           m_flSelectionTime;
+
+protected:
+	CPanelAnimationVar(Color, m_TextColor, "TextColor", "FgColor");
+	CPanelAnimationVar(vgui::HFont, textFont, "TextFont", "Default");
+	CPanelAnimationVar(float, m_flOpenCloseTime, "OpenCloseTime", "1");
+
+	CPanelAnimationVar(float, m_flBlur, "Blur", "0");
+	CPanelAnimationVar(float, m_flTextScan, "TextScan", "1.0");
+
+	CPanelAnimationVar(float, m_flAlphaOverride, "Alpha", "255.0");
+	CPanelAnimationVar(float, m_flSelectionAlphaOverride, "SelectionAlpha", "255.0");
+
+	CPanelAnimationVar(vgui::HFont, m_hItemFont, "ItemFont", "Default");
+    CPanelAnimationVar(vgui::HFont, m_hItemFontPulsing, "ItemFontPulsing", "Default");//"MenuItemFontPulsing");
+
+	CPanelAnimationVar(Color, m_MenuColor, "MenuColor", "BgColor");
+	CPanelAnimationVar(Color, m_ItemColor, "MenuItemColor", "FgColor");
+	CPanelAnimationVar(Color, m_BoxColor, "MenuBoxColor", "BgColor");
+
+};
\ No newline at end of file
diff --git a/mp/src/game/client/momentum/ui/speedometer.cpp b/mp/src/game/client/momentum/ui/speedometer.cpp
new file mode 100644
index 000000000..6d08fd6c0
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/speedometer.cpp
@@ -0,0 +1,114 @@
+#include "cbase.h"
+#include "hudelement.h"
+#include "hud_numericdisplay.h"
+#include "iclientmode.h"
+#include <math.h>
+#include "vphysics_interface.h"
+
+using namespace vgui;
+
+static ConVar speedmeter_hvel("mom_speedmeter_hvel", "0", FCVAR_DONTRECORD | FCVAR_CLIENTDLL | FCVAR_ARCHIVE,
+    "If set to 1, doesn't take the vertical velocity component into account.\n", true, 0, true, 1);
+
+static ConVar speedmeter_units("mom_speedmeter_units", "1",FCVAR_DONTRECORD | FCVAR_ARCHIVE | FCVAR_CLIENTDLL,
+    "Changes the units of measure of the speedmeter. \n 1: Units per second. \n 2: Kilometers per hour. \n 3: Milles per hour.\n",true, 1, true, 3);
+
+static ConVar speedmeter_draw("mom_drawspeedmeter", "1", FCVAR_CLIENTDLL | FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_ARCHIVE,
+    "Toggles displaying the speedmeter.\n", true, 0, true, 1);
+
+class CHudSpeedMeter : public CHudElement, public CHudNumericDisplay
+{
+	DECLARE_CLASS_SIMPLE(CHudSpeedMeter, CHudNumericDisplay);
+
+public:
+	CHudSpeedMeter(const char *pElementName);
+	virtual void Init()
+	{
+		Reset();
+	}
+	virtual void VidInit()
+	{
+		Reset();
+	}
+	virtual void Reset()
+	{
+		//We set the proper LabelText based on mom_speedmeter_units value
+		switch (speedmeter_units.GetInt()) 
+		{
+		case 1:
+			SetLabelText(L"UPS");
+			break;
+		case 2:
+			SetLabelText(L"KM/H");
+			break;
+		case 3:
+			SetLabelText(L"MPH");
+			break;
+		default:
+			//If its value is not supported, USP is assumed (Even though this shouln't happen as Max and Min values are set)
+			SetLabelText(L"UPS");
+			break;
+		}	
+		SetDisplayValue(0);
+	}
+	virtual void OnThink();
+    virtual bool ShouldDraw()
+    {
+        return speedmeter_draw.GetBool() && CHudElement::ShouldDraw();
+    }
+};
+
+DECLARE_HUDELEMENT(CHudSpeedMeter);
+
+
+CHudSpeedMeter::CHudSpeedMeter(const char *pElementName) : CHudElement(pElementName), CHudNumericDisplay(g_pClientMode->GetViewport(), "HudSpeedMeter")
+{
+    // This is already set for HUD elements, but still...
+    SetProportional(true);
+    SetKeyBoardInputEnabled(false);
+    SetMouseInputEnabled(false);
+    SetHiddenBits(HIDEHUD_WEAPONSELECTION);
+}
+
+void CHudSpeedMeter::OnThink()
+{
+	Vector velocity = vec3_origin;
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if (player) {
+		velocity = player->GetLocalVelocity();
+
+		// Remove the vertical component if necessary
+		if (!speedmeter_hvel.GetBool())
+		{
+			velocity.z = 0;
+		}
+
+		//Conversions based on https://developer.valvesoftware.com/wiki/Dimensions#Map_Grid_Units:_quick_reference
+		float vel = (float)velocity.Length();
+		switch (speedmeter_units.GetInt())
+		{
+		case 1:
+			//We do nothing but break out of the switch, as default vel is already in UPS
+			SetLabelText(L"UPS");
+			break;
+		case 2:
+			//1 unit = 19.05mm -> 0.01905m -> 0.00001905Km(/s) -> 0.06858Km(/h)
+			vel = vel * 0.06858;
+			SetLabelText(L"KM/H");
+			break;
+		case 3:
+			//1 unit = 0.75", 1 mile = 63360. 0.75 / 63360 ~~> 0.00001184"(/s) ~~> 0.04262MPH 
+			vel = vel * 0.04262;
+			SetLabelText(L"MPH");
+			break;
+		default:
+			//We do nothing but break out of the switch, as default vel is already in UPS
+			SetLabelText(L"UPS");
+			break;
+		}
+		//With this round we ensure that the speed is as precise as possible, instead of taking the floor value of the float
+		SetDisplayValue(round(vel));
+	}
+}
+
+
diff --git a/mp/src/game/client/momentum/ui/timer.cpp b/mp/src/game/client/momentum/ui/timer.cpp
new file mode 100644
index 000000000..a0175ad03
--- /dev/null
+++ b/mp/src/game/client/momentum/ui/timer.cpp
@@ -0,0 +1,333 @@
+#include "cbase.h"
+#include "hudelement.h"
+#include "hud_numericdisplay.h"
+#include "hud_macros.h"
+#include "iclientmode.h"
+#include "view.h"
+#include "menu.h"
+
+using namespace vgui;
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Frame.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include <vgui_controls/AnimationController.h>
+
+#include "vgui_helpers.h"
+#include "momentum/util/mom_util.h"
+
+#include "tier0/memdbgon.h"
+
+#define BUFSIZETIME (sizeof("00:00:00.0000")+1)
+#define BUFSIZELOCL (73)
+
+static ConVar mom_timer("mom_timer", "1",
+    FCVAR_DONTRECORD | FCVAR_CLIENTDLL | FCVAR_ARCHIVE,
+    "Turn the timer display on/off\n");
+
+static ConVar timer_mode("mom_timer_mode", "0", FCVAR_DONTRECORD | FCVAR_CLIENTDLL | FCVAR_ARCHIVE | FCVAR_REPLICATED,
+    "Set what type of timer you want.\n0 = Generic Timer (no splits)\n1 = Splits by Checkpoint\n");
+
+class C_Timer : public CHudElement, public Panel
+{
+    DECLARE_CLASS_SIMPLE(C_Timer, Panel);
+public:
+    C_Timer();
+    C_Timer(const char *pElementName);
+    virtual void Init();
+    virtual void Reset();
+    virtual void OnThink();
+    virtual bool ShouldDraw()
+    {
+        return mom_timer.GetBool() && CHudElement::ShouldDraw();
+    }
+    void MsgFunc_Timer_State(bf_read &msg);
+    void MsgFunc_Timer_Reset(bf_read &msg);
+    void MsgFunc_Timer_Checkpoint(bf_read &msg);
+    void MsgFunc_Timer_Stage(bf_read &msg);
+    void MsgFunc_Timer_StageCount(bf_read&);
+    virtual void Paint();
+    int GetCurrentTime();
+    bool m_bIsRunning;
+    int m_iStartTick;
+
+private:
+    int m_iStageCurrent;
+    int m_iStageCount;
+    int initialTall;
+    wchar_t m_pwCurrentTime[BUFSIZETIME];
+    char m_pszString[BUFSIZETIME];
+    wchar_t m_pwCurrentCheckpoints[BUFSIZELOCL];
+    char m_pszStringCps[BUFSIZELOCL];
+    wchar_t m_pwCurrentStages[BUFSIZELOCL];
+    char m_pszStringStages[BUFSIZELOCL];
+    CUtlMap<const char*, float> map;
+    int m_iTotalTicks;
+    bool m_bWereCheatsActivated = false;
+    bool m_bShowCheckpoints;
+    int m_iCheckpointCount;
+    int m_iCheckpointCurrent;
+
+protected:
+    CPanelAnimationVar(float, m_flBlur, "Blur", "0");
+    CPanelAnimationVar(Color, m_TextColor, "TextColor", "FgColor");
+    CPanelAnimationVar(Color, m_Ammo2Color, "Ammo2Color", "FgColor");
+
+    CPanelAnimationVar(HFont, m_hNumberFont, "NumberFont", "HudNumbers");
+    CPanelAnimationVar(HFont, m_hNumberGlowFont, "NumberGlowFont",
+        "HudNumbersGlow");
+    CPanelAnimationVar(HFont, m_hSmallNumberFont, "SmallNumberFont",
+        "HudNumbersSmall");
+    CPanelAnimationVar(HFont, m_hTextFont, "TextFont", "Default");
+
+    CPanelAnimationVarAliasType(bool, center_time, "centerTime", "1",
+        "BOOL");
+    CPanelAnimationVarAliasType(float, time_xpos, "time_xpos", "50",
+        "proportional_float");
+    CPanelAnimationVarAliasType(float, time_ypos, "time_ypos", "2",
+        "proportional_float");
+    CPanelAnimationVarAliasType(bool, center_cps, "centerCps", "1",
+        "BOOL");
+    CPanelAnimationVarAliasType(float, cps_xpos, "cps_xpos", "50",
+        "proportional_float");
+    CPanelAnimationVarAliasType(float, cps_ypos, "cps_ypos", "25",
+        "proportional_float");
+    CPanelAnimationVarAliasType(bool, center_stage, "centerStage", "1",
+        "BOOL");
+    CPanelAnimationVarAliasType(float, stage_xpos, "stage_xpos", "50",
+        "proportional_float");
+    CPanelAnimationVarAliasType(float, stage_ypos, "stage_ypos", "40",
+        "proportional_float");
+};
+
+DECLARE_HUDELEMENT(C_Timer);
+// MOM_TODO add more for checkpoints and ending
+DECLARE_HUD_MESSAGE(C_Timer, Timer_State);
+DECLARE_HUD_MESSAGE(C_Timer, Timer_Reset);
+DECLARE_HUD_MESSAGE(C_Timer, Timer_Checkpoint);
+DECLARE_HUD_MESSAGE(C_Timer, Timer_Stage);
+DECLARE_HUD_MESSAGE(C_Timer, Timer_StageCount);
+
+C_Timer::C_Timer(const char *pElementName) :
+CHudElement(pElementName), Panel(g_pClientMode->GetViewport(), "HudTimer")
+{
+    // This is already set for HUD elements, but still...
+    SetProportional(true);
+    SetKeyBoardInputEnabled(false);
+    SetMouseInputEnabled(false);
+    SetHiddenBits(HIDEHUD_WEAPONSELECTION);
+}
+
+void C_Timer::Init()
+{
+    HOOK_HUD_MESSAGE(C_Timer, Timer_State);
+    HOOK_HUD_MESSAGE(C_Timer, Timer_Reset);
+    HOOK_HUD_MESSAGE(C_Timer, Timer_Checkpoint);
+    HOOK_HUD_MESSAGE(C_Timer, Timer_Stage);
+    HOOK_HUD_MESSAGE(C_Timer, Timer_StageCount);
+    initialTall = 48;
+    m_iTotalTicks = 0;
+    //Reset();
+}
+
+void C_Timer::Reset()
+{
+    m_bIsRunning = false;
+    m_iTotalTicks = 0;
+    m_iStageCount = 0;
+    m_iStageCurrent = 0;
+    m_bShowCheckpoints = false;
+    m_iCheckpointCount = 0;
+    m_iCheckpointCurrent = 0;
+}
+
+void C_Timer::OnThink()
+{
+    if (m_iStageCount == 0)
+        engine->ServerCmd("hud_timer_request_stages");
+    // Cheat detection moved to server Timer.cpp
+}
+
+void C_Timer::MsgFunc_Timer_State(bf_read &msg)
+{
+    bool started = msg.ReadOneBit();
+    m_bIsRunning = started;
+    m_iStartTick = (int) msg.ReadLong();
+    C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+    if (!pPlayer)
+        return;
+    // MOM_TODO: Create HUD animations for states
+    if (started)
+    {
+        //VGUI_ANIMATE("TimerStart");
+        // Checking again, even if we just checked 8 lines before
+        if (pPlayer != NULL)
+        {
+            pPlayer->EmitSound("Momentum.StartTimer");
+        }
+    }
+    else // stopped
+    {
+        // Compare times.
+        if (m_bWereCheatsActivated) //EY, CHEATER, STOP
+        {
+            Msg("sv_cheats was set to 1, thus making the run not valid \n");
+        }
+        else //He didn't cheat, we can carry on
+        {
+            //m_iTotalTicks = gpGlobals->tickcount - m_iStartTick;
+            //DevMsg("Ticks upon exit: %i and total seconds: %f\n", m_iTotalTicks, gpGlobals->interval_per_tick);
+            //Paint();
+            //DevMsg("%s \n", m_pszString);
+        }
+
+        //VGUI_ANIMATE("TimerStop");
+        if (pPlayer != NULL)
+        {
+            pPlayer->EmitSound("Momentum.StopTimer");
+        }
+
+        //MOM_TODO: (Beta+) show scoreboard animation with new position on leaderboards?
+    }
+}
+
+void C_Timer::MsgFunc_Timer_Reset(bf_read &msg)
+{
+    Reset();
+}
+
+void C_Timer::MsgFunc_Timer_Checkpoint(bf_read &msg)
+{
+    m_bShowCheckpoints = msg.ReadOneBit();
+    m_iCheckpointCurrent = (int) msg.ReadLong();
+    m_iCheckpointCount = (int) msg.ReadLong();
+}
+
+void C_Timer::MsgFunc_Timer_Stage(bf_read &msg)
+{
+    m_iStageCurrent = (int) msg.ReadLong();
+    //g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("MenuPulse");
+}
+
+void C_Timer::MsgFunc_Timer_StageCount(bf_read &msg)
+{
+    m_iStageCount = (int) msg.ReadLong();
+}
+
+int C_Timer::GetCurrentTime()
+{
+    if (m_bIsRunning) m_iTotalTicks = gpGlobals->tickcount - m_iStartTick;
+    return m_iTotalTicks;
+}
+
+void C_Timer::Paint(void)
+{
+    mom_UTIL.FormatTime(GetCurrentTime(), gpGlobals->interval_per_tick, m_pszString);
+    
+    //float m_flSecondsTime = ((float) GetCurrentTime()) * gpGlobals->interval_per_tick;
+
+    /*int hours = m_flSecondsTime / (60.0f * 60.0f);
+    int minutes = fmod(m_flSecondsTime / 60.0f, 60.0f);
+    int seconds = fmod(m_flSecondsTime, 60.0f);
+    int millis = fmod(m_flSecondsTime, 1.0f) * 1000.0f;
+
+    Q_snprintf(m_pszString, sizeof(m_pszString), "%02d:%02d:%02d.%03d",
+        hours, //hours
+        minutes, //minutes
+        seconds, //seconds
+        millis //millis
+        );*/
+
+
+    g_pVGuiLocalize->ConvertANSIToUnicode(
+        m_pszString, m_pwCurrentTime, sizeof(m_pwCurrentTime));
+
+    if (m_bShowCheckpoints)
+    {
+        char cpLocalized[BUFSIZELOCL];
+        wchar_t *uCPUnicode = g_pVGuiLocalize->Find("#MOM_Checkpoint");
+        g_pVGuiLocalize->ConvertUnicodeToANSI(uCPUnicode ? uCPUnicode : L"#MOM_Checkpoint", cpLocalized, BUFSIZELOCL);
+
+        Q_snprintf(m_pszStringCps, sizeof(m_pszStringCps), "%s %i/%i",
+            cpLocalized, // Checkpoint localization
+            m_iCheckpointCurrent, //CurrentCP
+            m_iCheckpointCount //CPCount
+            );
+        g_pVGuiLocalize->ConvertANSIToUnicode(
+            m_pszStringCps, m_pwCurrentCheckpoints, sizeof(m_pwCurrentCheckpoints));
+    }
+    if (m_iStageCount > 1)
+    {
+        char stLocalized[BUFSIZELOCL];
+        wchar_t *uStageUnicode = g_pVGuiLocalize->Find("#MOM_Stage");
+        g_pVGuiLocalize->ConvertUnicodeToANSI(uStageUnicode ? uStageUnicode : L"#MOM_Stage", stLocalized, BUFSIZELOCL);
+        Q_snprintf(m_pszStringStages, sizeof(m_pszStringStages), "%s %i/%i",
+            stLocalized, // Stage localization
+            m_iStageCurrent, // Current Stage
+            m_iStageCount // Total number of stages
+            );
+    }
+    else //it's a linear map
+    {
+        char linearLocalized[25];
+        wchar_t *uLinearUnicode = g_pVGuiLocalize->Find("#MOM_Linear");
+        g_pVGuiLocalize->ConvertUnicodeToANSI(uLinearUnicode ? uLinearUnicode : L"#MOM_Linear", linearLocalized, 25);
+        Q_snprintf(m_pszStringStages, sizeof(m_pszStringStages), linearLocalized);
+    }
+
+    g_pVGuiLocalize->ConvertANSIToUnicode(
+        m_pszStringStages, m_pwCurrentStages, sizeof(m_pwCurrentStages));
+
+    // Draw the text label.
+    surface()->DrawSetTextFont(m_hTextFont);
+    surface()->DrawSetTextColor(GetFgColor());
+
+    // Draw current time.
+    int dummy, totalWide;
+
+    GetSize(totalWide, dummy);
+
+    if (center_time)
+    {
+        int timeWide;
+        surface()->GetTextSize(m_hTextFont, m_pwCurrentTime, timeWide, dummy);
+        int offsetToCenter = ((totalWide - timeWide) / 2);
+        surface()->DrawSetTextPos(offsetToCenter, time_ypos);
+    }
+    else
+    {
+        surface()->DrawSetTextPos(time_xpos, time_ypos);
+    }
+    surface()->DrawPrintText(m_pwCurrentTime, wcslen(m_pwCurrentTime));
+
+    if (m_bShowCheckpoints)
+    {
+        if (center_cps)
+        {
+            int cpsWide;
+            surface()->GetTextSize(m_hTextFont, m_pwCurrentCheckpoints, cpsWide, dummy);
+            int offsetToCenter = ((totalWide - cpsWide) / 2);
+            surface()->DrawSetTextPos(offsetToCenter, cps_ypos);
+        }
+        else
+            surface()->DrawSetTextPos(cps_xpos, cps_ypos);
+
+        surface()->DrawPrintText(m_pwCurrentCheckpoints, wcslen(m_pwCurrentCheckpoints));
+    }
+
+    // MOM_TODO: Print this only if map gamemode is supported
+    if (center_stage)
+    {
+        int stageWide;
+        surface()->GetTextSize(m_hTextFont, m_pwCurrentStages, stageWide, dummy);
+        int offsetToCenter = ((totalWide - stageWide) / 2);
+        surface()->DrawSetTextPos(offsetToCenter, stage_ypos);
+    }
+    else
+        surface()->DrawSetTextPos(stage_xpos, stage_ypos);
+
+    surface()->DrawPrintText(m_pwCurrentStages, wcslen(m_pwCurrentStages));
+
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/Timer.cpp b/mp/src/game/server/momentum/Timer.cpp
new file mode 100644
index 000000000..b6e31a560
--- /dev/null
+++ b/mp/src/game/server/momentum/Timer.cpp
@@ -0,0 +1,490 @@
+#include "cbase.h"
+#include "Timer.h"
+
+#include "tier0/memdbgon.h"
+
+extern IFileSystem *filesystem;
+
+void CTimer::Start(int start)
+{
+    m_iStartTick = start;
+    SetRunning(true);
+    DispatchStateMessage();
+}
+
+void CTimer::PostTime()
+{
+    if (steamapicontext->SteamHTTP() && steamapicontext->SteamUser() && !m_bWereCheatsActivated)
+    {
+        //Get required info 
+        //MOM_TODO include the extra security measures for beta+
+        uint64 steamID = steamapicontext->SteamUser()->GetSteamID().ConvertToUint64();
+        const char* map = gpGlobals->mapname.ToCStr();
+        int ticks = gpGlobals->tickcount - m_iStartTick;
+
+        TickSet::Tickrate tickRate = TickSet::GetCurrentTickrate();
+
+        //Build URL
+        char webURL[512];
+        Q_snprintf(webURL, 512, "http://momentum-mod.org/postscore/%llu/%s/%i/%s", steamID, map,
+            ticks, tickRate.sType);
+
+        DevLog("Ticks sent to server: %i\n", ticks);
+
+        //Build request
+        mom_UTIL.PostTime(webURL);
+    }
+    else
+    {
+        Warning("Failed to post scores online: Cannot access STEAM HTTP or Steam User!\n");
+    }
+}
+
+////MOM_TODO: REMOVEME
+//CON_COMMAND(mom_test_hash, "Tests SHA1 Hashing\n")
+//{
+//    char pathToZone[MAX_PATH];
+//    char mapName[MAX_PATH];
+//    V_ComposeFileName("maps", gpGlobals->mapname.ToCStr(), mapName, MAX_PATH);
+//    Q_strncat(mapName, ".zon", MAX_PATH);
+//    filesystem->RelativePathToFullPath(mapName, "MOD", pathToZone, MAX_PATH);
+//    Log("File path is: %s\n", pathToZone);
+//
+//    CSHA1 sha1;
+//    sha1.HashFile(pathToZone);
+//    sha1.Final();
+//    unsigned char hash[20];
+//    sha1.GetHash(hash);
+//    Log("The hash for %s is: ", mapName);
+//    for (int i = 0; i < 20; i++)
+//    {
+//        Log("%02x", hash[i]);
+//    }
+//    Log("\n");
+//}
+
+//Called upon map load, loads any and all times stored in the <mapname>.tim file
+void CTimer::LoadLocalTimes(const char *szMapname)
+{
+    char timesFilePath[MAX_PATH];
+    Q_strcpy(timesFilePath, c_mapDir);
+    Q_strcat(timesFilePath, szMapname, MAX_PATH);
+    Q_strncat(timesFilePath, c_timesExt, MAX_PATH);
+    KeyValues *timesKV = new KeyValues(szMapname);
+    if (timesKV->LoadFromFile(filesystem, timesFilePath, "MOD"))
+    {
+        for (KeyValues *kv = timesKV->GetFirstSubKey(); kv; kv = kv->GetNextKey())
+        {
+            Time t;
+            t.ticks = Q_atoi(kv->GetName());
+            t.tickrate = kv->GetFloat("rate");
+            t.date = (time_t) kv->GetInt("date");
+            localTimes.AddToTail(t);
+        }
+    }
+    else
+    {
+        DevLog("Failed to load local times; no local file was able to be loaded!\n");
+    }
+    timesKV->deleteThis();
+}
+
+//Called every time a new time is achieved
+void CTimer::SaveTime()
+{
+    const char *szMapName = gpGlobals->mapname.ToCStr();
+    KeyValues *timesKV = new KeyValues(szMapName);
+    int count = localTimes.Count();
+
+    for (int i = 0; i < count; i++)
+    {
+        Time t = localTimes[i];
+        char timeName[512];
+        Q_snprintf(timeName, 512, "%i", t.ticks);
+        KeyValues *pSubkey = new KeyValues(timeName);
+        pSubkey->SetFloat("rate", t.tickrate);
+        pSubkey->SetInt("date", t.date);
+        timesKV->AddSubKey(pSubkey);
+    }
+
+    char file[MAX_PATH];
+    Q_strcpy(file, c_mapDir);
+    Q_strcat(file, szMapName, MAX_PATH);
+    Q_strncat(file, c_timesExt, MAX_PATH);
+
+    if (timesKV->SaveToFile(filesystem, file, "MOD", true))
+    {
+        Log("Successfully saved new time!\n");
+        IGameEvent *savedEvent = gameeventmanager->CreateEvent("runtime_saved");
+        if (savedEvent)
+            gameeventmanager->FireEvent(savedEvent);
+    }
+
+    timesKV->deleteThis();
+}
+
+void CTimer::Stop(bool endTrigger /* = false */)
+{
+    if (endTrigger && !m_bWereCheatsActivated)
+    {
+        // Post time to leaderboards if they're online
+        // and if cheats haven't been turned on this session
+        if (SteamAPI_IsSteamRunning())
+            PostTime();
+
+        //Save times locally too, regardless of SteamAPI condition
+        Time t;
+        t.ticks = gpGlobals->tickcount - m_iStartTick;
+        t.tickrate = gpGlobals->interval_per_tick;
+        time(&t.date);
+        localTimes.AddToTail(t);
+
+        SaveTime();
+    }
+    SetRunning(false);
+    DispatchStateMessage();
+}
+
+void CTimer::OnMapEnd(const char *pMapName)
+{
+    if (IsRunning())
+        Stop(false);
+    m_bWereCheatsActivated = false;
+    SetCurrentCheckpointTrigger(NULL);
+    SetStartTrigger(NULL);
+    SetCurrentStage(NULL);
+    RemoveAllCheckpoints();
+    localTimes.Purge();
+    //MOM_TODO: onlineTimes.RemoveAll();
+}
+
+void CTimer::OnMapStart(const char *pMapName)
+{
+    SetGameModeConVars();
+    m_bWereCheatsActivated = false;
+    RequestStageCount();
+    //DispatchMapStartMessage();
+    LoadLocalTimes(pMapName);
+    //MOM_TODO: g_Timer.LoadOnlineTimes();
+}
+
+void CTimer::RequestStageCount()
+{
+    CTriggerStage *stage = (CTriggerStage *) gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_stage");
+    int iCount = 1;//CTriggerStart counts as one
+    while (stage)
+    {
+        iCount++;
+        stage = (CTriggerStage *) gEntList.FindEntityByClassname(stage, "trigger_momentum_timer_stage");
+    }
+    m_iStageCount = iCount;
+}
+
+void CTimer::DispatchResetMessage()
+{
+    CSingleUserRecipientFilter user(UTIL_GetLocalPlayer());
+    user.MakeReliable();
+    UserMessageBegin(user, "Timer_Reset");
+    MessageEnd();
+}
+
+void CTimer::DispatchStageMessage()
+{
+    CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+    if (cPlayer && GetCurrentStage())
+    {
+        CSingleUserRecipientFilter user(cPlayer);
+        user.MakeReliable();
+        UserMessageBegin(user, "Timer_Stage");
+        WRITE_LONG(GetCurrentStage()->GetStageNumber());
+        MessageEnd();
+    }
+}
+
+void CTimer::DispatchStateMessage()
+{
+    CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+    if (cPlayer)
+    {
+        CSingleUserRecipientFilter user(cPlayer);
+        user.MakeReliable();
+        UserMessageBegin(user, "Timer_State");
+        WRITE_BOOL(m_bIsRunning);
+        WRITE_LONG(m_iStartTick);
+        MessageEnd();
+    }
+}
+
+void CTimer::DispatchCheckpointMessage()
+{
+    CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+    if (cPlayer)
+    {
+        CSingleUserRecipientFilter user(cPlayer);
+        user.MakeReliable();
+        UserMessageBegin(user, "Timer_Checkpoint");
+        WRITE_BOOL(m_bUsingCPMenu);
+        WRITE_LONG(m_iCurrentStepCP + 1);
+        WRITE_LONG(checkpoints.Count());
+        MessageEnd();
+    }
+}
+
+void CTimer::DispatchStageCountMessage()
+{
+    CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+    if (cPlayer)
+    {
+        CSingleUserRecipientFilter user(cPlayer);
+        user.MakeReliable();
+        UserMessageBegin(user, "Timer_StageCount");
+        WRITE_LONG(m_iStageCount);
+        MessageEnd();
+    }
+}
+
+CON_COMMAND_F(hud_timer_request_stages, "", FCVAR_DONTRECORD | FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_HIDDEN)
+{
+    g_Timer.DispatchStageCountMessage();
+}
+//set ConVars according to Gamemode. Tickrate is by in tickset.h
+void CTimer::SetGameModeConVars()
+{
+    ConVarRef gm("mom_gamemode");
+    ConVarRef aa("sv_airaccelerate");
+    switch (gm.GetInt())
+    {
+    case MOMGM_SURF:
+        sv_maxvelocity.SetValue(3500);
+        aa.SetValue(150);
+        break;
+    case MOMGM_BHOP:
+        sv_maxvelocity.SetValue(10000);
+        aa.SetValue(1000);
+        break;
+    case MOMGM_SCROLL:
+        sv_maxvelocity.SetValue(3500);
+        aa.SetValue(100);
+        break;
+    case MOMGM_UNKNOWN:
+    case MOMGM_ALLOWED:
+        sv_maxvelocity.SetValue(3500);
+        aa.SetValue(150);
+        break;
+    default:
+        DevWarning("[%i] GameMode not defined.\n", gm.GetInt());
+        break;
+    }
+    DevMsg("CTimer set ::\nsv_maxvelocity: %i\nsv_airaccelerate: %i", sv_maxvelocity.GetInt(), aa.GetInt());
+}
+//Practice mode that stops the timer and allows the player to noclip.
+void CTimer::EnablePractice(CBasePlayer *pPlayer)
+{
+    pPlayer->SetParent(NULL);
+    pPlayer->SetMoveType(MOVETYPE_NOCLIP);
+    ClientPrint(pPlayer, HUD_PRINTCONSOLE, "Practice mode on!\n");
+    pPlayer->AddEFlags(EFL_NOCLIP_ACTIVE);
+    g_Timer.Stop(false);
+}
+void CTimer::DisablePractice(CBasePlayer *pPlayer)
+{
+    pPlayer->RemoveEFlags(EFL_NOCLIP_ACTIVE);
+    ClientPrint(pPlayer, HUD_PRINTCONSOLE, "Practice mode OFF!\n");
+    pPlayer->SetMoveType(MOVETYPE_WALK);
+}
+bool CTimer::IsPracticeMode(CBaseEntity *pOther)
+{
+    return pOther->GetMoveType() == MOVETYPE_NOCLIP && (pOther->GetEFlags() & EFL_NOCLIP_ACTIVE);
+}
+//--------- CPMenu stuff --------------------------------
+
+void CTimer::CreateCheckpoint(CBasePlayer *pPlayer)
+{
+    if (!pPlayer) return;
+    Checkpoint c;
+    c.ang = pPlayer->GetAbsAngles();
+    c.pos = pPlayer->GetAbsOrigin();
+    c.vel = pPlayer->GetAbsVelocity();
+    checkpoints.AddToTail(c);
+    m_iCurrentStepCP++;
+}
+
+void CTimer::RemoveLastCheckpoint()
+{
+    if (checkpoints.IsEmpty()) return;
+    checkpoints.Remove(m_iCurrentStepCP);
+    m_iCurrentStepCP--;//If there's one element left, we still need to decrease currentStep to -1
+}
+
+void CTimer::TeleportToCP(CBasePlayer* cPlayer, int cpNum)
+{
+    if (checkpoints.IsEmpty() || !cPlayer) return;
+    Checkpoint c = checkpoints[cpNum];
+    cPlayer->Teleport(&c.pos, &c.ang, &c.vel);
+}
+
+void CTimer::SetUsingCPMenu(bool pIsUsingCPMenu)
+{
+    m_bUsingCPMenu = pIsUsingCPMenu;
+}
+
+void CTimer::SetCurrentCPMenuStep(int pNewNum)
+{
+    m_iCurrentStepCP = pNewNum;
+}
+
+//--------- CTriggerOnehop stuff --------------------------------
+
+int CTimer::AddOnehopToListTail(CTriggerOnehop *pTrigger)
+{
+    return onehops.AddToTail(pTrigger);
+}
+
+bool CTimer::RemoveOnehopFromList(CTriggerOnehop *pTrigger)
+{
+    return onehops.FindAndRemove(pTrigger);
+}
+
+int CTimer::FindOnehopOnList(CTriggerOnehop *pTrigger)
+{
+    return onehops.Find(pTrigger);
+}
+
+CTriggerOnehop *CTimer::FindOnehopOnList(int pIndexOnList)
+{
+    return onehops.Element(pIndexOnList);
+}
+
+//--------- Commands --------------------------------
+
+class CTimerCommands
+{
+public:
+    static void ResetToStart()
+    {
+        CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+        CTriggerTimerStart *start;
+        if ((start = g_Timer.GetStartTrigger()) != NULL && cPlayer)
+        {
+            // Don't set angles if still in start zone.
+            if (g_Timer.IsRunning() && start->GetHasLookAngles())
+            {
+                QAngle ang = start->GetLookAngles();
+
+                cPlayer->Teleport(&start->WorldSpaceCenter(), &ang, &vec3_origin);
+            }
+            else
+            {
+                cPlayer->Teleport(&start->WorldSpaceCenter(), NULL, &vec3_origin);
+            }
+        }
+    }
+
+    static void ResetToCheckpoint()
+    {
+        CTriggerStage *stage;
+        CBaseEntity* pPlayer = UTIL_GetLocalPlayer();
+        if ((stage = g_Timer.GetCurrentStage()) != NULL && pPlayer)
+        {
+            pPlayer->Teleport(&stage->WorldSpaceCenter(), NULL, &vec3_origin);
+        }
+    }
+
+    static void CPMenu(const CCommand &args)
+    {
+        if (!g_Timer.IsUsingCPMenu())
+            g_Timer.SetUsingCPMenu(true);
+
+        if (g_Timer.IsRunning())
+        {
+            // MOM_TODO: consider
+            // 1. having a local timer running, as people may want to time their routes they're using CP menu for
+            // 2. gamemodes (KZ) where this is allowed
+
+            ConVarRef gm("mom_gamemode");
+            switch (gm.GetInt())
+            {
+            case MOMGM_SURF:
+            case MOMGM_BHOP:
+            case MOMGM_SCROLL:
+                g_Timer.Stop(false);
+
+                //case MOMGM_KZ:
+            default:
+                break;
+            }
+        }
+        if (args.ArgC() > 1)
+        {
+            int sel = Q_atoi(args[1]);
+            CBasePlayer* cPlayer = UTIL_GetLocalPlayer();
+            switch (sel)
+            {
+            case 1://create a checkpoint
+                g_Timer.CreateCheckpoint(cPlayer);
+                break;
+
+            case 2://load previous checkpoint
+                g_Timer.TeleportToCP(cPlayer, g_Timer.GetCurrentCPMenuStep());
+                break;
+
+            case 3://cycle through checkpoints forwards (+1 % length)
+                if (g_Timer.GetCPCount() > 0)
+                {
+                    g_Timer.SetCurrentCPMenuStep((g_Timer.GetCurrentCPMenuStep() + 1) % g_Timer.GetCPCount());
+                    g_Timer.TeleportToCP(cPlayer, g_Timer.GetCurrentCPMenuStep());
+                }
+                break;
+
+            case 4://cycle backwards through checkpoints
+                if (g_Timer.GetCPCount() > 0)
+                {
+                    g_Timer.SetCurrentCPMenuStep(g_Timer.GetCurrentCPMenuStep() == 0 ? g_Timer.GetCPCount() - 1 : g_Timer.GetCurrentCPMenuStep() - 1);
+                    g_Timer.TeleportToCP(cPlayer, g_Timer.GetCurrentCPMenuStep());
+                }
+                break;
+
+            case 5://remove current checkpoint
+                g_Timer.RemoveLastCheckpoint();
+                break;
+            case 6://remove every checkpoint
+                g_Timer.RemoveAllCheckpoints();
+                break;
+            case 0://They closed the menu
+                g_Timer.SetUsingCPMenu(false);
+                break;
+            default:
+                if (cPlayer != NULL)
+                {
+                    cPlayer->EmitSound("Momentum.UIMissingMenuSelection");
+                }
+                break;
+            }
+        }
+        g_Timer.DispatchCheckpointMessage();
+    }
+
+    static void PracticeMove()
+    {
+        CBasePlayer *pPlayer = ToBasePlayer(UTIL_GetCommandClient());
+        if (!pPlayer)
+            return;
+        Vector velocity = pPlayer->GetAbsVelocity();
+
+        if (pPlayer->GetMoveType() != MOVETYPE_NOCLIP && velocity.Length2DSqr() == 0)
+            g_Timer.EnablePractice(pPlayer);
+        else //player is either already in practice mode or currently moving.
+            g_Timer.DisablePractice(pPlayer);
+    }
+};
+
+
+
+static ConCommand mom_practice("mom_practice", CTimerCommands::PracticeMove, "Toggle. Stops timer and allows player to fly around in noclip.\n",
+    FCVAR_CLIENTCMD_CAN_EXECUTE);
+static ConCommand mom_reset_to_start("mom_restart", CTimerCommands::ResetToStart, "Restarts the player to the start trigger.\n",
+    FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_SERVER_CAN_EXECUTE);
+static ConCommand mom_reset_to_checkpoint("mom_reset", CTimerCommands::ResetToCheckpoint, "Teleports the player back to the start of the current stage.\n",
+    FCVAR_CLIENTCMD_CAN_EXECUTE | FCVAR_SERVER_CAN_EXECUTE);
+static ConCommand mom_cpmenu("cpmenu", CTimerCommands::CPMenu, "", FCVAR_HIDDEN | FCVAR_SERVER_CAN_EXECUTE);
+CTimer g_Timer;
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/Timer.h b/mp/src/game/server/momentum/Timer.h
new file mode 100644
index 000000000..ed5fb7125
--- /dev/null
+++ b/mp/src/game/server/momentum/Timer.h
@@ -0,0 +1,189 @@
+#ifndef TIMER_H
+#define TIMER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "utlvector.h"
+#include "momentum/tickset.h"
+#include "KeyValues.h"
+#include "momentum/util/mom_util.h"
+#include "filesystem.h"
+#include "mom_triggers.h"
+#include "GameEventListener.h"
+#include "tier1/checksum_sha1.h"
+#include "momentum/mom_shareddefs.h"
+#include "momentum/mom_gamerules.h"
+#include "movevars_shared.h"
+#include <ctime>
+
+class CTriggerTimerStart;
+class CTriggerCheckpoint;
+class CTriggerOnehop;
+class CTriggerStage;
+
+class CTimer
+{
+public:
+
+    //-------- HUD Messages --------------------
+    void DispatchStateMessage();
+    void DispatchResetMessage();
+    void DispatchCheckpointMessage();
+    void DispatchStageMessage();
+    void DispatchStageCountMessage();
+
+
+    // ------------- Timer state related messages --------------------------
+    // Strats the timer for the given starting tick
+    void Start(int startTick);
+    // Stops the timer
+    void Stop(bool = false);
+    // Is the timer running?
+    bool IsRunning() { return m_bIsRunning; }
+    // Set the running status of the timer
+    void SetRunning(bool running) { m_bIsRunning = running; }
+
+    // ------------- Timer trigger related methods ----------------------------
+    // Gets the current starting trigger
+    CTriggerTimerStart *GetStartTrigger() { return m_pStartTrigger.Get(); }
+    // Gets the current checkpoint
+    CTriggerCheckpoint *GetCurrentCheckpoint() { return m_pCurrentCheckpoint.Get(); }
+
+    // Sets the given trigger as the start trigger
+    void SetStartTrigger(CTriggerTimerStart *pTrigger) { m_pStartTrigger.Set(pTrigger); }
+
+    // Sets the current checkpoint
+    void SetCurrentCheckpointTrigger(CTriggerCheckpoint *pTrigger) { m_pCurrentCheckpoint.Set(pTrigger); }
+
+    void SetCurrentStage(CTriggerStage *pTrigger)
+    {
+        m_pCurrentStage.Set(pTrigger);
+        DispatchStageMessage();
+    }
+    CTriggerStage *GetCurrentStage() { return m_pCurrentStage.Get(); }
+
+    // Calculates the stage count
+    // Stores the result on m_iStageCount
+    void RequestStageCount();
+    // Gets the total stage count
+    int GetStageCount() { return m_iStageCount; };
+
+    //--------- CheckpointMenu stuff --------------------------------
+    // Gets the current menu checkpoint index
+    int GetCurrentCPMenuStep() { return m_iCurrentStepCP; }
+    // MOM_TODO: For leaderboard use later on
+    bool IsUsingCPMenu() { return m_bUsingCPMenu; }
+    // Creates a checkpoint (menu) on the location of the given Entity
+    void CreateCheckpoint(CBasePlayer*);
+    // Removes last checkpoint (menu) form the checkpoint lists
+    void RemoveLastCheckpoint();
+    // Removes every checkpoint (menu) on the checkpoint list
+    void RemoveAllCheckpoints()
+    {
+        checkpoints.RemoveAll();
+        m_iCurrentStepCP = -1;
+        //SetUsingCPMenu(false);
+        DispatchCheckpointMessage();
+    }
+    // Teleports the entity to the checkpoint (menu) with the given index
+    void TeleportToCP(CBasePlayer*, int);
+    // Sets the current checkpoint (menu) to the desired one with that index
+    void SetCurrentCPMenuStep(int pNewNum);
+    // Gets the total amount of menu checkpoints
+    int GetCPCount() { return checkpoints.Size(); }
+    // Sets wheter or not we're using the CPMenu
+    // WARNING! No verification is done. It is up to the caller to don't give false information
+    void SetUsingCPMenu(bool pIsUsingCPMenu);
+
+    //----- Trigger_Onehop stuff -----------------------------------------
+    // Removes the given Onehop form the hopped list.
+    // Returns: True if deleted, False if not found.
+    bool RemoveOnehopFromList(CTriggerOnehop* pTrigger);
+    // Adds the give Onehop to the hopped list.
+    // Returns: Its new index.
+    int AddOnehopToListTail(CTriggerOnehop* pTrigger);
+    // Finds a Onehop on the hopped list.
+    // Returns: Its index. -1 if not found
+    int FindOnehopOnList(CTriggerOnehop* pTrigger);
+    // Removes all onehops from the list
+    void RemoveAllOnehopsFromList() { onehops.RemoveAll(); }
+    // Returns the count for the onehop list
+    int GetOnehopListCount() { return onehops.Count(); }
+    // Finds the onehop with the given index on the list
+    CTriggerOnehop* FindOnehopOnList(int pIndexOnList);
+
+
+    //-------- Online-related timer commands -----------------------------
+    // Tries to post the current time.
+    void PostTime();
+    //MOM_TODO: void LoadOnlineTimes();
+
+
+    //------- Local-related timer commands -------------------------------
+    // Loads local times from given map name
+    void LoadLocalTimes(const char*);
+    // Saves current time to a local file
+    void SaveTime();
+    void OnMapEnd(const char *);
+    void OnMapStart(const char *);
+
+    // Practice mode- noclip mode that stops timer
+    void PracticeMove();
+    void EnablePractice(CBasePlayer *pPlayer);
+    void DisablePractice(CBasePlayer *pPlayer);
+    bool IsPracticeMode(CBaseEntity *pOther);
+
+    // Have the cheats been turned on in this session?
+    bool GotCaughtCheating() { return m_bWereCheatsActivated; };
+    void SetCheating(bool newBool)
+    {
+        UTIL_ShowMessage("CHEATER", UTIL_GetLocalPlayer());
+        Stop(false);
+        m_bWereCheatsActivated = newBool;
+    }
+
+    void SetGameModeConVars();
+
+private:
+
+    int m_iStageCount;
+    int m_iStartTick;
+    bool m_bIsRunning;
+    bool m_bWereCheatsActivated;
+    CHandle<CTriggerTimerStart> m_pStartTrigger;
+    CHandle<CTriggerCheckpoint> m_pCurrentCheckpoint;
+    CHandle<CTriggerStage> m_pCurrentStage;
+
+    struct Time
+    {
+        //The amount of ticks took to complete
+        int ticks;
+        //Tickrate the run was done on
+        float tickrate;
+        //Date achieved
+        time_t date;
+    };
+
+    struct Checkpoint
+    {
+        Vector pos;
+        Vector vel;
+        QAngle ang;
+    };
+    CUtlVector<Checkpoint> checkpoints;
+    CUtlVector<CTriggerOnehop*> onehops;
+    CUtlVector<Time> localTimes;
+    //MOM_TODO: CUtlVector<OnlineTime> onlineTimes;
+
+    int m_iCurrentStepCP = 0;
+    bool m_bUsingCPMenu = false;
+
+    const char* c_mapDir = "maps/";
+    // Extension used for storing local map times
+    const char* c_timesExt = ".tim";
+};
+
+extern CTimer g_Timer;
+
+#endif // TIMER_H
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/flashbang_projectile.cpp b/mp/src/game/server/momentum/flashbang_projectile.cpp
new file mode 100644
index 000000000..4df098b06
--- /dev/null
+++ b/mp/src/game/server/momentum/flashbang_projectile.cpp
@@ -0,0 +1,314 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "flashbang_projectile.h"
+#include "shake.h"
+#include "engine/IEngineSound.h"
+#include "mom_player.h"
+#include "dlight.h"
+#include "KeyValues.h"
+
+#include "tier0/memdbgon.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_flashbang_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS(flashbang_projectile, CFlashbangProjectile);
+PRECACHE_WEAPON_REGISTER(flashbang_projectile);
+
+float PercentageOfFlashForPlayer(CBaseEntity *player, Vector flashPos, CBaseEntity *pevInflictor)
+{
+    float retval = 0.0f;
+
+    trace_t tr;
+
+    Vector pos = player->EyePosition();
+    Vector vecRight, vecUp;
+
+    QAngle tempAngle;
+    VectorAngles(player->EyePosition() - flashPos, tempAngle);
+    AngleVectors(tempAngle, NULL, &vecRight, &vecUp);
+
+    vecRight.NormalizeInPlace();
+    vecUp.NormalizeInPlace();
+
+    UTIL_TraceLine(flashPos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    if ((tr.fraction == 1.0) || (tr.m_pEnt == player))
+    {
+        return 1.0;
+    }
+
+    if (!(player->IsPlayer()))
+    {
+        // if this entity isn't a player, it's a hostage or some other entity, then don't bother with the expensive checks
+        // that come below.
+        return 0.0;
+    }
+
+    // check the point straight up.
+    pos = flashPos + vecUp * 50;
+
+    UTIL_TraceLine(flashPos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    pos = player->EyePosition();
+
+    UTIL_TraceLine(tr.endpos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    if ((tr.fraction == 1.0) || (tr.m_pEnt == player))
+    {
+        retval += 0.167;
+    }
+
+    // check the point up and right.
+    pos = flashPos + vecRight * 75 + vecUp * 10;
+
+    UTIL_TraceLine(flashPos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    pos = player->EyePosition();
+
+    UTIL_TraceLine(tr.endpos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    if ((tr.fraction == 1.0) || (tr.m_pEnt == player))
+    {
+        retval += 0.167;
+    }
+
+    pos = flashPos - vecRight * 75 + vecUp * 10;
+
+    UTIL_TraceLine(flashPos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    pos = player->EyePosition();
+
+    UTIL_TraceLine(tr.endpos, pos,
+        (CONTENTS_SOLID | CONTENTS_MOVEABLE | CONTENTS_DEBRIS | CONTENTS_MONSTER),
+        pevInflictor, COLLISION_GROUP_NONE, &tr);
+
+    if ((tr.fraction == 1.0) || (tr.m_pEnt == player))
+    {
+        retval += 0.167;
+    }
+
+    return retval;
+}
+
+// --------------------------------------------------------------------------------------------------- //
+//
+// RadiusDamage - this entity is exploding, or otherwise needs to inflict damage upon entities within a certain range.
+// 
+// only damage ents that can clearly be seen by the explosion!
+// --------------------------------------------------------------------------------------------------- //
+
+void RadiusFlash(
+    Vector vecSrc,
+    CBaseEntity *pevInflictor,
+    CBaseEntity *pevAttacker,
+    float flDamage,
+    int iClassIgnore,
+    int bitsDamageType)
+{
+    vecSrc.z += 1;// in case grenade is lying on the ground
+
+    if (!pevAttacker)
+        pevAttacker = pevInflictor;
+
+    trace_t		tr;
+    float		flAdjustedDamage;
+    variant_t	var;
+    Vector		vecEyePos;
+    float		fadeTime, fadeHold;
+    Vector		vForward;
+    Vector		vecLOS;
+    float		flDot;
+
+    CBaseEntity		*pEntity = NULL;
+    static float	flRadius = 1500;
+    float			falloff = flDamage / flRadius;
+
+    bool bInWater = (UTIL_PointContents(vecSrc) == CONTENTS_WATER);
+
+    // iterate on all entities in the vicinity.
+    while ((pEntity = gEntList.FindEntityInSphere(pEntity, vecSrc, flRadius)) != NULL)
+    {
+        bool bPlayer = pEntity->IsPlayer();
+        bool bHostage = (Q_stricmp(pEntity->GetClassname(), "hostage_entity") == 0);
+
+        if (!bPlayer && !bHostage)
+            continue;
+
+        vecEyePos = pEntity->EyePosition();
+
+        // blasts don't travel into or out of water
+        if (bInWater && pEntity->GetWaterLevel() == 0)
+            continue;
+        if (!bInWater && pEntity->GetWaterLevel() == 3)
+            continue;
+
+        float percentageOfFlash = PercentageOfFlashForPlayer(pEntity, vecSrc, pevInflictor);
+
+        if (percentageOfFlash > 0.0)
+        {
+            // decrease damage for an ent that's farther from the grenade
+            flAdjustedDamage = flDamage - (vecSrc - pEntity->EyePosition()).Length() * falloff;
+
+            if (flAdjustedDamage > 0)
+            {
+                // See if we were facing the flash
+                AngleVectors(pEntity->EyeAngles(), &vForward);
+
+                vecLOS = (vecSrc - vecEyePos);
+
+                //float flDistance = vecLOS.Length();
+
+                // Normalize both vectors so the dotproduct is in the range -1.0 <= x <= 1.0 
+                vecLOS.NormalizeInPlace();
+
+                flDot = DotProduct(vecLOS, vForward);
+
+                float startingAlpha = 255;
+
+                // if target is facing the bomb, the effect lasts longer
+                if (flDot >= 0.5)
+                {
+                    // looking at the flashbang
+                    fadeTime = flAdjustedDamage * 2.5f;
+                    fadeHold = flAdjustedDamage * 1.25f;
+                }
+                else if (flDot >= -0.5)
+                {
+                    // looking to the side
+                    fadeTime = flAdjustedDamage * 1.75f;
+                    fadeHold = flAdjustedDamage * 0.8f;
+                }
+                else
+                {
+                    // facing away
+                    fadeTime = flAdjustedDamage * 1.0f;
+                    fadeHold = flAdjustedDamage * 0.75f;
+                    startingAlpha = 200;
+                }
+
+                fadeTime *= percentageOfFlash;
+                fadeHold *= percentageOfFlash;
+
+                if (bPlayer)
+                {
+                    //MOM_TODO: do we want this functionality?
+                    // blind players and bots
+                    //CMomentumPlayer *player = static_cast<CMomentumPlayer *>(pEntity);
+                    //player->Blind( fadeHold, fadeTime, startingAlpha );
+
+                    // deafen players and bots
+                    //player->Deafen( flDistance );
+                }
+                else if (bHostage)
+                {
+                    variant_t val;
+                    val.SetFloat(fadeTime);
+                    pEntity->AcceptInput("flashbang", pevInflictor, pevAttacker, val, 0);
+                }
+            }
+        }
+    }
+
+    CPVSFilter filter(vecSrc);
+    te->DynamicLight(filter, 0.0, &vecSrc, 255, 255, 255, 2, 400, 0.1, 768);
+}
+
+// --------------------------------------------------------------------------------------------------- //
+// CFlashbangProjectile implementation.
+// --------------------------------------------------------------------------------------------------- //
+
+CFlashbangProjectile* CFlashbangProjectile::Create(
+    const Vector &position,
+    const QAngle &angles,
+    const Vector &velocity,
+    const AngularImpulse &angVelocity,
+    CBaseCombatCharacter *pOwner)
+{
+    CFlashbangProjectile *pGrenade = (CFlashbangProjectile*) CBaseEntity::Create("flashbang_projectile", position, angles, pOwner);
+
+    // Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+    // one second before detonation.
+    pGrenade->SetAbsVelocity(velocity);
+    pGrenade->SetupInitialTransmittedGrenadeVelocity(velocity);
+    pGrenade->SetThrower(pOwner);
+    pGrenade->m_flDamage = 100;
+    pGrenade->ChangeTeam(pOwner->GetTeamNumber());
+
+    pGrenade->SetTouch(&CBaseGrenade::BounceTouch);
+
+    pGrenade->SetThink(&CBaseCSGrenadeProjectile::DangerSoundThink);
+    pGrenade->SetNextThink(gpGlobals->curtime);
+
+    pGrenade->SetDetonateTimerLength(1.5);
+
+    pGrenade->ApplyLocalAngularVelocityImpulse(angVelocity);
+
+    pGrenade->SetGravity(BaseClass::GetGrenadeGravity());
+    pGrenade->SetFriction(BaseClass::GetGrenadeFriction());
+    pGrenade->SetElasticity(BaseClass::GetGrenadeElasticity());
+
+    return pGrenade;
+}
+
+void CFlashbangProjectile::Spawn()
+{
+    SetModel(GRENADE_MODEL);
+    BaseClass::Spawn();
+}
+
+void CFlashbangProjectile::Precache()
+{
+    PrecacheModel(GRENADE_MODEL);
+
+    PrecacheScriptSound("Flashbang.Explode");
+    PrecacheScriptSound("Flashbang.Bounce");
+
+    BaseClass::Precache();
+}
+
+void CFlashbangProjectile::Detonate()
+{
+    RadiusFlash(GetAbsOrigin(), this, GetThrower(), 4, CLASS_NONE, DMG_BLAST);
+    EmitSound("Flashbang.Explode");
+
+    // tell the bots a flashbang grenade has exploded
+    CMomentumPlayer *player = static_cast<CMomentumPlayer*>(GetThrower());
+    if (player)
+    {
+        IGameEvent * event = gameeventmanager->CreateEvent("flashbang_detonate");
+        if (event)
+        {
+            event->SetInt("userid", player->GetUserID());
+            event->SetFloat("x", GetAbsOrigin().x);
+            event->SetFloat("y", GetAbsOrigin().y);
+            event->SetFloat("z", GetAbsOrigin().z);
+            gameeventmanager->FireEvent(event);
+        }
+    }
+
+    UTIL_Remove(this);
+}
+
+//TODO: Let physics handle the sound!
+void CFlashbangProjectile::BounceSound(void)
+{
+    EmitSound("Flashbang.Bounce");
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/flashbang_projectile.h b/mp/src/game/server/momentum/flashbang_projectile.h
new file mode 100644
index 000000000..1229560dd
--- /dev/null
+++ b/mp/src/game/server/momentum/flashbang_projectile.h
@@ -0,0 +1,39 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "momentum/basecsgrenade_projectile.h"
+
+
+class CFlashbangProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CFlashbangProjectile, CBaseCSGrenadeProjectile );
+
+// Overrides.
+public:
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void BounceSound( void );
+	virtual void Detonate();
+
+// Grenade stuff.
+	static CFlashbangProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner );	
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/mp/src/game/server/momentum/hegrenade_projectile.cpp b/mp/src/game/server/momentum/hegrenade_projectile.cpp
new file mode 100644
index 000000000..d69eb0781
--- /dev/null
+++ b/mp/src/game/server/momentum/hegrenade_projectile.cpp
@@ -0,0 +1,93 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#ifndef CLIENT_DLL
+#include "hegrenade_projectile.h"
+#include "soundent.h"
+#include "mom_player.h"
+#include "KeyValues.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_fraggrenade_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS( hegrenade_projectile, CHEGrenadeProjectile );
+PRECACHE_WEAPON_REGISTER( hegrenade_projectile );
+
+CHEGrenadeProjectile* CHEGrenadeProjectile::Create( 
+    const Vector &position, 
+    const QAngle &angles, 
+    const Vector &velocity, 
+    const AngularImpulse &angVelocity, 
+    CBaseCombatCharacter *pOwner, 
+    float timer )
+{
+    CHEGrenadeProjectile *pGrenade = (CHEGrenadeProjectile*)CBaseEntity::Create( "hegrenade_projectile", position, angles, pOwner );
+
+    // Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+    // one second before detonation.
+
+    pGrenade->SetDetonateTimerLength( 1.5 );
+    pGrenade->SetAbsVelocity( velocity );
+    pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
+    pGrenade->SetThrower( pOwner ); 
+
+    pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
+    pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
+    pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
+
+    pGrenade->m_flDamage = 100;
+    pGrenade->m_DmgRadius = pGrenade->m_flDamage * 3.5f;
+    pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+    pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );	
+
+    // make NPCs afaid of it while in the air
+    pGrenade->SetThink( &CHEGrenadeProjectile::DangerSoundThink );
+    pGrenade->SetNextThink( gpGlobals->curtime );
+
+    return pGrenade;
+}
+
+void CHEGrenadeProjectile::Spawn()
+{
+    SetModel( GRENADE_MODEL );
+    BaseClass::Spawn();
+}
+
+void CHEGrenadeProjectile::Precache()
+{
+    PrecacheModel( GRENADE_MODEL );
+
+    PrecacheScriptSound( "HEGrenade.Bounce" );
+
+    BaseClass::Precache();
+}
+
+void CHEGrenadeProjectile::BounceSound( void )
+{
+    EmitSound( "HEGrenade.Bounce" );
+}
+
+void CHEGrenadeProjectile::Detonate()
+{
+    BaseClass::Detonate();
+
+    // tell the bots an HE grenade has exploded
+    CMomentumPlayer *player = static_cast<CMomentumPlayer*>(GetThrower());
+    if ( player )
+    {
+        IGameEvent * event = gameeventmanager->CreateEvent( "hegrenade_detonate" );
+        if ( event )
+        {
+            event->SetInt( "userid", player->GetUserID() );
+            event->SetFloat( "x", GetAbsOrigin().x );
+            event->SetFloat( "y", GetAbsOrigin().y );
+            event->SetFloat( "z", GetAbsOrigin().z );
+            gameeventmanager->FireEvent( event );
+        }
+    }
+}
+#endif // CLIENT_DLL
diff --git a/mp/src/game/server/momentum/hegrenade_projectile.h b/mp/src/game/server/momentum/hegrenade_projectile.h
new file mode 100644
index 000000000..0c6428621
--- /dev/null
+++ b/mp/src/game/server/momentum/hegrenade_projectile.h
@@ -0,0 +1,46 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "momentum/basecsgrenade_projectile.h"
+
+class CHEGrenadeProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CHEGrenadeProjectile, CBaseCSGrenadeProjectile );
+
+
+// Overrides.
+public:
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void BounceSound( void );
+	virtual void Detonate();
+
+// Grenade stuff.
+public:
+
+	static CHEGrenadeProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner, 
+		float timer );
+
+	void SetTimer( float timer );
+
+private:
+	float m_flDetonateTime;
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/mp/src/game/server/momentum/mapzones.cpp b/mp/src/game/server/momentum/mapzones.cpp
new file mode 100644
index 000000000..09532e4cd
--- /dev/null
+++ b/mp/src/game/server/momentum/mapzones.cpp
@@ -0,0 +1,461 @@
+#include "cbase.h"
+#include "mapzones.h"
+#include "Timer.h"
+#include "filesystem.h"
+#include "KeyValues.h"
+#include "mom_triggers.h"
+
+#include "tier0/memdbgon.h"
+
+
+#define NO_LOOK -190.0f
+
+CMapzone::~CMapzone()
+{
+    if (m_pos)
+    {
+        delete m_pos;
+        m_pos = NULL;
+    }
+    if (m_rot)
+    {
+        delete m_rot;
+        m_rot = NULL;
+    }
+    if (m_scaleMins)
+    {
+        delete m_scaleMins;
+        m_scaleMins = NULL;
+    }
+    if (m_scaleMaxs)
+    {
+        delete m_scaleMaxs;
+        m_scaleMaxs = NULL;
+    }
+}
+
+CMapzone::CMapzone(const int pType, Vector* pPos, QAngle* pRot, Vector* pScaleMins,
+    Vector* pScaleMaxs, const int pIndex, const bool pShouldStop, const bool pShouldTilt,
+    const float pHoldTime, const bool pLimitSpeed,
+    const float pMaxLeaveSpeed, const float flYaw,
+    const string_t pLinkedEnt, const bool pCheckOnlyXY)
+{
+    m_type = pType;
+    m_pos = pPos;
+    m_rot = pRot;
+    m_scaleMins = pScaleMins;
+    m_scaleMaxs = pScaleMaxs;
+    m_index = pIndex;
+    m_shouldStopOnTeleport = pShouldStop;
+    m_shouldResetAngles = pShouldTilt;
+    m_holdTimeBeforeTeleport = pHoldTime;
+    m_limitingspeed = pLimitSpeed;
+    m_maxleavespeed = pMaxLeaveSpeed;
+    m_yaw = flYaw;
+    m_linkedent = pLinkedEnt;
+    m_onlyxycheck = pCheckOnlyXY;
+}
+
+void CMapzone::SpawnZone()
+{
+    switch (m_type)
+    {
+    case MOMZONETYPE_START:
+        m_trigger = (CTriggerTimerStart *) CreateEntityByName("trigger_momentum_timer_start");
+        ((CTriggerTimerStart *) m_trigger)->SetIsLimitingSpeed(m_limitingspeed);
+        ((CTriggerTimerStart *) m_trigger)->SetMaxLeaveSpeed(m_maxleavespeed);
+        ((CTriggerTimerStart *) m_trigger)->SetIsLimitingSpeedOnlyXY(m_onlyxycheck);
+        if ( m_yaw != NO_LOOK )
+        {
+            ((CTriggerTimerStart *) m_trigger)->SetHasLookAngles(true);
+            ((CTriggerTimerStart *) m_trigger)->SetLookAngles(QAngle( 0, m_yaw, 0 ));
+        }
+        else
+        {
+            ((CTriggerTimerStart *) m_trigger)->SetHasLookAngles(false);
+        }
+        
+        m_trigger->SetName(MAKE_STRING("Start Trigger"));
+        g_Timer.SetStartTrigger((CTriggerTimerStart *) m_trigger);
+        break;
+    case MOMZONETYPE_CP:
+        m_trigger = (CTriggerCheckpoint *) CreateEntityByName("trigger_momentum_timer_checkpoint");
+        m_trigger->SetName(MAKE_STRING("Checkpoint Trigger"));
+        ((CTriggerCheckpoint *) m_trigger)->SetCheckpointNumber(m_index);
+        break;
+    case MOMZONETYPE_STOP:
+        m_trigger = (CTriggerTimerStop *) CreateEntityByName("trigger_momentum_timer_stop");
+        m_trigger->SetName(MAKE_STRING("Ending Trigger"));
+        break;
+    case MOMZONETYPE_ONEHOP:
+        m_trigger = (CTriggerOnehop *) CreateEntityByName("trigger_momentum_onehop");
+        m_trigger->SetName(MAKE_STRING("Onehop Trigger"));
+        m_trigger->m_target = m_linkedent;
+        //((CTriggerOnehop *) m_trigger)->SetDestinationIndex(m_destinationIndex);
+        //((CTriggerOnehop *) m_trigger)->SetDestinationName(m_linkedtrigger);
+        ((CTriggerOnehop *) m_trigger)->SetHoldTeleportTime(m_holdTimeBeforeTeleport);
+        ((CTriggerOnehop *) m_trigger)->SetShouldStopPlayer(m_shouldStopOnTeleport);
+        ((CTriggerOnehop *) m_trigger)->SetShouldResetAngles(m_shouldResetAngles);
+        break;
+    case MOMZONETYPE_RESETONEHOP:
+        m_trigger = (CTriggerResetOnehop *) CreateEntityByName("trigger_momentum_resetonehop");
+        m_trigger->SetName(MAKE_STRING("ResetOnehop Trigger"));
+        break;
+    case MOMZONETYPE_CPTELE:
+        m_trigger = (CTriggerTeleportCheckpoint *) CreateEntityByName("trigger_momentum_teleport_checkpoint");
+        m_trigger->SetName(MAKE_STRING("TeleportToCheckpoint Trigger"));
+        m_trigger->m_target = m_linkedent;
+        //((CTriggerTeleportCheckpoint *)m_trigger)->SetDestinationCheckpointNumber(m_destinationIndex);
+        //((CTriggerTeleportCheckpoint *)m_trigger)->SetDestinationCheckpointName(m_linkedtrigger);
+        ((CTriggerTeleportCheckpoint *) m_trigger)->SetShouldStopPlayer(m_shouldStopOnTeleport);
+        ((CTriggerTeleportCheckpoint *) m_trigger)->SetShouldResetAngles(m_shouldResetAngles);
+        break;
+    case MOMZONETYPE_MULTIHOP:
+        m_trigger = (CTriggerOnehop *) CreateEntityByName("trigger_momentum_onehop");
+        m_trigger->SetName(MAKE_STRING("Onehop Trigger"));
+        m_trigger->m_target = m_linkedent;
+        //((CTriggerMultihop *) m_trigger)->SetDestinationIndex(m_destinationIndex);
+        //((CTriggerMultihop *) m_trigger)->SetDestinationName(m_linkedent);
+        ((CTriggerMultihop *) m_trigger)->SetHoldTeleportTime(m_holdTimeBeforeTeleport);
+        ((CTriggerMultihop *) m_trigger)->SetShouldStopPlayer(m_shouldStopOnTeleport);
+        ((CTriggerMultihop *) m_trigger)->SetShouldResetAngles(m_shouldResetAngles);
+        break;
+    case MOMZONETYPE_STAGE:
+        m_trigger = (CTriggerStage *) CreateEntityByName("trigger_momentum_timer_stage");
+        m_trigger->SetName(MAKE_STRING("Stage Trigger"));
+        ((CTriggerStage *) m_trigger)->SetStageNumber(m_index);
+        break;
+        //MOM_TODO: add trigger_momentum_teleport, and momentum_trigger_userinput
+    default:
+        break;
+    }
+
+    if (m_trigger)
+    {
+        m_trigger->Spawn();
+        m_trigger->Activate();
+        m_trigger->SetAbsOrigin(*m_pos);
+        m_trigger->SetSize(*m_scaleMins, *m_scaleMaxs);
+        m_trigger->SetAbsAngles(*m_rot);
+        m_trigger->SetSolid(SOLID_BBOX);
+    }
+}
+
+static void saveZonFile(const char* szMapName)
+{
+    KeyValues* zoneKV = new KeyValues(szMapName);
+    CBaseEntity* pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_*");
+    while (pEnt)
+    {
+        KeyValues* subKey = NULL;
+        if (pEnt->ClassMatches("trigger_momentum_timer_start"))
+        {
+            CTriggerTimerStart* pTrigger = dynamic_cast<CTriggerTimerStart*>(pEnt);
+            subKey = new KeyValues("start");
+            if (pTrigger)
+            {
+                subKey->SetFloat("leavespeed", pTrigger->GetMaxLeaveSpeed());
+                subKey->SetBool("limitingspeed", pTrigger->IsLimitingSpeed());
+                subKey->SetBool("onlyxy", pTrigger->IsLimitingSpeedOnlyXY());
+                if (pTrigger->GetHasLookAngles())
+                    subKey->SetFloat("yaw", pTrigger->GetLookAngles()[YAW] );
+            }
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_timer_stop"))
+        {
+            subKey = new KeyValues("end");
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_timer_checkpoint"))
+        {
+            CTriggerCheckpoint* pTrigger = dynamic_cast<CTriggerCheckpoint*>(pEnt);
+            if (pTrigger)
+            {
+                subKey = new KeyValues("checkpoint");
+                subKey->SetInt("number", pTrigger->GetCheckpointNumber());
+            }
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_onehop"))
+        {
+            CTriggerOnehop* pTrigger = dynamic_cast<CTriggerOnehop*>(pEnt);
+            if (pTrigger)
+            {
+                subKey = new KeyValues("onehop");
+                //subKey->SetInt("destination", pTrigger->GetDestinationIndex());
+                subKey->SetBool("stop", pTrigger->ShouldStopPlayer());
+                subKey->SetBool("resetang", pTrigger->ShouldResetAngles());
+                subKey->SetFloat("hold", pTrigger->GetHoldTeleportTime());
+                subKey->SetString("destinationname", pTrigger->m_target.ToCStr());
+            }
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_resetonehop"))
+        {
+            subKey = new KeyValues("resetonehop");
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_teleport_checkpoint"))
+        {
+
+            CTriggerTeleportCheckpoint* pTrigger = dynamic_cast<CTriggerTeleportCheckpoint*>(pEnt);
+            if (pTrigger)
+            {
+                subKey = new KeyValues("checkpoint_teleport");
+                //subKey->SetInt("destination", pTrigger->GetDestinationCheckpointNumber());
+                subKey->SetBool("stop", pTrigger->ShouldStopPlayer());
+                subKey->SetBool("resetang", pTrigger->ShouldResetAngles());
+                subKey->SetString("destinationname", pTrigger->m_target.ToCStr());
+            }
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_multihop"))
+        {
+            CTriggerMultihop* pTrigger = dynamic_cast<CTriggerMultihop*>(pEnt);
+            if (pTrigger)
+            {
+                subKey = new KeyValues("multihop");
+                //subKey->SetInt("destination", pTrigger->GetDestinationIndex());
+                subKey->SetBool("stop", pTrigger->ShouldStopPlayer());
+                subKey->SetFloat("hold", pTrigger->GetHoldTeleportTime());
+                subKey->SetBool("resetang", pTrigger->ShouldResetAngles());
+                subKey->SetString("destinationname", pTrigger->m_target.ToCStr());
+            }
+        }
+        else if (pEnt->ClassMatches("trigger_momentum_timer_stage"))
+        {
+            CTriggerStage *pTrigger = dynamic_cast<CTriggerStage*>(pEnt);
+            if (pTrigger)
+            {
+                subKey = new KeyValues("stage");
+                subKey->SetInt("number", pTrigger->GetStageNumber());
+            }
+        }
+        if (subKey)
+        {
+            subKey->SetFloat("xPos", pEnt->GetAbsOrigin().x);
+            subKey->SetFloat("yPos", pEnt->GetAbsOrigin().y);
+            subKey->SetFloat("zPos", pEnt->GetAbsOrigin().z);
+            subKey->SetFloat("xRot", pEnt->GetAbsAngles().x);
+            subKey->SetFloat("yRot", pEnt->GetAbsAngles().y);
+            subKey->SetFloat("zRot", pEnt->GetAbsAngles().z);
+            subKey->SetFloat("xScaleMins", pEnt->WorldAlignMins().x);
+            subKey->SetFloat("yScaleMins", pEnt->WorldAlignMins().y);
+            subKey->SetFloat("zScaleMins", pEnt->WorldAlignMins().z);
+            subKey->SetFloat("xScaleMaxs", pEnt->WorldAlignMaxs().x);
+            subKey->SetFloat("yScaleMaxs", pEnt->WorldAlignMaxs().y);
+            subKey->SetFloat("zScaleMaxs", pEnt->WorldAlignMaxs().z);
+            zoneKV->AddSubKey(subKey);
+        }
+        pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_*");
+    }
+    if (zoneKV->GetFirstSubKey())//not empty 
+    {
+        char zoneFilePath[MAX_PATH];
+        Q_strcpy(zoneFilePath, "maps/");
+        Q_strcat(zoneFilePath, szMapName, MAX_PATH);
+        Q_strncat(zoneFilePath, ".zon", MAX_PATH);
+        zoneKV->SaveToFile(filesystem, zoneFilePath, "MOD");
+        zoneKV->deleteThis();
+    }
+}
+
+CMapzoneData::CMapzoneData(const char *szMapName)
+{
+    if (!LoadFromFile(szMapName))
+    {
+        Log("Unable to find map zones! Trying to create them...\n");
+        saveZonFile(szMapName);//try making the zon file if the map has the entities
+        LoadFromFile(szMapName);
+    }
+}
+
+//MOM_TODO: Get rid of the following method and ConCommand
+static void saveZonFile_f()
+{
+    saveZonFile(gpGlobals->mapname.ToCStr());
+}
+
+static ConCommand mom_generate_zone_file("mom_generate_zone_file", saveZonFile_f, "Generates a zone file.");
+
+CMapzoneData::~CMapzoneData()
+{
+    if (!m_zones.IsEmpty())
+    {
+        m_zones.PurgeAndDeleteElements();
+    }
+}
+
+bool CMapzoneData::MapZoneSpawned(CMapzone *mZone)
+{
+    bool toReturn = false;
+    if (!mZone) return false;
+
+    char name[128];
+    if ( !ZoneTypeToClass( mZone->GetType(), name ) ) return false;
+
+
+    CBaseEntity *pEnt = gEntList.FindEntityByClassname(NULL, name);
+    while (pEnt)
+    {
+        if (pEnt->GetAbsOrigin() == *mZone->GetPosition()
+            && pEnt->GetAbsAngles() == *mZone->GetRotation()
+            && pEnt->WorldAlignMaxs() == *mZone->GetScaleMaxs()
+            && pEnt->WorldAlignMins() == *mZone->GetScaleMins())
+        {
+            DevLog("Already found a %s spawned on the map! Not spawning it from zone file...\n", name);
+            toReturn = true;
+            break;
+        }
+
+        pEnt = gEntList.FindEntityByClassname(pEnt, name);
+    }
+
+    return toReturn;
+}
+
+void CMapzoneData::SpawnMapZones()
+{
+    int count = m_zones.Count();
+    for (int i = 0; i < count; i++)
+    {
+        if (m_zones[i])
+        {
+            //if the zone already exists (placed in map by Hammer), don't spawn it
+            if (!MapZoneSpawned(m_zones[i]))
+                m_zones[i]->SpawnZone();
+        }
+    }
+}
+
+bool CMapzoneData::LoadFromFile(const char *szMapName)
+{
+    bool toReturn = false;
+    char zoneFilePath[MAX_PATH];
+    Q_strcpy(zoneFilePath, c_mapPath);
+    Q_strcat(zoneFilePath, szMapName, MAX_PATH);
+    Q_strncat(zoneFilePath, c_zoneFileEnding, MAX_PATH);
+    DevLog("Looking for zone file: %s \n", zoneFilePath);
+    KeyValues* zoneKV = new KeyValues(szMapName);
+    if (zoneKV->LoadFromFile(filesystem, zoneFilePath, "MOD"))
+    {
+        // Go through checkpoints
+        for (KeyValues *cp = zoneKV->GetFirstSubKey(); cp; cp = cp->GetNextKey())
+        {
+            // Load position information (will default to 0 if the keys don't exist)
+            Vector* pos = new Vector(cp->GetFloat("xPos"), cp->GetFloat("yPos"), cp->GetFloat("zPos"));
+            QAngle* rot = new QAngle(cp->GetFloat("xRot"), cp->GetFloat("yRot"), cp->GetFloat("zRot"));
+            Vector* scaleMins = new Vector(cp->GetFloat("xScaleMins"), cp->GetFloat("yScaleMins"), cp->GetFloat("zScaleMins"));
+            Vector* scaleMaxs = new Vector(cp->GetFloat("xScaleMaxs"), cp->GetFloat("yScaleMaxs"), cp->GetFloat("zScaleMaxs"));
+
+            // Do specific things for different types of checkpoints
+            // 0 = start, 1 = checkpoint, 2 = end, 3 = Onehop, 4 = OnehopReset, 5 = Checkpoint_teleport, 6 = Multihop, 7 = stage
+            int zoneType = -1;
+            int index = -1;
+            bool shouldStop = false;
+            bool shouldTilt = true;
+            float holdTime = 1.0f;
+            //int destinationIndex = -1;
+            bool limitingspeed = true;
+            bool checkonlyxy = true;
+            float maxleavespeed = 290.0f;
+            const char * linkedtrigger = NULL;
+
+            float start_yaw = NO_LOOK;
+
+            if (Q_strcmp(cp->GetName(), "start") == 0)
+            {
+                zoneType = MOMZONETYPE_START;
+                limitingspeed = cp->GetBool("limitingspeed");
+                maxleavespeed = cp->GetFloat("leavespeed");
+                start_yaw = cp->GetFloat("yaw", NO_LOOK);
+                checkonlyxy = cp->GetBool("onlyxy", true);
+            }
+            else if (Q_strcmp(cp->GetName(), "checkpoint") == 0)
+            {
+                zoneType = MOMZONETYPE_CP;
+                index = cp->GetInt("number", -1);
+            }
+            else if (Q_strcmp(cp->GetName(), "end") == 0)
+            {
+                zoneType = MOMZONETYPE_STOP;
+            }
+            else if (Q_strcmp(cp->GetName(), "onehop") == 0)
+            {
+                zoneType = MOMZONETYPE_ONEHOP;
+                shouldStop = cp->GetBool("stop", false);
+                shouldTilt = cp->GetBool("resetang", true);
+                holdTime = cp->GetFloat("hold", 1);
+                //destinationIndex = cp->GetInt("destination", 1);
+                linkedtrigger = cp->GetString("destinationname", NULL);
+            }
+            else if (Q_strcmp(cp->GetName(), "resetonehop") == 0)
+            {
+                zoneType = MOMZONETYPE_RESETONEHOP;
+            }
+            else if (Q_strcmp(cp->GetName(), "checkpoint_teleport") == 0)
+            {
+                zoneType = MOMZONETYPE_CPTELE;
+                //destinationIndex = cp->GetInt("destination", -1);
+                shouldStop = cp->GetBool("stop", false);
+                shouldTilt = cp->GetBool("resetang", true);
+                linkedtrigger = cp->GetString("destinationname", NULL);
+            }
+            else if (Q_strcmp(cp->GetName(), "multihop") == 0)
+            {
+                zoneType = MOMZONETYPE_MULTIHOP;
+                shouldStop = cp->GetBool("stop", false);
+                shouldTilt = cp->GetBool("resetang", true);
+                holdTime = cp->GetFloat("hold", 1);
+                //destinationIndex = cp->GetInt("destination", 1);
+                linkedtrigger = cp->GetString("destinationname", NULL);
+            }
+            else if (Q_strcmp(cp->GetName(), "stage") == 0)
+            {
+                zoneType = MOMZONETYPE_STAGE;
+                index = cp->GetInt("number", 0);
+            }
+            else
+            {
+                Warning("Error while reading zone file: Unknown mapzone type %s!\n", cp->GetName());
+                continue;
+            }
+
+            // Add element
+            m_zones.AddToTail(new CMapzone(zoneType, pos, rot, scaleMins, scaleMaxs, index, shouldStop, shouldTilt,
+                holdTime, limitingspeed, maxleavespeed, start_yaw, MAKE_STRING(linkedtrigger),checkonlyxy));
+        }
+        DevLog("Successfully loaded map zone file %s!\n", zoneFilePath);
+        toReturn = true;
+    }
+    zoneKV->deleteThis();
+    return toReturn;
+}
+
+bool ZoneTypeToClass( int type, char *dest )
+{
+    switch (type)
+    {
+    case MOMZONETYPE_START:
+        Q_strcpy(dest, "trigger_momentum_timer_start");
+        return true;
+    case MOMZONETYPE_CP:
+        Q_strcpy(dest, "trigger_momentum_timer_checkpoint");
+        return true;
+    case MOMZONETYPE_STOP:
+        Q_strcpy(dest, "trigger_momentum_timer_stop");
+        return true;
+    case MOMZONETYPE_ONEHOP:
+        Q_strcpy(dest, "trigger_momentum_onehop");
+        return true;
+    case MOMZONETYPE_RESETONEHOP:
+        Q_strcpy(dest, "trigger_momentum_timer_resetonehop");
+        return true;
+    case MOMZONETYPE_CPTELE:
+        Q_strcpy(dest, "trigger_momentum_teleport_checkpoint");
+        return true;
+    case MOMZONETYPE_MULTIHOP:
+        Q_strcpy(dest, "trigger_momentum_multihop");
+        return true;
+    case MOMZONETYPE_STAGE:
+        Q_strcpy(dest, "trigger_momentum_timer_stage");
+        return true;
+    }
+
+    return false;
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mapzones.h b/mp/src/game/server/momentum/mapzones.h
new file mode 100644
index 000000000..809143ba3
--- /dev/null
+++ b/mp/src/game/server/momentum/mapzones.h
@@ -0,0 +1,77 @@
+#ifndef MAPZONES_H
+#define MAPZONES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "filesystem.h"
+#include "mom_triggers.h"
+
+#define MOMZONETYPE_START       0
+#define MOMZONETYPE_CP          1
+#define MOMZONETYPE_STOP        2
+#define MOMZONETYPE_ONEHOP      3
+#define MOMZONETYPE_RESETONEHOP 4
+#define MOMZONETYPE_CPTELE      5
+#define MOMZONETYPE_MULTIHOP    6
+#define MOMZONETYPE_STAGE       7
+
+class CMapzone
+{
+public:
+    CMapzone();
+    CMapzone(const int, Vector*, QAngle*, Vector*, Vector*,
+        const int, const bool, const bool, const float,
+        const bool, const float, const float, const string_t, const bool);
+    ~CMapzone();
+
+    void SpawnZone();
+    void RemoveZone();
+
+    int GetType() { return m_type; }
+    Vector* GetPosition() { return m_pos; }
+    QAngle* GetRotation() { return m_rot; }
+    Vector* GetScaleMins() { return m_scaleMins; }
+    Vector* GetScaleMaxs() { return m_scaleMaxs; }
+
+private:
+    int m_type; // Zone type, look above
+    int m_index; // Ignored when not a checkpoint
+    bool m_shouldStopOnTeleport; // Stop player on teleport?
+    bool m_shouldResetAngles; // Reset the player's angles?
+    float m_holdTimeBeforeTeleport; // How much to wait for before teleporting
+    // startTrigger
+    bool m_limitingspeed; // Limit leave speed?
+    bool m_onlyxycheck; // Only checking speed in XY?
+    float m_maxleavespeed; // Max speed allowed
+    float m_yaw; // Teleport yaw for start zone.
+    string_t m_linkedent; // Entity name for teleporting to this entity (YESYES, It can be null!)
+    Vector* m_pos;
+    QAngle* m_rot;
+    Vector* m_scaleMins;
+    Vector* m_scaleMaxs;
+    CBaseEntity* m_trigger;
+};
+
+class CMapzoneData
+{
+public:
+    CMapzoneData(const char *szMapName);
+    ~CMapzoneData();
+
+    
+    void SpawnMapZones();
+    void RemoveMapZones();
+    bool MapZoneSpawned(CMapzone*);
+    bool LoadFromFile(const char*);
+
+private:
+    const char* c_mapPath = "maps/";
+    const char* c_zoneFileEnding = ".zon";
+
+    CUtlVector<CMapzone*> m_zones;
+};
+
+bool ZoneTypeToClass(int type, char *dest);
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mapzones_edit.cpp b/mp/src/game/server/momentum/mapzones_edit.cpp
new file mode 100644
index 000000000..5060ccf2f
--- /dev/null
+++ b/mp/src/game/server/momentum/mapzones_edit.cpp
@@ -0,0 +1,558 @@
+#include "cbase.h"
+#include "mapzones_edit.h"
+
+#include "tier0/memdbgon.h"
+
+
+ConVar mom_zone_edit("mom_zone_edit", "0", FCVAR_CHEAT, "Toggle zone editing.\n", true, 0, true, 1);
+static ConVar mom_zone_ignorewarning("mom_zone_ignorewarning", "0", FCVAR_CHEAT, "Lets you create zones despite map already having start and end.\n", true, 0, true, 1);
+static ConVar mom_zone_grid("mom_zone_grid", "8", FCVAR_CHEAT, "Set grid size. 0 to disable.", true, 0, false, 0);
+static ConVar mom_zone_defzone("mom_zone_defzone", "start", FCVAR_CHEAT, "If no zone type is passed to mom_zone_mark, use this.\n");
+static ConVar mom_zone_start_limitspdmethod("mom_zone_start_limitspdmethod", "1", FCVAR_CHEAT, "0 = Take into account player z-velocity, 1 = Ignore z-velocity.\n", true, 0, true, 1);
+static ConVar mom_zone_stage_num("mom_zone_stage_num", "0", FCVAR_CHEAT, "Set stage number. Should start from 2. 0 to automatically find one.\n", true, 0, false, 0);
+static ConVar mom_zone_start_maxleavespeed("mom_zone_start_maxleavespeed", "290", FCVAR_CHEAT, "Max leave speed. 0 to disable.\n", true, 0, false, 0);
+//static ConVar mom_zone_cp_num( "mom_zone_cp_num", "0", FCVAR_CHEAT, "Checkpoint number. 0 to automatically find one." );
+
+
+void CC_Mom_ZoneZoomIn()
+{
+    g_MapzoneEdit.DecreaseZoom((float) mom_zone_grid.GetInt());
+}
+
+static ConCommand mom_zone_zoomin("mom_zone_zoomin", CC_Mom_ZoneZoomIn, "Decrease reticle maximum distance.\n", FCVAR_CHEAT);
+
+
+void CC_Mom_ZoneZoomOut()
+{
+    g_MapzoneEdit.IncreaseZoom((float) mom_zone_grid.GetInt());
+}
+
+static ConCommand mom_zone_zoomout("mom_zone_zoomout", CC_Mom_ZoneZoomOut, "Increase reticle maximum distance.\n", FCVAR_CHEAT);
+
+
+void CC_Mom_ZoneDelete(const CCommand &args)
+{
+    if (!mom_zone_edit.GetBool()) return;
+
+
+    if (args.ArgC() > 1)
+    {
+        DevMsg("Attempting to delete '%s'\n", args[1]);
+
+        int entindex = atoi(args[1]);
+
+        if (entindex != 0)
+        {
+            CBaseEntity *pEnt = CBaseEntity::Instance(INDEXENT(entindex));
+
+            if (pEnt && g_MapzoneEdit.GetEntityZoneType(pEnt) != -1)
+            {
+                UTIL_Remove(pEnt);
+            }
+        }
+        else
+        {
+            char szDelete[64];
+            if (ZoneTypeToClass(g_MapzoneEdit.ShortNameToZoneType(args[1]), szDelete))
+            {
+                CBaseEntity *pEnt = gEntList.FindEntityByClassname(NULL, szDelete);
+                while (pEnt)
+                {
+                    UTIL_Remove(pEnt);
+                    pEnt = gEntList.FindEntityByClassname(pEnt, szDelete);
+                }
+            }
+        }
+    }
+}
+
+static ConCommand mom_zone_delete("mom_zone_delete", CC_Mom_ZoneDelete, "Delete zone types. Accepts start/stop/stage or an entity index.\n", FCVAR_CHEAT);
+
+
+void CC_Mom_ZoneSetLook(const CCommand &args)
+{
+    if (!mom_zone_edit.GetBool()) return;
+
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+    if (!pPlayer) return;
+
+
+    float yaw;
+
+    if (args.ArgC() > 1)
+    {
+        yaw = atof(args[1]);
+    }
+    else
+    {
+        yaw = pPlayer->EyeAngles()[1];
+    }
+
+    CBaseEntity *pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_start");
+    CTriggerTimerStart *pStart;
+
+    while (pEnt)
+    {
+        pStart = static_cast<CTriggerTimerStart *>(pEnt);
+
+        if (pStart)
+        {
+            pStart->SetHasLookAngles(true);
+            pStart->SetLookAngles(QAngle(0, yaw, 0));
+
+            DevMsg("Set start zone angles to: %.1f, %.1f, %.1f\n", pStart->GetLookAngles()[0], pStart->GetLookAngles()[1], pStart->GetLookAngles()[2]);
+        }
+
+        pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_timer_start");
+    }
+}
+
+static ConCommand mom_zone_start_setlook("mom_zone_start_setlook", CC_Mom_ZoneSetLook, "Sets start zone teleport look angles. Will take yaw in degrees or use your angles if no arguments given.\n", FCVAR_CHEAT);
+
+
+void CC_Mom_ZoneMark(const CCommand &args)
+{
+    if (!mom_zone_edit.GetBool()) return;
+
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+
+    if (!pPlayer) return;
+
+
+    int zonetype = -1;
+
+    if (g_MapzoneEdit.GetBuildStage() >= BUILDSTAGE_END)
+    {
+        if (args.ArgC() > 1)
+        {
+            zonetype = g_MapzoneEdit.ShortNameToZoneType(args[1]);
+        }
+        else
+        {
+            zonetype = g_MapzoneEdit.ShortNameToZoneType(mom_zone_defzone.GetString());
+        }
+
+        if (zonetype == MOMZONETYPE_START || zonetype == MOMZONETYPE_STOP)
+        {
+            // Count zones to make sure we don't create multiple instances.
+            int startnum = 0;
+            int endnum = 0;
+
+            CBaseEntity *pEnt;
+
+            pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_start");
+            while (pEnt)
+            {
+                startnum++;
+                pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_timer_start");
+            }
+
+            pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_stop");
+            while (pEnt)
+            {
+                endnum++;
+                pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_timer_stop");
+            }
+
+            DevMsg("Found %i starts and %i ends (previous)\n", startnum, endnum);
+
+            if (!mom_zone_ignorewarning.GetBool() && startnum && endnum)
+            {
+                g_MapzoneEdit.SetBuildStage(BUILDSTAGE_NONE);
+
+                ConMsg("Map already has a start and an end! Use mom_zone_defzone to set another type.\n");
+
+                return;
+            }
+
+            //The user is trying to make multiple starts?
+            if (zonetype == MOMZONETYPE_START)
+            {
+                 // Switch between start and end.
+                 zonetype = (startnum <= endnum) ? MOMZONETYPE_START : MOMZONETYPE_STOP;
+            }
+            //else the zonetype can be STOP, allowing for multiple stop triggers to be created
+        }
+    }
+
+    trace_t tr;
+    Vector vecFwd;
+
+    AngleVectors(pPlayer->EyeAngles(), &vecFwd);
+
+    UTIL_TraceLine(pPlayer->EyePosition(), pPlayer->EyePosition() + vecFwd * g_MapzoneEdit.GetZoom(), MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
+
+
+    g_MapzoneEdit.Build(&tr.endpos, zonetype);
+}
+
+static ConCommand mom_zone_mark("mom_zone_mark", CC_Mom_ZoneMark, "Starts building a zone.\n", FCVAR_CHEAT);
+
+
+void CC_Mom_ZoneCancel()
+{
+    if (!mom_zone_edit.GetBool()) return;
+
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+
+    if (!pPlayer) return;
+
+
+    g_MapzoneEdit.SetBuildStage(BUILDSTAGE_NONE);
+}
+
+static ConCommand mom_zone_cancel("mom_zone_cancel", CC_Mom_ZoneCancel, "Cancel the zone building.\n", FCVAR_CHEAT);
+
+
+void CMapzoneEdit::Build(Vector *aimpos, int type, int forcestage)
+{
+    if (mom_zone_grid.GetInt() > 0)
+        VectorSnapToGrid(aimpos, (float) mom_zone_grid.GetInt());
+
+
+    switch ((forcestage != BUILDSTAGE_NONE) ? forcestage : ++m_nBuildStage)
+    {
+    case BUILDSTAGE_START:
+        m_vecBuildStart = *aimpos;
+        break;
+
+    case BUILDSTAGE_END:
+        m_vecBuildEnd = *aimpos;
+        break;
+
+    case BUILDSTAGE_HEIGHT:
+    {
+        char szClass[64];
+        if (ZoneTypeToClass(type, szClass))
+        {
+            CBaseEntity *pEnt = CreateEntityByName(szClass);
+            Vector vecOrigin, vecSize, vecMinsRel;
+            int i;
+
+            VectorMin(m_vecBuildStart, m_vecBuildEnd, vecMinsRel);
+            VectorMax(m_vecBuildStart, m_vecBuildEnd, vecSize);
+
+            for (i = 0; i < 3; i++)
+                vecSize[i] = (vecSize[i] - vecMinsRel[i]) / 2.0f;
+
+            for (i = 0; i < 3; i++)
+                vecOrigin[i] = vecMinsRel[i] + vecSize[i];
+
+            pEnt->Spawn();
+
+            pEnt->SetAbsOrigin(vecOrigin);
+            pEnt->SetSize(Vector(-vecSize.x, -vecSize.y, -vecSize.z), vecSize);
+            pEnt->SetEffects(EF_NODRAW);
+            pEnt->SetSolid(SOLID_BBOX);
+
+            pEnt->Activate();
+
+            SetZoneProps(pEnt);
+        }
+    }
+    default:
+        m_nBuildStage = BUILDSTAGE_NONE;
+    }
+}
+
+void CMapzoneEdit::SetZoneProps(CBaseEntity *pEnt)
+{
+    CTriggerTimerStart *pStart = dynamic_cast<CTriggerTimerStart *>(pEnt);
+    if (pStart)
+    {
+        if (mom_zone_start_maxleavespeed.GetFloat() > 0.0)
+        {
+            pStart->SetMaxLeaveSpeed(mom_zone_start_maxleavespeed.GetFloat());
+            pStart->SetIsLimitingSpeed(true);
+        }
+        else
+        {
+            pStart->SetIsLimitingSpeed(false);
+        }
+
+        pStart->SetIsLimitingSpeedOnlyXY(mom_zone_start_limitspdmethod.GetBool());
+
+        return;
+    }
+
+    CTriggerStage *pStage = dynamic_cast<CTriggerStage *>(pEnt);
+    if (pStage)
+    {
+        if (mom_zone_stage_num.GetInt() > 0)
+        {
+            pStage->SetStageNumber(mom_zone_stage_num.GetInt());
+        }
+        else
+        {
+            int higheststage = 1;
+            CTriggerStage *pTempStage;
+
+            CBaseEntity *pTemp = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_stage");
+            while (pTemp)
+            {
+                pTempStage = static_cast<CTriggerStage *>(pTemp);
+
+                if (pTempStage && pTempStage->GetStageNumber() > higheststage)
+                {
+                    higheststage = pTempStage->GetStageNumber();
+                }
+
+                pTemp = gEntList.FindEntityByClassname(pTemp, "trigger_momentum_timer_stage");
+            }
+
+            pStage->SetStageNumber(higheststage + 1);
+        }
+
+        return;
+    }
+
+
+    /*CTriggerCheckpoint *pCP = dynamic_cast<CTriggerCheckpoint *>( pEnt );
+    if ( pCP )
+    {
+    if ( mom_zone_cpnum.GetInt() > 0 )
+    {
+    pCP->SetCheckpointNumber( mom_zone_cpnum.GetInt() );
+    }
+    else
+    {
+    int highestcp = 0;
+    CTriggerCheckpoint *pTempCP;
+
+    CBaseEntity *pTemp = gEntList.FindEntityByClassname( NULL, "trigger_momentum_timer_checkpoint" );
+    while ( pTemp )
+    {
+    pTempCP = dynamic_cast<CTriggerCheckpoint *>( pTemp );
+
+    if ( pTempCP && pTempCP->GetCheckpointNumber() > highestcp )
+    {
+    highestcp = pTempCP->GetCheckpointNumber();
+    }
+
+    pTemp = gEntList.FindEntityByClassname( pTemp, "trigger_momentum_timer_checkpoint" );
+    }
+
+    pStage->SetStageNumber( highestcp + 1 );
+    }
+
+    return;
+    }*/
+}
+
+int CMapzoneEdit::GetEntityZoneType(CBaseEntity *pEnt)
+{
+    CTriggerTimerStart *pStart = dynamic_cast<CTriggerTimerStart *>(pEnt);
+    if (pStart) return MOMZONETYPE_START;
+
+    /*CTriggerTeleportCheckpoint *pCP = dynamic_cast<CTriggerTeleportCheckpoint *>( pEnt );
+    if ( pCP ) return 1;*/
+
+    CTriggerTimerStop *pStop = dynamic_cast<CTriggerTimerStop *>(pEnt);
+    if (pStop) return MOMZONETYPE_STOP;
+
+    CTriggerStage *pStage = dynamic_cast<CTriggerStage *>(pEnt);
+    if (pStage) return MOMZONETYPE_STAGE;
+
+    return -1;
+}
+
+void CMapzoneEdit::Update()
+{
+    if (mom_zone_edit.GetBool())
+    {
+        if (!m_bEditing)
+        {
+            m_nBuildStage = BUILDSTAGE_NONE;
+            m_bEditing = true;
+        }
+    }
+    else
+    {
+        if (m_bEditing)
+        {
+            m_nBuildStage = BUILDSTAGE_NONE;
+            m_bEditing = false;
+        }
+
+        return;
+    }
+
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+
+    if (!pPlayer) return;
+
+
+    trace_t tr;
+    Vector vecFwd;
+
+    AngleVectors(pPlayer->EyeAngles(), &vecFwd);
+
+    UTIL_TraceLine(pPlayer->EyePosition(), pPlayer->EyePosition() + vecFwd * m_flReticleDist, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
+
+    Vector vecAim = tr.endpos;
+
+    if (mom_zone_grid.GetInt() > 0)
+        VectorSnapToGrid(&vecAim, (float) mom_zone_grid.GetInt());
+
+
+    if (m_nBuildStage >= BUILDSTAGE_START)
+    {
+        Vector vecP2, vecP3, vecP4;
+
+        if (m_nBuildStage >= BUILDSTAGE_END)
+        {
+            vecP3 = m_vecBuildEnd;
+        }
+        else
+        {
+            vecP3 = vecAim;
+        }
+
+        vecP3[2] = m_vecBuildStart[2];
+
+        // Bottom
+        vecP2[0] = m_vecBuildStart[0];
+        vecP2[1] = vecP3[1];
+        vecP2[2] = m_vecBuildStart[2];
+
+        vecP4[0] = vecP3[0];
+        vecP4[1] = m_vecBuildStart[1];
+        vecP4[2] = m_vecBuildStart[2];
+
+        DebugDrawLine(m_vecBuildStart, vecP2, 255, 255, 255, true, -1.0f);
+        DebugDrawLine(vecP2, vecP3, 255, 255, 255, true, -1.0f);
+        DebugDrawLine(vecP3, vecP4, 255, 255, 255, true, -1.0f);
+        DebugDrawLine(vecP4, m_vecBuildStart, 255, 255, 255, true, -1.0f);
+
+        if (m_nBuildStage >= BUILDSTAGE_END)
+        {
+            Vector vecP5, vecP6, vecP8;
+
+            m_vecBuildEnd[2] = SnapToGrid(m_vecBuildStart[2] + GetZoneHeightToPlayer(pPlayer), (float) mom_zone_grid.GetInt());
+
+            // Top
+            vecP5 = m_vecBuildStart;
+            vecP5.z = m_vecBuildEnd[2];
+
+            vecP6 = vecP2;
+            vecP6.z = m_vecBuildEnd[2];
+
+            vecP8 = vecP4;
+            vecP8.z = m_vecBuildEnd[2];
+
+            DebugDrawLine(vecP5, vecP6, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(vecP6, m_vecBuildEnd, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(m_vecBuildEnd, vecP8, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(vecP8, vecP5, 255, 255, 255, true, -1.0f);
+
+            // Bottom to top
+            DebugDrawLine(m_vecBuildStart, vecP5, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(vecP2, vecP6, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(vecP3, m_vecBuildEnd, 255, 255, 255, true, -1.0f);
+            DebugDrawLine(vecP4, vecP8, 255, 255, 255, true, -1.0f);
+        }
+    }
+
+    // Draw surface normal. Makes it a bit easier to see where reticle is hitting.
+    if (tr.DidHit())
+    {
+        DebugDrawLine(vecAim, vecAim + tr.plane.normal * 24.0f, 0, 0, 255, true, -1.0f);
+    }
+
+    DrawReticle(&vecAim, (mom_zone_grid.GetInt() > 0) ? ((float) mom_zone_grid.GetInt() / 2.0f) : 8.0f);
+}
+
+void CMapzoneEdit::VectorSnapToGrid(Vector *dest, float gridsize)
+{
+    dest->x = SnapToGrid(dest->x, gridsize);
+    dest->y = SnapToGrid(dest->y, gridsize);
+    dest->z = SnapToGrid(dest->z, gridsize);
+}
+
+float CMapzoneEdit::SnapToGrid(float fl, float gridsize)
+{
+    float closest;
+    float dif;
+
+    closest = fl - fmodf(fl, gridsize);
+
+    dif = fl - closest;
+
+    if (dif > (gridsize / 2.0f))
+    {
+        closest += gridsize;
+    }
+    else if (dif < (-gridsize / 2.0f))
+    {
+        closest -= gridsize;
+    }
+
+    return closest;
+}
+
+float CMapzoneEdit::GetZoneHeightToPlayer(CBasePlayer *pPlayer)
+{
+    // It's good enough.
+    return pPlayer->GetAbsOrigin().DistTo(m_vecBuildStart) * tanf(DEG2RAD(-pPlayer->EyeAngles()[0])) + pPlayer->GetViewOffset()[2];
+}
+
+void CMapzoneEdit::DrawReticle(Vector *pos, float retsize)
+{
+    Vector p1, p2, p3, p4, p5, p6;
+
+    p1.x = pos->x + retsize;
+    p1.y = pos->y;
+    p1.z = pos->z;
+
+    p2.x = pos->x - retsize;
+    p2.y = pos->y;
+    p2.z = pos->z;
+
+    p3.x = pos->x;
+    p3.y = pos->y + retsize;
+    p3.z = pos->z;
+
+    p4.x = pos->x;
+    p4.y = pos->y - retsize;
+    p4.z = pos->z;
+
+    p5.x = pos->x;
+    p5.y = pos->y;
+    p5.z = pos->z + retsize;
+
+    p6.x = pos->x;
+    p6.y = pos->y;
+    p6.z = pos->z - retsize;
+
+    DebugDrawLine(p1, p2, 255, 0, 0, true, -1.0f);
+    DebugDrawLine(p3, p4, 255, 0, 0, true, -1.0f);
+    DebugDrawLine(p5, p6, 255, 0, 0, true, -1.0f);
+}
+
+int CMapzoneEdit::ShortNameToZoneType(const char *in)
+{
+    if (Q_stricmp(in, "start") == 0)
+    {
+        return MOMZONETYPE_START;
+    }
+    else if (Q_stricmp(in, "end") == 0 || Q_stricmp(in, "stop") == 0)
+    {
+        return MOMZONETYPE_STOP;
+    }
+    else if (Q_stricmp(in, "stage") == 0)
+    {
+        return MOMZONETYPE_STAGE;
+    }
+
+    return -1;
+}
+
+void CMapzoneEdit::Reset()
+{
+    mom_zone_edit.SetValue(0);
+
+    m_nBuildStage = BUILDSTAGE_NONE;
+    m_bEditing = false;
+}
+
+CMapzoneEdit g_MapzoneEdit;
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mapzones_edit.h b/mp/src/game/server/momentum/mapzones_edit.h
new file mode 100644
index 000000000..94c8159f9
--- /dev/null
+++ b/mp/src/game/server/momentum/mapzones_edit.h
@@ -0,0 +1,58 @@
+#ifndef MAPZONES_EDIT_H
+#define MAPZONES_EDIT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define BUILDSTAGE_NONE         0
+#define BUILDSTAGE_START        1
+//#define BUILDSTAGE_ROTATE     2
+#define BUILDSTAGE_END          2
+#define BUILDSTAGE_HEIGHT       3
+
+#include "mapzones.h"
+#include "mom_triggers.h"
+
+extern ConVar mom_zone_edit;
+
+class CMapzoneEdit
+{
+public:
+    void Build( Vector *aimpos, int type, int forcestage = BUILDSTAGE_NONE );
+
+    // Draw lines and update the zone height.
+    void Update();
+
+    void Reset();
+
+    int GetBuildStage() { return m_nBuildStage; }
+    void SetBuildStage( int stage ) { m_nBuildStage = stage; }
+
+    void IncreaseZoom( float dist ) { m_flReticleDist = fminf( m_flReticleDist + dist, 2048.0f ); }
+    void DecreaseZoom( float dist ) { m_flReticleDist = fmaxf( m_flReticleDist - dist, 16.0f ); }
+    float GetZoom() { return m_flReticleDist; }
+    void SetZoom( float dist ) { m_flReticleDist = fmaxf( fminf( dist, 2048.0f ), 16.0f ); }
+    
+    // Placeholder, move this somewhere else if other files start using the zone types.
+    int GetEntityZoneType( CBaseEntity *pEnt );
+    
+    // start/stop/stage
+    int ShortNameToZoneType( const char *in );
+
+private:
+    int m_nBuildStage = BUILDSTAGE_NONE;
+    float m_flReticleDist = 256.0f;
+    Vector m_vecBuildStart;
+    Vector m_vecBuildEnd;
+    bool m_bEditing = false;
+
+    float GetZoneHeightToPlayer( CBasePlayer *pPlayer );
+    void SetZoneProps( CBaseEntity *pEnt );
+    float SnapToGrid( float fl, float gridsize );
+    void VectorSnapToGrid( Vector *dest, float gridsize );
+    void DrawReticle( Vector *pos, float retsize );
+};
+
+extern CMapzoneEdit g_MapzoneEdit;
+
+#endif // MAPZONES_EDIT_H
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mom_client.cpp b/mp/src/game/server/momentum/mom_client.cpp
new file mode 100644
index 000000000..888db973c
--- /dev/null
+++ b/mp/src/game/server/momentum/mom_client.cpp
@@ -0,0 +1,136 @@
+#include "cbase.h"
+#include "mom_player.h"
+#include "momentum/mom_gamerules.h"
+#include "gamerules.h"
+#include "teamplay_gamerules.h"
+#include "entitylist.h"
+#include "physics.h"
+#include "game.h"
+#include "player_resource.h"
+#include "engine/IEngineSound.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+void Host_Say(edict_t *pEdict, bool teamonly);
+
+extern CBaseEntity*	FindPickerEntityClass(CBasePlayer *pPlayer, char *classname);
+extern bool			g_fGameOver;
+
+/*
+===========
+ClientPutInServer
+
+called each time a player is spawned into the game
+============
+*/
+void ClientPutInServer(edict_t *pEdict, const char *playername)
+{
+    // Allocate a CBasePlayer for pev, and call spawn
+    CMomentumPlayer *pPlayer = CMomentumPlayer::CreatePlayer("player", pEdict);
+    pPlayer->SetPlayerName(playername);
+}
+
+
+void ClientActive(edict_t *pEdict, bool bLoadGame)
+{
+    CMomentumPlayer *pPlayer = dynamic_cast< CMomentumPlayer* >(CBaseEntity::Instance(pEdict));
+    Assert(pPlayer);
+
+    if (!pPlayer)
+    {
+        return;
+    }
+
+    pPlayer->InitialSpawn();
+
+    if (!bLoadGame)
+    {
+        pPlayer->Spawn();
+    }
+}
+
+
+/*
+===============
+const char *GetGameDescription()
+
+Returns the descriptive name of this .dll.  E.g., Half-Life, or Team Fortress 2
+===============
+*/
+const char *GetGameDescription()
+{
+    if (g_pGameRules) // this function may be called before the world has spawned, and the game rules initialized
+        return g_pGameRules->GetGameDescription();
+    else
+        return "Momentum";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a player and optional name returns the entity of that 
+//			classname that the player is nearest facing
+//			
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+CBaseEntity* FindEntity(edict_t *pEdict, char *classname)
+{
+    // If no name was given set bits based on the picked
+    if (FStrEq(classname, ""))
+    {
+        return (FindPickerEntityClass(static_cast<CBasePlayer*>(GetContainingEntity(pEdict)), classname));
+    }
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Precache game-specific models & sounds
+//-----------------------------------------------------------------------------
+void ClientGamePrecache(void)
+{
+    //MOM_TODO: Precache all of the mod-related sounds here
+
+
+
+    /*CBaseEntity::PrecacheModel("models/player.mdl");
+    CBaseEntity::PrecacheModel("models/gibs/agibs.mdl");
+    CBaseEntity::PrecacheModel("models/weapons/v_hands.mdl");
+
+    CBaseEntity::PrecacheScriptSound("HUDQuickInfo.LowAmmo");
+    CBaseEntity::PrecacheScriptSound("HUDQuickInfo.LowHealth");
+
+    CBaseEntity::PrecacheScriptSound("FX_AntlionImpact.ShellImpact");
+    CBaseEntity::PrecacheScriptSound("Missile.ShotDown");
+    CBaseEntity::PrecacheScriptSound("Bullets.DefaultNearmiss");
+    CBaseEntity::PrecacheScriptSound("Bullets.GunshipNearmiss");
+    CBaseEntity::PrecacheScriptSound("Bullets.StriderNearmiss");
+
+    CBaseEntity::PrecacheScriptSound("Geiger.BeepHigh");
+    CBaseEntity::PrecacheScriptSound("Geiger.BeepLow");*/
+}
+
+
+// called by ClientKill and DeadThink
+void respawn(CBaseEntity *pEdict, bool fCopyCorpse)
+{
+    pEdict->Spawn();
+}
+
+void GameStartFrame(void)
+{
+    VPROF("GameStartFrame()");
+    if (g_fGameOver)
+        return;
+
+    gpGlobals->teamplay = (teamplay.GetInt() != 0);
+}
+
+//=========================================================
+// instantiate the proper game rules object
+//=========================================================
+void InstallGameRules()
+{
+    CreateGameRulesObject("CMomentum");
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mom_player.cpp b/mp/src/game/server/momentum/mom_player.cpp
new file mode 100644
index 000000000..d72db1c33
--- /dev/null
+++ b/mp/src/game/server/momentum/mom_player.cpp
@@ -0,0 +1,110 @@
+#include "cbase.h"
+#include "mom_player.h"
+
+#include "tier0/memdbgon.h"
+
+IMPLEMENT_SERVERCLASS_ST(CMomentumPlayer, DT_MOM_Player)
+SendPropInt(SENDINFO(m_iShotsFired)),
+SendPropInt(SENDINFO(m_iDirection)),
+SendPropBool(SENDINFO(m_bResumeZoom)),
+SendPropInt(SENDINFO(m_iLastZoom)),
+END_SEND_TABLE()
+
+BEGIN_DATADESC(CMomentumPlayer)
+
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS(player, CMomentumPlayer);
+PRECACHE_REGISTER(player);
+
+CMomentumPlayer::CMomentumPlayer()
+{
+
+}
+
+CMomentumPlayer::~CMomentumPlayer()
+{
+
+}
+
+void CMomentumPlayer::SurpressLadderChecks(const Vector& pos, const Vector& normal)
+{
+    m_ladderSurpressionTimer.Start(1.0f);
+    m_lastLadderPos = pos;
+    m_lastLadderNormal = normal;
+}
+
+bool CMomentumPlayer::CanGrabLadder(const Vector& pos, const Vector& normal)
+{
+    if (m_ladderSurpressionTimer.GetRemainingTime() <= 0.0f)
+    {
+        return true;
+    }
+
+    const float MaxDist = 64.0f;
+    if (pos.AsVector2D().DistToSqr(m_lastLadderPos.AsVector2D()) < MaxDist * MaxDist)
+    {
+        return false;
+    }
+
+    if (normal != m_lastLadderNormal)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+CBaseEntity* CMomentumPlayer::EntSelectSpawnPoint()
+{
+    CBaseEntity *pStart;
+    pStart = NULL;
+    if (SelectSpawnSpot("info_player_counterterrorist", pStart))
+    {
+        return pStart;
+    }
+    else if (SelectSpawnSpot("info_player_terrorist", pStart))
+    {
+        return pStart;
+    }
+    else if (SelectSpawnSpot("info_player_start", pStart))
+    {
+        return pStart;
+    }
+    else
+    {
+        DevMsg("No valid spawn point found.\n");
+        return BaseClass::Instance(INDEXENT(0));
+    }
+}
+
+bool CMomentumPlayer::SelectSpawnSpot(const char *pEntClassName, CBaseEntity* &pStart)
+{
+#define SF_PLAYER_START_MASTER 1
+    pStart = gEntList.FindEntityByClassname(pStart, pEntClassName);
+    if (pStart == NULL) // skip over the null point
+        pStart = gEntList.FindEntityByClassname(pStart, pEntClassName);
+    CBaseEntity *pLast;
+    pLast = NULL;
+    while (pStart != NULL)
+    {
+        if (g_pGameRules->IsSpawnPointValid(pStart, this))
+        {
+            if (pStart->HasSpawnFlags(SF_PLAYER_START_MASTER))
+            {
+                g_pLastSpawn = pStart;
+                return true;
+            }
+        }
+        pLast = pStart;
+        pStart = gEntList.FindEntityByClassname(pStart, pEntClassName);
+    }
+    if (pLast)
+    {
+        g_pLastSpawn = pLast;
+        pStart = pLast;
+        return true;
+    }
+
+    return false;
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mom_player.h b/mp/src/game/server/momentum/mom_player.h
new file mode 100644
index 000000000..6f9ee121b
--- /dev/null
+++ b/mp/src/game/server/momentum/mom_player.h
@@ -0,0 +1,95 @@
+#ifndef MOMPLAYER_H
+#define MOMPLAYER_H
+#ifdef WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+#include "player.h"
+#include "momentum/mom_shareddefs.h"
+
+class CMomentumPlayer : public CBasePlayer
+{
+public:
+
+    DECLARE_CLASS(CMomentumPlayer, CBasePlayer);
+
+    CMomentumPlayer();
+    ~CMomentumPlayer(void);
+
+    static CMomentumPlayer *CreatePlayer(const char *className, edict_t *ed)
+    {
+        CMomentumPlayer::s_PlayerEdict = ed;
+        return (CMomentumPlayer*) CreateEntityByName(className);
+    }
+
+    DECLARE_SERVERCLASS();
+    DECLARE_DATADESC();
+
+    int FlashlightIsOn() { return IsEffectActive(EF_DIMLIGHT); }
+
+    void FlashlightTurnOn()
+    { 
+        AddEffects(EF_DIMLIGHT);
+        EmitSound("HL2Player.FlashLightOn");//MOM_TODO: change this?
+    }
+
+    void FlashlightTurnOff()
+    {
+        RemoveEffects(EF_DIMLIGHT);
+        EmitSound("HL2Player.FlashLightOff");//MOM_TODO: change this?
+    }
+
+    bool CanBreatheUnderwater() const { return true; }
+
+    // LADDERS
+    void SurpressLadderChecks(const Vector& pos, const Vector& normal);
+    bool CanGrabLadder(const Vector& pos, const Vector& normal);
+    Vector m_lastStandingPos; // used by the gamemovement code for finding ladders
+
+    //SPAWNING
+    CBaseEntity* EntSelectSpawnPoint();
+
+    CNetworkVar(int, m_iShotsFired);
+    CNetworkVar(int, m_iDirection);
+    CNetworkVar(bool, m_bResumeZoom);
+    CNetworkVar(int, m_iLastZoom);
+
+    void GetBulletTypeParameters(
+        int iBulletType,
+        float &fPenetrationPower,
+        float &flPenetrationDistance);
+
+    void FireBullet(
+        Vector vecSrc,
+        const QAngle &shootAngles,
+        float vecSpread,
+        float flDistance,
+        int iPenetration,
+        int iBulletType,
+        int iDamage,
+        float flRangeModifier,
+        CBaseEntity *pevAttacker,
+        bool bDoEffects,
+        float x,
+        float y);
+
+    void KickBack(
+        float up_base,
+        float lateral_base,
+        float up_modifier,
+        float lateral_modifier,
+        float up_max,
+        float lateral_max,
+        int direction_change);
+
+private:
+    CountdownTimer m_ladderSurpressionTimer;
+    Vector m_lastLadderNormal;
+    Vector m_lastLadderPos;
+    EHANDLE g_pLastSpawn;
+    bool SelectSpawnSpot(const char *pEntClassName, CBaseEntity* &pSpot);
+    friend class CMomentumGameMovement;
+
+};
+#endif //MOMPLAYER_H
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mom_triggers.cpp b/mp/src/game/server/momentum/mom_triggers.cpp
new file mode 100644
index 000000000..ab1b43bd3
--- /dev/null
+++ b/mp/src/game/server/momentum/mom_triggers.cpp
@@ -0,0 +1,547 @@
+#include "cbase.h"
+#include "Timer.h"
+#include "mom_triggers.h"
+#include "movevars_shared.h"
+#include "in_buttons.h"
+
+#include "tier0/memdbgon.h"
+
+// CBaseMomentumTrigger
+void CBaseMomentumTrigger::Spawn()
+{
+    BaseClass::Spawn();
+    // temporary
+    m_debugOverlays |= (OVERLAY_BBOX_BIT | OVERLAY_TEXT_BIT);
+}
+
+//---------- CTriggerStage -----------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_timer_stage, CTriggerStage);
+
+BEGIN_DATADESC(CTriggerStage)
+DEFINE_KEYFIELD(m_iStageNumber, FIELD_INTEGER, "stage")
+END_DATADESC()
+
+void CTriggerStage::StartTouch(CBaseEntity *pOther)
+{
+    BaseClass::StartTouch(pOther);
+    if (pOther->IsPlayer())
+    {
+        g_Timer.SetCurrentStage(this);
+    }
+}
+//------------------------------------------------------------------------------------------
+
+//---------- CTriggerTimerStart ------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_timer_start, CTriggerTimerStart);
+
+BEGIN_DATADESC(CTriggerTimerStart)
+DEFINE_KEYFIELD(m_fMaxLeaveSpeed, FIELD_FLOAT, "leavespeed"),
+DEFINE_KEYFIELD(m_angLook, FIELD_VECTOR, "lookangles")
+END_DATADESC()
+
+void CTriggerTimerStart::EndTouch(CBaseEntity *pOther)
+{
+    ConVarRef cheatsRef("sv_cheats");
+    if (pOther->IsPlayer()) 
+    {  //do not start timer if player is in practice mode or has cheats on
+        if (!cheatsRef.GetBool() && pOther->GetMoveType() != MOVETYPE_NOCLIP)
+        { 
+            g_Timer.Start(gpGlobals->tickcount);
+
+            if (IsLimitingSpeed())
+            {
+                Vector velocity = pOther->GetAbsVelocity();
+                if (IsLimitingSpeedOnlyXY())
+                {
+                    Vector2D vel2D = velocity.AsVector2D();
+                    if (velocity.AsVector2D().IsLengthGreaterThan(m_fMaxLeaveSpeed))
+                    {
+                        // Isn't it nice how Vector2D.h doesn't have Normalize() on it?
+                        // It only has a NormalizeInPlace... Not simple enough for me
+                        vel2D = ((vel2D / vel2D.Length()) * m_fMaxLeaveSpeed);
+                        pOther->SetAbsVelocity(Vector(vel2D.x, vel2D.y, velocity.z));
+                    }
+                }
+                else
+                {
+                    if (velocity.IsLengthGreaterThan(m_fMaxLeaveSpeed))
+                    {
+                        pOther->SetAbsVelocity(velocity.Normalized() * m_fMaxLeaveSpeed);
+                    }
+                }
+            }
+        }
+        else
+            DevWarning("You must turn off cheats or practice mode to start the timer!\n");
+    }
+    BaseClass::EndTouch(pOther);
+}
+
+void CTriggerTimerStart::StartTouch(CBaseEntity *pOther)
+{
+    g_Timer.SetStartTrigger(this);
+    if (pOther->IsPlayer() && g_Timer.IsRunning())
+    {
+        g_Timer.Stop(false);
+        g_Timer.DispatchResetMessage();
+    }
+    BaseClass::StartTouch(pOther);
+}
+
+void CTriggerTimerStart::Spawn()
+{
+    BaseClass::Spawn();
+    // We don't want negative velocities (We're checking against an absolute value)
+    if (m_fMaxLeaveSpeed < 0)
+        m_fMaxLeaveSpeed *= (-1);
+
+    m_angLook.z = 0.0f; // Reset roll since mappers will never stop ruining everything.
+}
+
+void CTriggerTimerStart::SetMaxLeaveSpeed(float pMaxLeaveSpeed)
+{
+    if (pMaxLeaveSpeed < 0)
+        pMaxLeaveSpeed *= (-1.0f);
+    m_fMaxLeaveSpeed = pMaxLeaveSpeed;
+}
+
+void CTriggerTimerStart::SetIsLimitingSpeed(bool pIsLimitingSpeed)
+{
+    if (pIsLimitingSpeed)
+    {
+        if (!HasSpawnFlags(SF_LIMIT_LEAVE_SPEED))
+        {
+            AddSpawnFlags(SF_LIMIT_LEAVE_SPEED);
+        }
+    }
+    else
+    {
+        if (HasSpawnFlags(SF_LIMIT_LEAVE_SPEED))
+        {
+            RemoveSpawnFlags(SF_LIMIT_LEAVE_SPEED);
+        }
+    }
+}
+
+void CTriggerTimerStart::SetIsLimitingSpeedOnlyXY(bool pIsLimitingSpeedOnlyXY)
+{
+    if (pIsLimitingSpeedOnlyXY)
+    {
+        if (!HasSpawnFlags(SF_LIMIT_LEAVE_SPEED_ONLYXY))
+        {
+            AddSpawnFlags(SF_LIMIT_LEAVE_SPEED_ONLYXY);
+        }
+    }
+    else
+    {
+        if (HasSpawnFlags(SF_LIMIT_LEAVE_SPEED_ONLYXY))
+        {
+            RemoveSpawnFlags(SF_LIMIT_LEAVE_SPEED_ONLYXY);
+        }
+    }
+}
+
+void CTriggerTimerStart::SetHasLookAngles(bool bHasLook)
+{
+    if (bHasLook)
+    {
+        if (!HasSpawnFlags(SF_USE_LOOKANGLES))
+        {
+            AddSpawnFlags(SF_USE_LOOKANGLES);
+        }
+    }
+    else
+    {
+        if (HasSpawnFlags(SF_USE_LOOKANGLES))
+        {
+            RemoveSpawnFlags(SF_USE_LOOKANGLES);
+        }
+    }
+}
+
+void CTriggerTimerStart::SetLookAngles(QAngle newang)
+{
+    m_angLook = newang;
+}
+//----------------------------------------------------------------------------------------------
+
+//----------- CTriggerTimerStop ----------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_timer_stop, CTriggerTimerStop);
+
+void CTriggerTimerStop::StartTouch(CBaseEntity *pOther)
+{
+    ConVarRef cheatsRef("sv_cheats");
+    BaseClass::StartTouch(pOther);
+    // If timer is already stopped, there's nothing to stop (No run state effect to play)
+    if (pOther->IsPlayer() && g_Timer.IsRunning())
+    {
+        if (!cheatsRef.GetBool())
+            g_Timer.Stop(true);
+        else
+            DevWarning("You must turn off cheats to use the timer!\n");
+    }
+}
+//----------------------------------------------------------------------------------------------
+
+//---------- CTriggerCheckpoint ----------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_timer_checkpoint, CTriggerCheckpoint);
+
+BEGIN_DATADESC(CTriggerCheckpoint)
+DEFINE_KEYFIELD(m_iCheckpointNumber, FIELD_INTEGER, "checkpoint"),
+END_DATADESC()
+
+void CTriggerCheckpoint::StartTouch(CBaseEntity *pOther)
+{
+    BaseClass::StartTouch(pOther);
+    if (pOther->IsPlayer())
+    {
+        g_Timer.SetCurrentCheckpointTrigger(this);
+        g_Timer.RemoveAllOnehopsFromList();
+    }
+}
+//----------------------------------------------------------------------------------------------
+
+//------------- CFilterCheckpoint --------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(filter_activator_checkpoint, CFilterCheckpoint);
+
+BEGIN_DATADESC(CFilterCheckpoint)
+DEFINE_KEYFIELD(m_iCheckpointNumber, FIELD_INTEGER, "checkpoint")
+END_DATADESC()
+
+bool CFilterCheckpoint::PassesFilterImpl(CBaseEntity *pCaller, CBaseEntity *pEntity)
+{
+    return (g_Timer.GetCurrentCheckpoint() &&
+        g_Timer.GetCurrentCheckpoint()->GetCheckpointNumber() >= m_iCheckpointNumber);
+}
+//----------------------------------------------------------------------------------------------
+
+//----------- CTriggerTeleport -----------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_teleport, CTriggerTeleportEnt);
+
+
+BEGIN_DATADESC(CTriggerTeleportEnt)
+DEFINE_KEYFIELD(m_bResetVelocity, FIELD_BOOLEAN, "stop"),
+DEFINE_KEYFIELD(m_bResetAngles, FIELD_BOOLEAN, "resetang")
+END_DATADESC()
+
+void CTriggerTeleportEnt::StartTouch(CBaseEntity *pOther)
+{
+    if (pOther)
+    {
+        BaseClass::StartTouch(pOther);
+
+        if (!pDestinationEnt)
+        {
+            if (m_target != NULL_STRING)
+                pDestinationEnt = gEntList.FindEntityByName(NULL, m_target, NULL, pOther, pOther);
+            else
+            {
+                DevWarning("CTriggerTeleport cannot teleport, pDestinationEnt and m_target are null!\n");
+                return;
+            }
+        }
+
+        if (!PassesTriggerFilters(pOther)) return;
+
+        if (pDestinationEnt)//ensuring not null
+        {
+            Vector tmp = pDestinationEnt->GetAbsOrigin();
+            // make origin adjustments. (origin in center, not at feet)
+            tmp.z -= pOther->WorldAlignMins().z;
+
+            pOther->Teleport(&tmp, m_bResetAngles ? &pDestinationEnt->GetAbsAngles() : NULL, m_bResetVelocity ? &vec3_origin : NULL);
+            AfterTeleport();
+        }
+    }
+}
+//----------------------------------------------------------------------------------------------
+
+//----------- CTriggerTeleportCheckpoint -------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_teleport_checkpoint, CTriggerTeleportCheckpoint);
+
+
+void CTriggerTeleportCheckpoint::StartTouch(CBaseEntity *pOther)
+{
+    SetDestinationEnt(g_Timer.GetCurrentCheckpoint());
+    BaseClass::StartTouch(pOther);
+}
+//-----------------------------------------------------------------------------------------------
+
+//------------ CTriggerOnehop -------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_onehop, CTriggerOnehop);
+
+BEGIN_DATADESC(CTriggerOnehop)
+DEFINE_KEYFIELD(m_fMaxHoldSeconds, FIELD_FLOAT, "hold")
+END_DATADESC()
+
+void CTriggerOnehop::StartTouch(CBaseEntity *pOther)
+{
+    SetDestinationEnt(NULL);
+    BaseClass::StartTouch(pOther);
+    //The above is needed for the Think() function of this class,
+    //it's very HACKHACK but it works
+
+    if (pOther->IsPlayer())
+    {
+        m_fStartTouchedTime = gpGlobals->realtime;
+        if (g_Timer.FindOnehopOnList(this) != (-1))
+        {
+            SetDestinationEnt(g_Timer.GetCurrentCheckpoint());
+            BaseClass::StartTouch(pOther);
+        }
+        else
+        {
+            if (g_Timer.GetOnehopListCount() > 0)
+            {
+                // I don't know if Count gets updated for each for, so better be safe than sorry
+                // This method shouldn't be slow. Isn't it?
+                int c_MaxCount = g_Timer.GetOnehopListCount();
+                for (int iIndex = 0; iIndex < c_MaxCount; iIndex++)
+                {
+                    CTriggerOnehop *thisOnehop = g_Timer.FindOnehopOnList(iIndex);
+                    if (thisOnehop != NULL && thisOnehop->HasSpawnFlags(SF_TELEPORT_RESET_ONEHOP))
+                        g_Timer.RemoveOnehopFromList(thisOnehop);
+                }
+            }
+            g_Timer.AddOnehopToListTail(this);
+        }
+    }
+}
+
+void CTriggerOnehop::Think()
+{
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+    if (pPlayer != NULL && m_fStartTouchedTime > 0)
+    {
+        if (IsTouching(pPlayer) && (gpGlobals->realtime - m_fStartTouchedTime >= m_fMaxHoldSeconds))
+        {
+            SetDestinationEnt(g_Timer.GetCurrentCheckpoint());
+            BaseClass::StartTouch(pPlayer);
+        }
+    }
+}
+//-----------------------------------------------------------------------------------------------
+
+//------- CTriggerResetOnehop -------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_resetonehop, CTriggerResetOnehop);
+
+void CTriggerResetOnehop::StartTouch(CBaseEntity *pOther)
+{
+    BaseClass::StartTouch(pOther);
+    if (pOther->IsPlayer())
+        g_Timer.RemoveAllOnehopsFromList();
+}
+//-----------------------------------------------------------------------------------------------
+
+//---------- CTriggerMultihop -------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_multihop, CTriggerMultihop);
+
+BEGIN_DATADESC(CTriggerMultihop)
+DEFINE_KEYFIELD(m_fMaxHoldSeconds, FIELD_FLOAT, "hold")
+END_DATADESC()
+
+void CTriggerMultihop::StartTouch(CBaseEntity *pOther)
+{
+    BaseClass::StartTouch(pOther);
+    if (pOther->IsPlayer())
+    {
+        m_fStartTouchedTime = gpGlobals->realtime;
+    }
+}
+
+void CTriggerMultihop::EndTouch(CBaseEntity* pOther)
+{
+    // We don't want to keep checking for tp
+    m_fStartTouchedTime = -1.0f;
+    BaseClass::EndTouch(pOther);
+}
+
+void CTriggerMultihop::Think()
+{
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+    if (pPlayer != NULL && m_fStartTouchedTime > 0)
+    {
+        if (IsTouching(pPlayer) && (gpGlobals->realtime - m_fStartTouchedTime >= m_fMaxHoldSeconds))
+        {
+            SetDestinationEnt(g_Timer.GetCurrentCheckpoint());
+            BaseClass::StartTouch(pPlayer);
+        }
+    }
+}
+//-----------------------------------------------------------------------------------------------
+
+//--------- CTriggerUserInput -------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_userinput, CTriggerUserInput);
+
+BEGIN_DATADESC(CTriggerUserInput)
+DEFINE_KEYFIELD(m_eKey, FIELD_INTEGER, "lookedkey"),
+DEFINE_OUTPUT(m_OnKeyPressed, "OnKeyPressed"),
+END_DATADESC()
+
+void CTriggerUserInput::Think()
+{
+    CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
+    if (pPlayer != NULL && IsTouching(pPlayer) && (pPlayer->m_nButtons & m_ButtonRep))
+    {
+        m_OnKeyPressed.FireOutput(pPlayer, this);
+    }
+    BaseClass::Think();
+}
+
+void CTriggerUserInput::Spawn()
+{
+    switch (m_eKey)
+    {
+    case forward:
+        m_ButtonRep = IN_FORWARD;
+        break;
+    case back:
+        m_ButtonRep = IN_BACK;
+        break;
+    case moveleft:
+        m_ButtonRep = IN_MOVELEFT;
+        break;
+    case moveright:
+        m_ButtonRep = IN_MOVERIGHT;
+        break;
+    case jump:
+        m_ButtonRep = IN_JUMP;
+        break;
+    case duck:
+        m_ButtonRep = IN_DUCK;
+        break;
+    case attack:
+        m_ButtonRep = IN_ATTACK;
+        break;
+    case attack2:
+        m_ButtonRep = IN_ATTACK2;
+        break;
+    case reload:
+        m_ButtonRep = IN_RELOAD;
+        break;
+    default:
+        DevWarning("Passed unhandled key press\n");
+        break;
+    }
+    BaseClass::Spawn();
+}
+//-----------------------------------------------------------------------------------------------
+
+//---------- CFuncShootBoost --------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(func_shootboost, CFuncShootBoost);
+
+BEGIN_DATADESC(CFuncShootBoost)
+DEFINE_KEYFIELD(m_vPushDir, FIELD_VECTOR, "pushdir"),
+DEFINE_KEYFIELD(m_fPushForce, FIELD_FLOAT, "force"),
+DEFINE_KEYFIELD(m_iIncrease, FIELD_INTEGER, "increase"),
+END_DATADESC()
+
+void CFuncShootBoost::Spawn()
+{
+    BaseClass::Spawn();
+    // temporary
+    m_debugOverlays |= (OVERLAY_BBOX_BIT | OVERLAY_TEXT_BIT);
+    if (m_target != NULL_STRING)
+        m_Destination = gEntList.FindEntityByName(NULL, m_target);
+}
+
+int CFuncShootBoost::OnTakeDamage(const CTakeDamageInfo &info)
+{
+    CBaseEntity *pInflictor = info.GetAttacker();
+    if (pInflictor)
+    {
+        Vector finalVel = m_vPushDir.Normalized() * m_fPushForce;
+        switch (m_iIncrease)
+        {
+        case 0:
+            break;
+        case 1:
+            finalVel += pInflictor->GetAbsVelocity();
+            break;
+        case 2:
+            if (finalVel.LengthSqr() < pInflictor->GetAbsVelocity().LengthSqr())
+                finalVel = pInflictor->GetAbsVelocity();
+            break;
+        case 3: // The description of this method says the player velocity is increaed by final velocity,
+            // but we're just adding one vec to the other, which is not quite the same
+            if (finalVel.LengthSqr() < pInflictor->GetAbsVelocity().LengthSqr())
+                finalVel += pInflictor->GetAbsVelocity();
+            break;
+        case 4:
+            pInflictor->SetBaseVelocity(finalVel);
+            break;
+        default:
+            DevWarning("CFuncShootBoost:: %i not recognised as valid for m_iIncrease", m_iIncrease);
+            break;
+        }
+        if (m_Destination)
+        {
+            if (((CBaseTrigger *) m_Destination)->IsTouching(pInflictor))
+            {
+                pInflictor->SetAbsVelocity(finalVel);
+            }
+        }
+        else
+        {
+            pInflictor->SetAbsVelocity(finalVel);
+        }
+    }
+    // As we don't want to break it, we don't call BaseClass::OnTakeDamage(info);
+    // OnTakeDamage returns the damage dealt
+    return info.GetDamage();
+}
+//-----------------------------------------------------------------------------------------------
+
+//---------- CTriggerMomentumPush ---------------------------------------------------------------
+LINK_ENTITY_TO_CLASS(trigger_momentum_push, CTriggerMomentumPush);
+
+BEGIN_DATADESC(CTriggerMomentumPush)
+DEFINE_KEYFIELD(m_vPushDir, FIELD_VECTOR, "pushdir"),
+DEFINE_KEYFIELD(m_fPushForce, FIELD_FLOAT, "force"),
+DEFINE_KEYFIELD(m_iIncrease, FIELD_INTEGER, "increase"),
+END_DATADESC()
+
+void CTriggerMomentumPush::StartTouch(CBaseEntity *pOther)
+{
+    if (pOther && HasSpawnFlags(SF_PUSH_ONSTART) && pOther->IsPlayer())
+        OnSuccessfulTouch(pOther);
+}
+
+void CTriggerMomentumPush::EndTouch(CBaseEntity *pOther)
+{
+    if (pOther && HasSpawnFlags(SF_PUSH_ONEND) && pOther->IsPlayer())
+        OnSuccessfulTouch(pOther);
+}
+
+void CTriggerMomentumPush::OnSuccessfulTouch(CBaseEntity *pOther)
+{
+    if (pOther)
+    {
+        Vector finalVel;
+        if (HasSpawnFlags(SF_PUSH_DIRECTION_AS_FINAL_FORCE))
+            finalVel = m_vPushDir;
+        else
+            finalVel = m_vPushDir.Normalized() * m_fPushForce;
+        switch (m_iIncrease)
+        {
+        case 0:
+            break;
+        case 1:
+            finalVel += pOther->GetAbsVelocity();
+            break;
+        case 2:
+            if (finalVel.LengthSqr() < pOther->GetAbsVelocity().LengthSqr())
+                finalVel = pOther->GetAbsVelocity();
+            break;
+        case 3:
+            pOther->SetBaseVelocity(finalVel);
+            break;
+        default:
+            DevWarning("CTriggerMomentumPush:: %i not recognised as valid for m_iIncrease", m_iIncrease);
+            break;
+        }
+
+        pOther->SetAbsVelocity(finalVel);
+    }
+}
+//-----------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/mom_triggers.h b/mp/src/game/server/momentum/mom_triggers.h
new file mode 100644
index 000000000..819842902
--- /dev/null
+++ b/mp/src/game/server/momentum/mom_triggers.h
@@ -0,0 +1,293 @@
+#ifndef TIMERTRIGGERS_H
+#define TIMERTRIGGERS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "triggers.h"
+#include "filters.h"
+#include "func_break.h"
+
+// CBaseMomentumTrigger
+class CBaseMomentumTrigger : public CTriggerMultiple
+{
+    DECLARE_CLASS(CBaseMomentumTrigger, CTriggerMultiple);
+
+public:
+    virtual void Spawn();
+};
+
+// CTriggerTimerStop
+class CTriggerTimerStop : public CBaseMomentumTrigger
+{
+    DECLARE_CLASS(CTriggerTimerStop, CBaseMomentumTrigger);
+
+public:
+    void StartTouch(CBaseEntity*);
+};
+
+// CTriggerTeleportEnt
+class CTriggerTeleportEnt : public CBaseMomentumTrigger
+{
+    DECLARE_CLASS(CTriggerTeleportEnt, CBaseMomentumTrigger);
+    DECLARE_DATADESC();
+
+public:
+    //This void teleports the touching entity!
+    void StartTouch(CBaseEntity*);
+    // Used by children classes to define what ent to teleport to (see CTriggerOneHop)
+    void SetDestinationEnt(CBaseEntity *ent) { pDestinationEnt = ent; }
+    bool ShouldStopPlayer() { return m_bResetVelocity; }
+    bool ShouldResetAngles() { return m_bResetAngles; }
+    void SetShouldStopPlayer(bool newB) { m_bResetVelocity = newB; }
+    void SetShouldResetAngles(bool newB) { m_bResetAngles = newB; }
+
+    virtual void AfterTeleport() {};//base class does nothing
+
+private:
+    bool m_bResetVelocity;
+    bool m_bResetAngles;
+    CBaseEntity *pDestinationEnt;
+};
+
+// CTriggerCheckpoint, used by mappers for teleporting 
+class CTriggerCheckpoint : public CBaseMomentumTrigger
+{
+    DECLARE_CLASS(CTriggerCheckpoint, CBaseMomentumTrigger);
+    DECLARE_DATADESC();
+
+public:
+    void StartTouch(CBaseEntity*);
+    // the following is only used by CFilterCheckpoint
+    virtual int GetCheckpointNumber() { return m_iCheckpointNumber; }
+    // The following is used by mapzones.cpp
+    void SetCheckpointNumber(int newInt) { m_iCheckpointNumber = newInt; }
+
+private:
+    int m_iCheckpointNumber;
+};
+
+// CTriggerStage
+// used to declare which major part of the map the player has gotten to
+class CTriggerStage : public CTriggerCheckpoint
+{
+    DECLARE_CLASS(CTriggerStage, CTriggerCheckpoint);
+    DECLARE_DATADESC();
+
+public:
+    void StartTouch(CBaseEntity*);
+    void Spawn()
+    {
+        SetCheckpointNumber(-1);
+        BaseClass::Spawn();
+    }
+    //Used by CTimer and CStageFilter
+    virtual int GetStageNumber() { return m_iStageNumber; }
+    void SetStageNumber(int newInt) { m_iStageNumber = newInt; }
+    int GetCheckpointNumber() { return -1; }//Override, use GetStageNumber()
+
+private:
+    int m_iStageNumber;
+};
+
+// CTriggerTimerStart
+class CTriggerTimerStart : public CTriggerStage
+{
+    DECLARE_CLASS(CTriggerTimerStart, CTriggerStage);
+    DECLARE_DATADESC();
+
+public:
+    void EndTouch(CBaseEntity*);
+    void StartTouch(CBaseEntity*);
+    void Spawn();
+    // The start is always the first stage/checkpoint
+    int GetCheckpointNumber() { return -1; }//Override
+    int GetStageNumber() { return 1; }
+    float GetMaxLeaveSpeed() { return m_fMaxLeaveSpeed; }
+    void SetMaxLeaveSpeed(float pMaxSpeed);
+    bool IsLimitingSpeed() { return HasSpawnFlags(SF_LIMIT_LEAVE_SPEED); }
+    void SetIsLimitingSpeed(bool pIsLimitingSpeed);
+    bool IsLimitingSpeedOnlyXY() { return HasSpawnFlags(SF_LIMIT_LEAVE_SPEED_ONLYXY); }
+    void SetIsLimitingSpeedOnlyXY(bool pIsLimitingSpeedOnlyXY);
+
+    void SetHasLookAngles(bool bHasLook);
+    bool GetHasLookAngles() { return HasSpawnFlags(SF_USE_LOOKANGLES); }
+    void SetLookAngles(QAngle newang);
+    QAngle GetLookAngles() { return m_angLook; }
+
+private:
+    QAngle m_angLook = QAngle(0, 0, 0);
+
+    // How fast can the player leave the start trigger?
+    float m_fMaxLeaveSpeed = 280;
+
+    // MOM_TODO: Why aren't these defines?
+
+    // Limit max leave speed to m_fMaxLeaveSpeed?
+    const int SF_LIMIT_LEAVE_SPEED = 0x2;
+    // Use look angles?
+    const int SF_USE_LOOKANGLES = 0x4;
+    // Limit speed without taking into account hvel (Z axis)
+    const int SF_LIMIT_LEAVE_SPEED_ONLYXY = 0x8;
+};
+
+// CFilterCheckpoint
+class CFilterCheckpoint : public CBaseFilter
+{
+    DECLARE_CLASS(CFilterCheckpoint, CBaseFilter);
+    DECLARE_DATADESC();
+
+public:
+    bool PassesFilterImpl(CBaseEntity*, CBaseEntity*);
+
+private:
+    int m_iCheckpointNumber;
+
+};
+
+// CTriggerTeleportCheckpoint
+class CTriggerTeleportCheckpoint : public CTriggerTeleportEnt
+{
+    DECLARE_CLASS(CTriggerTeleportCheckpoint, CTriggerTeleportEnt);
+
+public:
+    void StartTouch(CBaseEntity*);
+};
+
+// CTriggerOnehop
+class CTriggerOnehop : public CTriggerTeleportEnt
+{
+    DECLARE_CLASS(CTriggerOnehop, CTriggerTeleportEnt);
+    DECLARE_DATADESC();
+
+public:
+    void StartTouch(CBaseEntity*);
+    float GetHoldTeleportTime() { return m_fMaxHoldSeconds; }
+    void SetHoldTeleportTime(float pHoldTime) { m_fMaxHoldSeconds = pHoldTime; }
+    void Think();
+    void AfterTeleport() { m_fStartTouchedTime = -1.0f; SetDestinationEnt(NULL); }
+
+private:
+    // The time that the player initally touched the trigger
+    float m_fStartTouchedTime = 0.0f;
+    // Seconds to hold before activating the teleport
+    float m_fMaxHoldSeconds = 1;
+    // Reset hop state if player hops onto another different onehop
+    const int SF_TELEPORT_RESET_ONEHOP = 0x2;
+
+};
+
+// CTriggerResetOnehop
+class CTriggerResetOnehop : public CBaseMomentumTrigger
+{
+    DECLARE_CLASS(CTriggerResetOnehop, CBaseMomentumTrigger);
+
+public:
+    void StartTouch(CBaseEntity*);
+
+};
+
+// CTriggerMultihop
+class CTriggerMultihop : public CTriggerTeleportEnt
+{
+    DECLARE_CLASS(CTriggerMultihop, CTriggerTeleportEnt);
+    DECLARE_DATADESC();
+
+public:
+    void StartTouch(CBaseEntity*);
+    void EndTouch(CBaseEntity*);
+    float GetHoldTeleportTime() { return m_fMaxHoldSeconds; }
+    void SetHoldTeleportTime(float pHoldTime) { m_fMaxHoldSeconds = pHoldTime; }
+    void Think();
+    void AfterTeleport() { m_fStartTouchedTime = -1.0f; SetDestinationEnt(NULL); }
+
+private:
+    // The time that the player initally touched the trigger. -1 if not checking for teleport
+    float m_fStartTouchedTime = 0.0f;
+    // Seconds to hold before activating the teleport
+    float m_fMaxHoldSeconds = 1;
+
+};
+
+// CTriggerUserInput
+class CTriggerUserInput : public CBaseMomentumTrigger
+{
+    DECLARE_CLASS(CTriggerUserInput, CBaseMomentumTrigger);
+    DECLARE_DATADESC();
+
+public:
+    enum key { forward, back, moveleft, moveright, jump, duck, attack, attack2, reload };
+    key m_eKey;
+    void Think();
+    void Spawn();
+    COutputEvent m_OnKeyPressed;
+
+private:
+    int m_ButtonRep;
+
+};
+
+// CFuncShootBoost
+class CFuncShootBoost : public CBreakable
+{
+    DECLARE_CLASS(CFuncShootBoost, CBreakable);
+    DECLARE_DATADESC();
+
+public:
+    void Spawn();
+    int OnTakeDamage(const CTakeDamageInfo &info);
+    // Force in units per seconds applied to the player
+    float m_fPushForce;
+    // 0: No
+    // 1: Yes
+    // 2: Only if the player's velocity is lower than the push velocity, set player's velocity to final push velocity
+    // 3: Only if the player's velocity is lower than the push velocity, increase player's velocity by final push velocity
+    int m_iIncrease;
+    // Dictates the direction of push
+    Vector m_vPushDir;
+    // If not null, dictates which entity the attacker must be touching for the func to work
+    CBaseEntity *m_Destination;
+    // Use the direction vector as final force instead of calculating it by force amount
+    const int SF_PUSH_DIRECTION_AS_FINAL_FORCE = 0x2;
+};
+
+// CTriggerMomentumPush
+class CTriggerMomentumPush : public CTriggerTeleportEnt
+{
+    DECLARE_CLASS(CTriggerMomentumPush, CTriggerTeleportEnt);
+    DECLARE_DATADESC();
+
+public:
+    void StartTouch(CBaseEntity*);
+    void EndTouch(CBaseEntity*);
+    // Called when (and by) either a StartTouch() or EndTouch() event happens and their requisites are met
+    void OnSuccessfulTouch(CBaseEntity*);
+    float GetHoldTeleportTime() { return m_fMaxHoldSeconds; }
+    void SetHoldTeleportTime(float pHoldTime) { m_fMaxHoldSeconds = pHoldTime; }
+    void AfterTeleport() { m_fStartTouchedTime = -1.0f; SetDestinationEnt(NULL); }
+
+private:
+    // The time that the player initally touched the trigger
+    float m_fStartTouchedTime = 0.0f;
+    // Seconds to hold before activating the teleport
+    float m_fMaxHoldSeconds = 1;
+    // Force in units per seconds applied to the player
+    float m_fPushForce;
+    // 1: SetPlayerVelocity to final push force
+    // 2: Increase player's current velocity by push final foce ammount // This is almost like the default trigger_push behaviour
+    // 3: Only set the player's velocity to the final push velocity if player's velocity is lower than final push velocity
+    int m_iIncrease;
+    // Dictates the direction of push
+    Vector m_vPushDir;
+    // Pointer to the destination entity if a teleport is needed
+    CBaseEntity *m_Destination;
+    // Only allow for one touch
+    const int SF_PUSH_ONETOUCH = 0x2;
+    // Modify player velocity on StartTouch
+    const int SF_PUSH_ONSTART = 0x4;
+    // Modify player velocity on EndTouch
+    const int SF_PUSH_ONEND = 0x8;
+    // Use the direction vector as final force instead of calculating it by force amount
+    const int SF_PUSH_DIRECTION_AS_FINAL_FORCE = 0x16;
+};
+#endif // TIMERTRIGGERS_H
diff --git a/mp/src/game/server/momentum/server_events.cpp b/mp/src/game/server/momentum/server_events.cpp
new file mode 100644
index 000000000..0fb20afb8
--- /dev/null
+++ b/mp/src/game/server/momentum/server_events.cpp
@@ -0,0 +1,117 @@
+#include "cbase.h"
+#include "movevars_shared.h"
+#include "mapzones.h"
+#include "Timer.h"
+#include "mapzones_edit.h"
+#include "momentum/mom_shareddefs.h"
+
+#include "tier0/memdbgon.h"
+
+namespace Momentum
+{
+
+    CMapzoneData* zones;
+
+    void OnServerDLLInit()
+    {
+        TickSet::TickInit();
+        // MOM_TODO: connect to site
+    }
+
+    //This is only called when "map ____" is called, if the user uses changelevel then...
+    // \/(o_o)\/
+    void GameInit()
+    {
+        ConVarRef gm("mom_gamemode");
+        ConVarRef map("host_map");
+        const char *pMapName = map.GetString();
+        // This will only happen if the user didn't use the map selector to start a map
+
+        //set gamemode depending on map name
+        if (gm.GetInt() == MOMGM_UNKNOWN)
+        {
+            if (!Q_strnicmp(pMapName, "surf_", strlen("surf_")))
+            {
+                gm.SetValue(MOMGM_SURF);
+                //g_Timer.SetGameMode(MOMGM_SURF);
+            }
+            else if (!Q_strnicmp(pMapName, "bhop_", strlen("bhop_")))
+            {
+                DevLog("SETTING THE GAMEMODE!\n");
+                gm.SetValue(MOMGM_BHOP);
+                //DevLog("GOT TO #2 %i\n", m_iGameMode);
+
+                //g_Timer.SetGameMode(MOMGM_BHOP);
+            }
+            else if (!Q_strnicmp(pMapName, "kz_", strlen("kz_")))
+            {
+               DevLog("SETTING THE GAMEMODE!\n");
+               gm.SetValue(MOMGM_SCROLL);
+            }
+            else if (!Q_strcmp(pMapName, "background") || !Q_strcmp(pMapName, "credits"))
+            {
+                gm.SetValue(MOMGM_ALLOWED);
+            }
+            else
+            {
+                gm.SetValue(MOMGM_UNKNOWN);
+                //g_Timer.SetGameMode(MOMGM_UNKNOWN);
+            }
+            
+        }
+    }
+
+    void OnMapStart(const char *pMapName)
+    { 
+        // (Re-)Load zones
+        if (zones)
+        {
+            delete zones;
+            zones = NULL;
+        }
+        zones = new CMapzoneData(pMapName);
+        zones->SpawnMapZones();
+
+        //Setup timer
+        g_Timer.OnMapStart(pMapName);
+        
+        // Reset zone editing
+        g_MapzoneEdit.Reset();
+    }
+
+    void OnMapEnd(const char *pMapName)
+    {
+        // Unload zones
+        if (zones)
+        {
+            delete zones;
+            zones = NULL;
+        }
+
+        ConVarRef gm("mom_gamemode");
+        gm.SetValue(gm.GetDefault());
+
+        g_Timer.OnMapEnd(pMapName);
+    }
+
+    void OnGameFrameStart()
+    {
+        g_MapzoneEdit.Update();
+
+        if (!g_Timer.GotCaughtCheating())
+        {
+            ConVarRef cheatsRef = ConVarRef("sv_cheats");
+            if (cheatsRef.GetBool())
+            {
+                g_Timer.SetCheating(true);
+                g_Timer.Stop(false);
+            }
+
+        }
+    }
+
+    /*void OnGameFrameEnd()
+    {
+    }*/
+
+} // namespace Momentum
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/server_events.h b/mp/src/game/server/momentum/server_events.h
new file mode 100644
index 000000000..9ade5986a
--- /dev/null
+++ b/mp/src/game/server/momentum/server_events.h
@@ -0,0 +1,18 @@
+#ifndef SERVER_EVENTS_H
+#define SERVER_EVENTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+namespace Momentum {
+
+void OnServerDLLInit();
+void OnMapStart(const char *pMapName);
+void OnMapEnd(const char *pMapName);
+void OnGameFrameStart();
+void GameInit();
+//void OnGameFrameEnd();
+
+} // namespace Momentum
+
+#endif // SERVER_EVENTS_H
diff --git a/mp/src/game/server/momentum/smokegrenade_projectile.cpp b/mp/src/game/server/momentum/smokegrenade_projectile.cpp
new file mode 100644
index 000000000..4d5fad53c
--- /dev/null
+++ b/mp/src/game/server/momentum/smokegrenade_projectile.cpp
@@ -0,0 +1,186 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "smokegrenade_projectile.h"
+#include "sendproxy.h"
+#include "particle_smokegrenade.h"
+#include "mom_player.h"
+#include "KeyValues.h"
+//#include "bot_manager.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_smokegrenade_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS( smokegrenade_projectile, CSmokeGrenadeProjectile );
+PRECACHE_WEAPON_REGISTER( smokegrenade_projectile );
+
+BEGIN_DATADESC( CSmokeGrenadeProjectile )
+	DEFINE_THINKFUNC( Think_Detonate ),
+	DEFINE_THINKFUNC( Think_Fade ),
+	DEFINE_THINKFUNC( Think_Remove )
+END_DATADESC()
+
+
+CSmokeGrenadeProjectile* CSmokeGrenadeProjectile::Create( 
+	const Vector &position, 
+	const QAngle &angles, 
+	const Vector &velocity, 
+	const AngularImpulse &angVelocity, 
+	CBaseCombatCharacter *pOwner )
+{
+	CSmokeGrenadeProjectile *pGrenade = (CSmokeGrenadeProjectile*)CBaseEntity::Create( "smokegrenade_projectile", position, angles, pOwner );
+	
+	// Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+	// one second before detonation.
+	pGrenade->SetTimer( 1.5 );
+	pGrenade->SetAbsVelocity( velocity );
+	pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
+	pGrenade->SetThrower( pOwner );
+	pGrenade->SetGravity( 0.55 );
+	pGrenade->SetFriction( 0.7 );
+	pGrenade->m_flDamage = 100;
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+	pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );	
+	pGrenade->SetTouch( &CBaseGrenade::BounceTouch );
+
+	pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
+	pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
+	pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
+	pGrenade->m_bDidSmokeEffect = false;
+
+	return pGrenade;
+}
+
+
+void CSmokeGrenadeProjectile::SetTimer( float timer )
+{
+	SetThink( &CSmokeGrenadeProjectile::Think_Detonate );
+	SetNextThink( gpGlobals->curtime + timer );
+
+	//TheBots->SetGrenadeRadius( this, 0.0f );
+}
+
+void CSmokeGrenadeProjectile::Think_Detonate()
+{
+	if ( GetAbsVelocity().Length() > 0.1 )
+	{
+		// Still moving. Don't detonate yet.
+		SetNextThink( gpGlobals->curtime + 0.2 );
+		return;
+	}
+
+	//TheBots->SetGrenadeRadius( this, SmokeGrenadeRadius );
+
+	// Ok, we've stopped rolling or whatever. Now detonate.
+	ParticleSmokeGrenade *pGren = (ParticleSmokeGrenade*)CBaseEntity::Create( PARTICLESMOKEGRENADE_ENTITYNAME, GetAbsOrigin(), QAngle(0,0,0), NULL );
+	if ( pGren )
+	{
+		pGren->FillVolume();
+		pGren->SetFadeTime( 17, 22 );
+		pGren->SetAbsOrigin( GetAbsOrigin() );
+
+		//tell the hostages about the smoke!
+		CBaseEntity *pEntity = NULL;
+		variant_t var;	//send the location of the smoke?
+		var.SetVector3D( GetAbsOrigin() );
+		while ( ( pEntity = gEntList.FindEntityByClassname( pEntity, "hostage_entity" ) ) != NULL)
+		{
+			//send to hostages that have a resonable chance of being in it while its still smoking
+			if( (GetAbsOrigin() - pEntity->GetAbsOrigin()).Length() < 1000 )
+				pEntity->AcceptInput( "smokegrenade", this, this, var, 0 );
+		}
+
+		// tell the bots a smoke grenade has exploded
+		CMomentumPlayer *player = static_cast<CMomentumPlayer*>(GetThrower());
+		if ( player )
+		{
+			IGameEvent * event = gameeventmanager->CreateEvent( "smokegrenade_detonate" );
+			if ( event )
+			{
+				event->SetInt( "userid", player->GetUserID() );
+				event->SetFloat( "x", GetAbsOrigin().x );
+				event->SetFloat( "y", GetAbsOrigin().y );
+				event->SetFloat( "z", GetAbsOrigin().z );
+				gameeventmanager->FireEvent( event );
+			}
+		}
+	}
+
+	m_hSmokeEffect = pGren;
+	m_bDidSmokeEffect = true;
+
+	EmitSound( "BaseSmokeEffect.Sound" );
+
+	m_nRenderMode = kRenderTransColor;
+	SetNextThink( gpGlobals->curtime + 5 );
+	SetThink( &CSmokeGrenadeProjectile::Think_Fade );
+}
+
+
+// Fade the projectile out over time before making it disappear
+void CSmokeGrenadeProjectile::Think_Fade()
+{
+	SetNextThink( gpGlobals->curtime );
+
+	color32 c = GetRenderColor();
+	c.a -= 1;
+	SetRenderColor( c.r, c.b, c.g, c.a );
+
+	if ( !c.a )
+	{
+		//TheBots->RemoveGrenade( this );
+
+		SetModelName( NULL_STRING );//invisible
+		SetNextThink( gpGlobals->curtime + 20 );
+		SetThink( &CSmokeGrenadeProjectile::Think_Remove );	// Spit out smoke for 10 seconds.
+		SetSolid( SOLID_NONE );
+	}
+}
+
+
+void CSmokeGrenadeProjectile::Think_Remove()
+{
+	if ( m_hSmokeEffect.Get() )
+		UTIL_Remove( m_hSmokeEffect );
+
+	//TheBots->RemoveGrenade( this );
+
+	SetModelName( NULL_STRING );//invisible
+	SetSolid( SOLID_NONE );
+	SetMoveType( MOVETYPE_NONE );
+}
+
+//Implement this so we never call the base class,
+//but this should never be called either.
+void CSmokeGrenadeProjectile::Detonate( void )
+{
+	Assert(!"Smoke grenade handles its own detonation");
+}
+
+
+void CSmokeGrenadeProjectile::Spawn()
+{
+	SetModel( GRENADE_MODEL );
+	BaseClass::Spawn();
+}
+
+
+void CSmokeGrenadeProjectile::Precache()
+{
+	PrecacheModel( GRENADE_MODEL );
+	PrecacheScriptSound( "BaseSmokeEffect.Sound" );
+	PrecacheScriptSound( "SmokeGrenade.Bounce" );
+	BaseClass::Precache();
+}
+
+void CSmokeGrenadeProjectile::BounceSound( void )
+{
+	if ( !m_bDidSmokeEffect )
+	{
+		EmitSound( "SmokeGrenade.Bounce" );
+	}
+}
diff --git a/mp/src/game/server/momentum/smokegrenade_projectile.h b/mp/src/game/server/momentum/smokegrenade_projectile.h
new file mode 100644
index 000000000..701e39c9f
--- /dev/null
+++ b/mp/src/game/server/momentum/smokegrenade_projectile.h
@@ -0,0 +1,53 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "momentum/basecsgrenade_projectile.h"
+
+
+class CSmokeGrenadeProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CSmokeGrenadeProjectile, CBaseCSGrenadeProjectile );
+	DECLARE_DATADESC();
+
+// Overrides.
+public:
+	
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void Detonate();
+	virtual void BounceSound( void );
+
+	void Think_Detonate();
+	void Think_Fade();
+	void Think_Remove();
+
+
+// Grenade stuff.
+public:
+
+	static CSmokeGrenadeProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner );
+
+	void SetTimer( float timer );
+
+	EHANDLE m_hSmokeEffect;
+	bool m_bDidSmokeEffect;
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/mp/src/game/server/momentum/te_shotgun_shot.cpp b/mp/src/game/server/momentum/te_shotgun_shot.cpp
new file mode 100644
index 000000000..b55774e28
--- /dev/null
+++ b/mp/src/game/server/momentum/te_shotgun_shot.cpp
@@ -0,0 +1,86 @@
+#include "cbase.h"
+#include "basetempentity.h"
+
+
+#define NUM_BULLET_SEED_BITS 8
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Display's a blood sprite
+//-----------------------------------------------------------------------------
+class CTEFireBullets : public CBaseTempEntity
+{
+public:
+    DECLARE_CLASS(CTEFireBullets, CBaseTempEntity);
+    DECLARE_SERVERCLASS();
+
+    CTEFireBullets(const char *name);
+    virtual			~CTEFireBullets(void);
+
+public:
+    CNetworkVar(int, m_iPlayer);
+    CNetworkVector(m_vecOrigin);
+    CNetworkQAngle(m_vecAngles);
+    CNetworkVar(int, m_iWeaponID);
+    CNetworkVar(int, m_iMode);
+    CNetworkVar(int, m_iSeed);
+    CNetworkVar(float, m_flSpread);
+
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CTEFireBullets::CTEFireBullets(const char *name) :
+CBaseTempEntity(name)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTEFireBullets::~CTEFireBullets(void)
+{
+}
+
+IMPLEMENT_SERVERCLASS_ST_NOBASE(CTEFireBullets, DT_TEFireBullets)
+SendPropVector(SENDINFO(m_vecOrigin), -1, SPROP_COORD),
+SendPropAngle(SENDINFO_VECTORELEM(m_vecAngles, 0), 13, 0),
+SendPropAngle(SENDINFO_VECTORELEM(m_vecAngles, 1), 13, 0),
+SendPropInt(SENDINFO(m_iWeaponID), 5, SPROP_UNSIGNED), // max 31 weapons
+SendPropInt(SENDINFO(m_iMode), 1, SPROP_UNSIGNED),
+SendPropInt(SENDINFO(m_iSeed), NUM_BULLET_SEED_BITS, SPROP_UNSIGNED),
+SendPropInt(SENDINFO(m_iPlayer), 6, SPROP_UNSIGNED), 	// max 64 players, see MAX_PLAYERS
+SendPropFloat(SENDINFO(m_flSpread), 10, 0, 0, 1),
+END_SEND_TABLE()
+
+
+// Singleton
+static CTEFireBullets g_TEFireBullets("Shotgun Shot");
+
+
+void TE_FireBullets(
+    int	iPlayerIndex,
+    const Vector &vOrigin,
+    const QAngle &vAngles,
+    int	iWeaponID,
+    int	iMode,
+    int iSeed,
+    float flSpread)
+{
+    CPASFilter filter(vOrigin);
+    filter.UsePredictionRules();
+
+    g_TEFireBullets.m_iPlayer = iPlayerIndex - 1;
+    g_TEFireBullets.m_vecOrigin = vOrigin;
+    g_TEFireBullets.m_vecAngles = vAngles;
+    g_TEFireBullets.m_iSeed = iSeed;
+    g_TEFireBullets.m_flSpread = flSpread;
+    g_TEFireBullets.m_iMode = iMode;
+    g_TEFireBullets.m_iWeaponID = iWeaponID;
+
+    Assert(iSeed < (1 << NUM_BULLET_SEED_BITS));
+
+    g_TEFireBullets.Create(filter, 0);
+}
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/te_shotgun_shot.h b/mp/src/game/server/momentum/te_shotgun_shot.h
new file mode 100644
index 000000000..1d2052ed3
--- /dev/null
+++ b/mp/src/game/server/momentum/te_shotgun_shot.h
@@ -0,0 +1,22 @@
+#ifndef TE_SHOTGUN_SHOT_H
+#define TE_SHOTGUN_SHOT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+
+void TE_FireBullets(
+    int	iPlayerIndex,
+    const Vector &vOrigin,
+    const QAngle &vAngles,
+    int	iWeaponID,
+    int	iMode,
+    int iSeed,
+    float flSpread
+    );
+
+void TE_PlantBomb(int iPlayerIndex, const Vector &vOrigin);
+
+
+#endif // TE_SHOTGUN_SHOT_H
\ No newline at end of file
diff --git a/mp/src/game/server/momentum/tickset.cpp b/mp/src/game/server/momentum/tickset.cpp
new file mode 100644
index 000000000..4263743ee
--- /dev/null
+++ b/mp/src/game/server/momentum/tickset.cpp
@@ -0,0 +1,141 @@
+#ifdef _WIN32
+#include "Windows.h"
+#include "Psapi.h"
+#pragma comment(lib, "psapi.lib")
+#elif defined (__linux__)
+#elif defined (__APPLE__)
+#endif
+
+#include "tickset.h"
+#include "tier0/platform.h"
+
+float* TickSet::interval_per_tick = NULL;
+const TickSet::Tickrate TickSet::s_DefinedRates[] = {
+    { 0.015f, "66" },
+    { 0.01f, "100" }
+};
+TickSet::Tickrate TickSet::m_trCurrent = TickSet::s_DefinedRates[TickSet::TICKRATE_66];
+
+#ifdef __linux__
+int GetModuleInformation_Linux(const char *name, void **base, size_t *length)
+{
+    // this is the only way to do this on linux, lol
+    FILE *f = fopen("/proc/self/maps", "r");
+    if (!f)
+        return 1;
+
+    char buf[PATH_MAX+100];
+    while (!feof(f))
+    {
+        if (!fgets(buf, sizeof(buf), f))
+            break;
+
+	char *tmp = strrchr(buf, '\n');
+	if (tmp)
+            *tmp = '\0';
+
+	char *mapname = strchr(buf, '/');
+	if (!mapname)
+	    continue;
+
+        char perm[5];
+        unsigned long begin, end;
+        sscanf(buf, "%lx-%lx %4s", &begin, &end, perm);
+
+        if (strcmp(basename(mapname), name) == 0 && perm[0] == 'r' && perm[2] == 'x')
+        {
+            *base = (void*)begin;
+            *length = (size_t)end-begin;
+            fclose(f);
+            return 0;
+        }
+    }
+
+    fclose(f);
+    return 2;
+}
+#endif // __linux__
+
+inline bool TickSet::DataCompare(const unsigned char* data, const unsigned char* pattern, const char* mask)
+{
+    for (; *mask != 0; ++data, ++pattern, ++mask)
+        if (*mask == 'x' && *data != *pattern)
+            return false;
+
+    return (*mask == 0);
+}
+
+void* TickSet::FindPattern(const void* start, size_t length, const unsigned char* pattern, const char* mask)
+{
+    auto maskLength = strlen(mask);
+    for (size_t i = 0; i <= length - maskLength; ++i)
+    {
+        auto addr = reinterpret_cast<const unsigned char*>(start)+i;
+        if (DataCompare(addr, pattern, mask))
+            return const_cast<void*>(reinterpret_cast<const void*>(addr));
+    }
+
+    return NULL;
+}
+
+bool TickSet::TickInit()
+{
+#ifdef _WIN32
+    HMODULE handle = GetModuleHandleA("engine.dll");
+    if (!handle)
+        return false;    
+    
+    MODULEINFO info;
+    GetModuleInformation(GetCurrentProcess(), handle, &info, sizeof(info));
+
+    auto moduleBase = info.lpBaseOfDll;
+    auto moduleSize = info.SizeOfImage;
+
+    unsigned char pattern[] = { 0x8B, 0x0D, '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', 0xFF, '?', 0xD9, 0x15, '?', '?', '?', '?', 0xDD, 0x05, '?', '?', '?', '?', 0xDB, 0xF1, 0xDD, 0x05, '?', '?', '?', '?', 0x77, 0x08, 0xD9, 0xCA, 0xDB, 0xF2, 0x76, 0x1F, 0xD9, 0xCA };
+    auto p = reinterpret_cast<uintptr_t>(FindPattern(moduleBase, moduleSize, pattern, "xx????????????x?xx????xx????xxxx????xxxxxxxxxx"));
+    if (p)
+        interval_per_tick = *reinterpret_cast<float**>(p + 18);
+
+#elif defined (__linux__)
+    void *base;
+    size_t length;
+    if (GetModuleInformation_Linux("engine.so", &base, &length))
+	return false;
+    
+    // mov ds:interval_per_tick, 3C75C28Fh         <-- float for 0.015
+    unsigned char pattern[] = { 0xC7,0x05, '?','?','?','?', 0x8F,0xC2,0x75,0x3C, 0xE8 };
+    void* addr = FindPattern(base, length, pattern, "xx????xxxxx");
+    if (addr)
+        interval_per_tick = *(float**)(addr + 2);
+
+#elif defined (__APPLE__)
+
+#endif
+
+    return (interval_per_tick ? true : false);
+}
+
+bool TickSet::SetTickrate(float tickrate)
+{
+    /*if (interval_per_tick)
+    {
+        *interval_per_tick = tickrate;
+        gpGlobals->interval_per_tick = tickrate;
+        
+        return true;
+    }
+    else return false;*/
+    if (m_trCurrent.fTickRate != tickrate)
+    {
+        Tickrate tr;
+        if (tickrate == 0.01f) tr = s_DefinedRates[TICKRATE_100];
+        else if (tickrate == 0.015f) tr = s_DefinedRates[TICKRATE_66];
+        else
+        {
+            tr.fTickRate = tickrate;
+            tr.sType = "CUSTOM";
+        }
+        return SetTickrate(tr);
+    }
+    else return false;
+}
diff --git a/mp/src/game/server/momentum/tickset.h b/mp/src/game/server/momentum/tickset.h
new file mode 100644
index 000000000..1da71527a
--- /dev/null
+++ b/mp/src/game/server/momentum/tickset.h
@@ -0,0 +1,89 @@
+#ifndef TICKSET_H
+#define TICKSET_H
+
+#include "cbase.h"
+#include "momentum/mom_shareddefs.h"
+
+class TickSet {
+public:
+    
+    struct Tickrate
+    {
+        float fTickRate;
+        const char* sType;
+
+        Tickrate()
+        {
+            fTickRate = 0.0f;
+            sType = '\0';
+        }
+        Tickrate(float f, const char * type)
+        {
+            fTickRate = f;
+            sType = type;
+        }
+        Tickrate& operator =(const Tickrate &other)
+        {
+            this->fTickRate = other.fTickRate;
+            this->sType = other.sType;
+            return *this;
+        }
+        bool operator ==(const Tickrate &other)
+        {
+            return (other.fTickRate == fTickRate
+                && !Q_strcmp(other.sType, sType));
+        }
+    };
+
+    static const Tickrate s_DefinedRates[];
+
+    enum
+    {
+        TICKRATE_66 = 0,
+        TICKRATE_100 = 1    
+    };
+
+    static bool SetTickrate(int gameMode)
+    {
+        switch (gameMode)
+        {
+        case MOMGM_BHOP:
+        case MOMGM_SCROLL:
+            //MOM_TODO: add more gamemodes
+            return SetTickrate(s_DefinedRates[TICKRATE_100]);
+
+        case MOMGM_SURF:
+        default:
+            return SetTickrate(s_DefinedRates[TICKRATE_66]);
+        }
+        return false;
+    }
+
+    static Tickrate GetCurrentTickrate() { return (m_trCurrent.fTickRate > 0.0f ? m_trCurrent : s_DefinedRates[TICKRATE_66]); }
+	static bool TickInit();
+    static bool SetTickrate(Tickrate trNew)
+    {
+        if (trNew == m_trCurrent) return false;
+
+        if (interval_per_tick)
+        {
+            DevLog("Testing: %f\n", trNew.fTickRate);
+            *interval_per_tick = trNew.fTickRate;
+            gpGlobals->interval_per_tick = *interval_per_tick;
+            DevLog("Should have set the tickrate to %f\n", *interval_per_tick);
+            m_trCurrent = trNew;
+            return true;
+        }
+        return false;
+    }
+	static bool SetTickrate(float);
+    static float GetTickrate() { return *interval_per_tick; }
+
+private:
+	static inline bool DataCompare(const unsigned char*, const unsigned char*, const char*);
+	static void *FindPattern(const void*, size_t, const unsigned char*, const char*);
+	static float *interval_per_tick;
+    static Tickrate m_trCurrent;
+};
+
+#endif // TICKSET_H
diff --git a/mp/src/game/shared/momentum/basecsgrenade_projectile.cpp b/mp/src/game/shared/momentum/basecsgrenade_projectile.cpp
new file mode 100644
index 000000000..025eeef8b
--- /dev/null
+++ b/mp/src/game/shared/momentum/basecsgrenade_projectile.cpp
@@ -0,0 +1,343 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "basecsgrenade_projectile.h"
+#include "mom_player_shared.h"
+
+
+extern ConVar sv_gravity;
+
+
+#ifndef CLIENT_DLL
+
+#include "soundent.h"
+#include "te_effect_dispatch.h"
+#include "KeyValues.h"
+
+BEGIN_DATADESC(CBaseCSGrenadeProjectile)
+DEFINE_THINKFUNC(DangerSoundThink),
+END_DATADESC()
+
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED(BaseCSGrenadeProjectile, DT_BaseCSGrenadeProjectile)
+
+BEGIN_NETWORK_TABLE(CBaseCSGrenadeProjectile, DT_BaseCSGrenadeProjectile)
+#ifdef CLIENT_DLL
+RecvPropVector( RECVINFO( m_vInitialVelocity ) )
+#else
+SendPropVector(SENDINFO(m_vInitialVelocity),
+20,		// nbits
+0,		// flags
+-3000,	// low value
+3000	// high value
+)
+#endif
+END_NETWORK_TABLE()
+
+
+#ifdef CLIENT_DLL
+
+
+void CBaseCSGrenadeProjectile::PostDataUpdate( DataUpdateType_t type )
+{
+    BaseClass::PostDataUpdate( type );
+
+    if ( type == DATA_UPDATE_CREATED )
+    {
+        // Now stick our initial velocity into the interpolation history 
+        CInterpolatedVar< Vector > &interpolator = GetOriginInterpolator();
+
+        interpolator.ClearHistory();
+        float changeTime = GetLastChangeTime( LATCH_SIMULATION_VAR );
+
+        // Add a sample 1 second back.
+        Vector vCurOrigin = GetLocalOrigin() - m_vInitialVelocity;
+        interpolator.AddToHead( changeTime - 1.0, &vCurOrigin, false );
+
+        // Add the current sample.
+        vCurOrigin = GetLocalOrigin();
+        interpolator.AddToHead( changeTime, &vCurOrigin, false );
+    }
+}
+
+int CBaseCSGrenadeProjectile::DrawModel( int flags )
+{
+    // During the first half-second of our life, don't draw ourselves if he's
+    // still playing his throw animation.
+    // (better yet, we could draw ourselves in his hand).
+    if ( GetThrower() != C_BasePlayer::GetLocalPlayer() )
+    {
+        if ( gpGlobals->curtime - m_flSpawnTime < 0.5 )
+        {
+            //MOM_TODO: inspect the below
+            //CMomentumPlayer *pPlayer = dynamic_cast<CMomentumPlayer*>( GetThrower() );
+            //if ( pPlayer && pPlayer->m_PlayerAnimState->IsThrowingGrenade() )
+            //{
+            //	return 0;
+            //}
+        }
+    }
+
+    return BaseClass::DrawModel( flags );
+}
+
+void CBaseCSGrenadeProjectile::Spawn()
+{
+    m_flSpawnTime = gpGlobals->curtime;
+    BaseClass::Spawn();
+}
+
+#else
+
+void CBaseCSGrenadeProjectile::PostConstructor(const char *className)
+{
+    BaseClass::PostConstructor(className);
+    //TheBots->AddGrenade( this );
+}
+
+CBaseCSGrenadeProjectile::~CBaseCSGrenadeProjectile()
+{
+    //TheBots->RemoveGrenade( this );
+}
+
+void CBaseCSGrenadeProjectile::Spawn(void)
+{
+    BaseClass::Spawn();
+
+    SetSolidFlags(FSOLID_NOT_STANDABLE);
+    SetMoveType(MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM);
+    SetSolid(SOLID_BBOX);	// So it will collide with physics props!
+
+    // smaller, cube bounding box so we rest on the ground
+    SetSize(Vector(-2, -2, -2), Vector(2, 2, 2));
+}
+
+void CBaseCSGrenadeProjectile::DangerSoundThink(void)
+{
+    if (!IsInWorld())
+    {
+        Remove();
+        return;
+    }
+
+    if (gpGlobals->curtime > m_flDetonateTime)
+    {
+        Detonate();
+        return;
+    }
+
+    CSoundEnt::InsertSound(SOUND_DANGER, GetAbsOrigin() + GetAbsVelocity() * 0.5, GetAbsVelocity().Length(), 0.2);
+
+    SetNextThink(gpGlobals->curtime + 0.2);
+
+    if (GetWaterLevel() != 0)
+    {
+        SetAbsVelocity(GetAbsVelocity() * 0.5);
+    }
+}
+
+//Sets the time at which the grenade will explode
+void CBaseCSGrenadeProjectile::SetDetonateTimerLength(float timer)
+{
+    m_flDetonateTime = gpGlobals->curtime + timer;
+}
+
+void CBaseCSGrenadeProjectile::ResolveFlyCollisionCustom(trace_t &trace, Vector &vecVelocity)
+{
+    //Assume all surfaces have the same elasticity
+    float flSurfaceElasticity = 1.0;
+
+    //Don't bounce off of players with perfect elasticity
+    if (trace.m_pEnt && trace.m_pEnt->IsPlayer())
+    {
+        flSurfaceElasticity = 0.3;
+    }
+
+    // if its breakable glass and we kill it, don't bounce.
+    // give some damage to the glass, and if it breaks, pass 
+    // through it.
+    bool breakthrough = false;
+
+    if (trace.m_pEnt && FClassnameIs(trace.m_pEnt, "func_breakable"))
+    {
+        breakthrough = true;
+    }
+
+    if (trace.m_pEnt && FClassnameIs(trace.m_pEnt, "func_breakable_surf"))
+    {
+        breakthrough = true;
+    }
+
+    if (breakthrough)
+    {
+        CTakeDamageInfo info(this, this, 10, DMG_CLUB);
+        trace.m_pEnt->DispatchTraceAttack(info, GetAbsVelocity(), &trace);
+
+        ApplyMultiDamage();
+
+        if (trace.m_pEnt->m_iHealth <= 0)
+        {
+            // slow our flight a little bit
+            Vector vel = GetAbsVelocity();
+
+            vel *= 0.4;
+
+            SetAbsVelocity(vel);
+            return;
+        }
+    }
+
+    float flTotalElasticity = GetElasticity() * flSurfaceElasticity;
+    flTotalElasticity = clamp(flTotalElasticity, 0.0f, 0.9f);
+
+    // NOTE: A backoff of 2.0f is a reflection
+    Vector vecAbsVelocity;
+    PhysicsClipVelocity(GetAbsVelocity(), trace.plane.normal, vecAbsVelocity, 2.0f);
+    vecAbsVelocity *= flTotalElasticity;
+
+    // Get the total velocity (player + conveyors, etc.)
+    VectorAdd(vecAbsVelocity, GetBaseVelocity(), vecVelocity);
+    float flSpeedSqr = DotProduct(vecVelocity, vecVelocity);
+
+    // Stop if on ground.
+    if (trace.plane.normal.z > 0.7f)			// Floor
+    {
+        // Verify that we have an entity.
+        CBaseEntity *pEntity = trace.m_pEnt;
+        Assert(pEntity);
+
+        SetAbsVelocity(vecAbsVelocity);
+
+        if (flSpeedSqr < (30 * 30))
+        {
+            if (pEntity->IsStandable())
+            {
+                SetGroundEntity(pEntity);
+            }
+
+            // Reset velocities.
+            SetAbsVelocity(vec3_origin);
+            SetLocalAngularVelocity(vec3_angle);
+
+            //align to the ground so we're not standing on end
+            QAngle angle;
+            VectorAngles(trace.plane.normal, angle);
+
+            // rotate randomly in yaw
+            angle[1] = random->RandomFloat(0, 360);
+
+            // TODO: rotate around trace.plane.normal
+
+            SetAbsAngles(angle);
+        }
+        else
+        {
+            Vector vecDelta = GetBaseVelocity() - vecAbsVelocity;
+            Vector vecBaseDir = GetBaseVelocity();
+            VectorNormalize(vecBaseDir);
+            float flScale = vecDelta.Dot(vecBaseDir);
+
+            VectorScale(vecAbsVelocity, (1.0f - trace.fraction) * gpGlobals->frametime, vecVelocity);
+            VectorMA(vecVelocity, (1.0f - trace.fraction) * gpGlobals->frametime, GetBaseVelocity() * flScale, vecVelocity);
+            PhysicsPushEntity(vecVelocity, &trace);
+        }
+    }
+    else
+    {
+        // If we get *too* slow, we'll stick without ever coming to rest because
+        // we'll get pushed down by gravity faster than we can escape from the wall.
+        if (flSpeedSqr < (30 * 30))
+        {
+            // Reset velocities.
+            SetAbsVelocity(vec3_origin);
+            SetLocalAngularVelocity(vec3_angle);
+        }
+        else
+        {
+            SetAbsVelocity(vecAbsVelocity);
+        }
+    }
+
+    BounceSound();
+
+    // tell the bots a grenade has bounced
+    CMomentumPlayer *player = ToCMOMPlayer(GetThrower());
+    if (player)
+    {
+        IGameEvent * event = gameeventmanager->CreateEvent("grenade_bounce");
+        if (event)
+        {
+            event->SetInt("userid", player->GetUserID());
+            event->SetFloat("x", GetAbsOrigin().x);
+            event->SetFloat("y", GetAbsOrigin().y);
+            event->SetFloat("z", GetAbsOrigin().z);
+            gameeventmanager->FireEvent(event);
+        }
+    }
+}
+
+void CBaseCSGrenadeProjectile::SetupInitialTransmittedGrenadeVelocity(const Vector &velocity)
+{
+    m_vInitialVelocity = velocity;
+}
+
+#define	MAX_WATER_SURFACE_DISTANCE	512
+
+void CBaseCSGrenadeProjectile::Splash()
+{
+    Vector centerPoint = GetAbsOrigin();
+    Vector normal(0, 0, 1);
+
+    // Find our water surface by tracing up till we're out of the water
+    trace_t tr;
+    Vector vecTrace(0, 0, MAX_WATER_SURFACE_DISTANCE);
+    UTIL_TraceLine(centerPoint, centerPoint + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr);
+
+    // If we didn't start in water, we're above it
+    if (tr.startsolid == false)
+    {
+        // Look downward to find the surface
+        vecTrace.Init(0, 0, -MAX_WATER_SURFACE_DISTANCE);
+        UTIL_TraceLine(centerPoint, centerPoint + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr);
+
+        // If we hit it, setup the explosion
+        if (tr.fraction < 1.0f)
+        {
+            centerPoint = tr.endpos;
+        }
+        else
+        {
+            //NOTENOTE: We somehow got into a splash without being near water?
+            Assert(0);
+        }
+    }
+    else if (tr.fractionleftsolid)
+    {
+        // Otherwise we came out of the water at this point
+        centerPoint = centerPoint + (vecTrace * tr.fractionleftsolid);
+    }
+    else
+    {
+        // Use default values, we're really deep
+    }
+
+    CEffectData	data;
+    data.m_vOrigin = centerPoint;
+    data.m_vNormal = normal;
+    data.m_flScale = random->RandomFloat(1.0f, 2.0f);
+
+    if (GetWaterType() & CONTENTS_SLIME)
+    {
+        data.m_fFlags |= FX_WATER_IN_SLIME;
+    }
+
+    DispatchEffect("gunshotsplash", data);
+}
+
+#endif // !CLIENT_DLL
diff --git a/mp/src/game/shared/momentum/basecsgrenade_projectile.h b/mp/src/game/shared/momentum/basecsgrenade_projectile.h
new file mode 100644
index 000000000..f74f908c7
--- /dev/null
+++ b/mp/src/game/shared/momentum/basecsgrenade_projectile.h
@@ -0,0 +1,82 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef BASECSGRENADE_PROJECTILE_H
+#define BASECSGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "basegrenade_shared.h"
+
+
+#ifdef CLIENT_DLL
+	#define CBaseCSGrenadeProjectile C_BaseCSGrenadeProjectile
+#endif
+
+
+class CBaseCSGrenadeProjectile : public CBaseGrenade
+{
+public:
+	DECLARE_CLASS( CBaseCSGrenadeProjectile, CBaseGrenade );
+	DECLARE_NETWORKCLASS(); 
+
+	virtual void Spawn();
+
+
+public:
+
+	// This gets sent to the client and placed in the client's interpolation history
+	// so the projectile starts out moving right off the bat.
+	CNetworkVector( m_vInitialVelocity );
+
+
+#ifdef CLIENT_DLL
+	CBaseCSGrenadeProjectile() {}
+	CBaseCSGrenadeProjectile( const CBaseCSGrenadeProjectile& ) {}
+	virtual int DrawModel( int flags );
+	virtual void PostDataUpdate( DataUpdateType_t type );
+	
+	float m_flSpawnTime;
+#else
+	DECLARE_DATADESC();
+
+	virtual void PostConstructor( const char *className );
+	virtual ~CBaseCSGrenadeProjectile();
+
+	//Constants for all CS Grenades
+	static inline float GetGrenadeGravity() { return 0.4f; }
+	static inline const float GetGrenadeFriction() { return 0.2f; }
+	static inline const float GetGrenadeElasticity() { return 0.45f; }
+
+	//Think function to emit danger sounds for the AI
+	void DangerSoundThink( void );
+	
+	virtual float GetShakeAmplitude( void ) { return 0.0f; }
+	virtual void Splash();
+
+	// Specify what velocity we want the grenade to have on the client immediately.
+	// Without this, the entity wouldn't have an interpolation history initially, so it would
+	// sit still until it had gotten a few updates from the server.
+	void SetupInitialTransmittedGrenadeVelocity( const Vector &velocity );
+
+protected:
+
+	//Set the time to detonate ( now + timer )
+	void SetDetonateTimerLength( float timer );
+
+private:	
+	
+	//Custom collision to allow for constant elasticity on hit surfaces
+	virtual void ResolveFlyCollisionCustom( trace_t &trace, Vector &vecVelocity );
+	
+	float m_flDetonateTime;
+#endif
+};
+
+
+#endif // BASECSGRENADE_PROJECTILE_H
diff --git a/mp/src/game/shared/momentum/cs_ammodef.cpp b/mp/src/game/shared/momentum/cs_ammodef.cpp
new file mode 100644
index 000000000..658471bbd
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_ammodef.cpp
@@ -0,0 +1,57 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_ammodef.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+void CCSAmmoDef::AddAmmoCost( char const* name, int cost, int buySize )
+{
+	int index = Index( name );
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return;
+
+	m_csAmmo[index].buySize = buySize;
+	m_csAmmo[index].cost = cost;
+}
+
+
+//-----------------------------------------------------------------------------
+int CCSAmmoDef::GetBuySize( int index ) const
+{
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return 0;
+
+	return m_csAmmo[index].buySize;
+}
+
+
+//-----------------------------------------------------------------------------
+int CCSAmmoDef::GetCost( int index ) const
+{
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return 0;
+
+	return m_csAmmo[index].cost;
+}
+
+
+//-----------------------------------------------------------------------------
+CCSAmmoDef::CCSAmmoDef(void)
+{
+	memset( m_csAmmo, 0, sizeof( m_csAmmo ) );
+}
+
+
+//-----------------------------------------------------------------------------
+CCSAmmoDef::~CCSAmmoDef( void )
+{
+}
+
+//-----------------------------------------------------------------------------
diff --git a/mp/src/game/shared/momentum/cs_ammodef.h b/mp/src/game/shared/momentum/cs_ammodef.h
new file mode 100644
index 000000000..9b51db061
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_ammodef.h
@@ -0,0 +1,55 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Holds defintion for game ammo types
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_AMMODEF_H
+#define CS_AMMODEF_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "ammodef.h"
+//#include "cs_blackmarket.h"
+
+class ConVar;
+
+struct CSAmmoCost
+{
+	int	buySize;
+	int	cost;
+};
+
+//=============================================================================
+//	>> CCSAmmoDef
+//=============================================================================
+class CCSAmmoDef : public CAmmoDef
+{
+
+public:
+
+	void AddAmmoCost( char const* name, int cost, int buySize );
+
+	CCSAmmoDef(void);
+	~CCSAmmoDef( void );
+
+	int GetBuySize( int nAmmoIndex ) const;
+	int GetCost( int nAmmoIndex ) const;
+
+private:
+	CSAmmoCost	m_csAmmo[MAX_AMMO_TYPES];
+};
+
+
+// Get the global ammodef object. This is usually implemented in each mod's game rules file somewhere,
+// so the mod can setup custom ammo types.
+CCSAmmoDef* GetCSAmmoDef();
+
+
+#endif // CS_AMMODEF_H
+ 
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/cs_playeranimstate.cpp b/mp/src/game/shared/momentum/cs_playeranimstate.cpp
new file mode 100644
index 000000000..261f73f74
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_playeranimstate.cpp
@@ -0,0 +1,1035 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_playeranimstate.h"
+#include "base_playeranimstate.h"
+#include "tier0/vprof.h"
+#include "animation.h"
+#include "weapon_csbase.h"
+#include "studio.h"
+#include "apparent_velocity_helper.h"
+#include "utldict.h"
+//#include "weapon_basecsgrenade.h" MOM_TODO: include this
+#include "datacache/imdlcache.h"
+#include "mom_player_shared.h"
+
+#ifdef CLIENT_DLL
+	#include "bone_setup.h"
+	#include "interpolatedvar.h"
+#else
+#endif
+
+#define ANIM_TOPSPEED_WALK			100
+#define ANIM_TOPSPEED_RUN			250
+#define ANIM_TOPSPEED_RUN_CROUCH	85
+
+#define DEFAULT_IDLE_NAME "idle_upper_"
+#define DEFAULT_CROUCH_IDLE_NAME "crouch_idle_upper_"
+#define DEFAULT_CROUCH_WALK_NAME "crouch_walk_upper_"
+#define DEFAULT_WALK_NAME "walk_upper_"
+#define DEFAULT_RUN_NAME "run_upper_"
+
+#define DEFAULT_FIRE_IDLE_NAME "idle_shoot_"
+#define DEFAULT_FIRE_CROUCH_NAME "crouch_idle_shoot_"
+#define DEFAULT_FIRE_CROUCH_WALK_NAME "crouch_walk_shoot_"
+#define DEFAULT_FIRE_WALK_NAME "walk_shoot_"
+#define DEFAULT_FIRE_RUN_NAME "run_shoot_"
+
+
+#define FIRESEQUENCE_LAYER		(AIMSEQUENCE_LAYER+NUM_AIMSEQUENCE_LAYERS+1)
+#define RELOADSEQUENCE_LAYER	(FIRESEQUENCE_LAYER + 1)
+#define GRENADESEQUENCE_LAYER	(RELOADSEQUENCE_LAYER + 1)
+#define NUM_LAYERS_WANTED		(GRENADESEQUENCE_LAYER + 1)
+
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CCSPlayerAnimState declaration.
+// ------------------------------------------------------------------------------------------------ //
+
+class CCSPlayerAnimState : public CBasePlayerAnimState, public ICSPlayerAnimState
+{
+public:
+	DECLARE_CLASS( CCSPlayerAnimState, CBasePlayerAnimState );
+	friend ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+
+	CCSPlayerAnimState();
+
+	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData );
+	virtual bool IsThrowingGrenade();
+	virtual int CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle );
+	virtual void ClearAnimationState();
+	virtual bool CanThePlayerMove();
+	virtual float GetCurrentMaxGroundSpeed();
+	virtual Activity CalcMainActivity();
+	virtual void DebugShowAnimState( int iStartLine );
+	virtual void ComputeSequences( CStudioHdr *pStudioHdr );
+	virtual void ClearAnimationLayers();
+	virtual int SelectWeightedSequence( Activity activity );
+
+	void InitCS( CBaseAnimatingOverlay *pPlayer, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+	
+protected:
+
+	int CalcFireLayerSequence(PlayerAnimEvent_t event);
+	void ComputeFireSequence( CStudioHdr *pStudioHdr );
+
+	void ComputeReloadSequence( CStudioHdr *pStudioHdr );
+	int CalcReloadLayerSequence( PlayerAnimEvent_t event );
+
+	bool IsOuterGrenadePrimed();
+	void ComputeGrenadeSequence( CStudioHdr *pStudioHdr );
+	int CalcGrenadePrimeSequence();
+	int CalcGrenadeThrowSequence();
+	int GetOuterGrenadeThrowCounter();
+
+	const char* GetWeaponSuffix();
+	bool HandleJumping();
+
+	void UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd );
+
+	virtual int CalcSequenceIndex( const char *pBaseName, ... );
+
+private:
+
+	// Current state variables.
+	bool m_bJumping;			// Set on a jump event.
+	float m_flJumpStartTime;
+	bool m_bFirstJumpFrame;
+
+	// Aim sequence plays reload while this is on.
+	bool m_bReloading;
+	float m_flReloadCycle;
+	int m_iReloadSequence;
+	float m_flReloadHoldEndTime;	// Intermediate shotgun reloads get held a fraction of a second
+
+	// This is set to true if ANY animation is being played in the fire layer.
+	bool m_bFiring;						// If this is on, then it'll continue the fire animation in the fire layer
+										// until it completes.
+	int m_iFireSequence;				// (For any sequences in the fire layer, including grenade throw).
+	float m_flFireCycle;
+	PlayerAnimEvent_t m_delayedFire;	// if we fire while reloading, delay the fire by one frame so we can cancel the reload first
+
+	// These control grenade animations.
+	bool m_bThrowingGrenade;
+	bool m_bPrimingGrenade;
+	float m_flGrenadeCycle;
+	int m_iGrenadeSequence;
+	int m_iLastThrowGrenadeCounter;	// used to detect when the guy threw the grenade.
+
+	CMomentumPlayer *m_pPlayer;
+
+	ICSPlayerAnimStateHelpers *m_pHelpers;
+
+	void CheckCachedSequenceValidity( void );
+
+	int m_sequenceCache[ ACT_CROUCHIDLE+1 ];	// Cache the first N sequences, since we don't have weights.
+	int m_cachedModelIndex;						// Model index for which the sequence cache is valid.
+
+	CUtlDict<int,int> m_namedSequence;			// Dictionary of sequences computed with CalcSequenceIndex.  This is because LookupSequence is a performance hit - CS:S player models have 750+ sequences!
+};
+
+
+ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CCSPlayerAnimState *pRet = new CCSPlayerAnimState;
+	pRet->InitCS( pEntity, pHelpers, legAnimType, bUseAimSequences );
+	return pRet;
+}
+
+
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Hostage animation mechanism
+ */
+class CCSHostageAnimState : public CCSPlayerAnimState
+{
+public:
+	DECLARE_CLASS( CCSHostageAnimState, CCSPlayerAnimState );
+
+	CCSHostageAnimState();
+
+	virtual Activity CalcMainActivity();
+
+	// No need to cache sequences, and we *do* have multiple sequences per activity
+	virtual int SelectWeightedSequence( Activity activity ) { return GetOuter()->SelectWeightedSequence( activity ); }
+};
+
+
+//----------------------------------------------------------------------------------------------
+ICSPlayerAnimState* CreateHostageAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CCSHostageAnimState *anim = new CCSHostageAnimState;
+	anim->InitCS( pEntity, pHelpers, legAnimType, bUseAimSequences );
+	return anim;
+}
+
+
+//----------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------
+CCSHostageAnimState::CCSHostageAnimState()
+{
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Set hostage animation state
+ */
+Activity CCSHostageAnimState::CalcMainActivity()
+{
+	/*float flOuterSpeed = GetOuterXYSpeed();
+
+	if ( HandleJumping() )
+	{
+		return ACT_HOP;
+	}
+	else
+	{
+		Assert( dynamic_cast<CHostage*>( m_pOuter ) );
+		CHostage *me = (CHostage*)m_pOuter;
+
+		// if we have no leader, hang out
+		Activity idealActivity = me->GetLeader() ? ACT_IDLE : ACT_BUSY_QUEUE;
+
+		if ( m_pOuter->GetFlags() & FL_DUCKING )
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+				idealActivity = ACT_RUN_CROUCH;
+			else
+				idealActivity = ACT_COVER_LOW;
+		}
+		else
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+			{
+				if ( flOuterSpeed > ARBITRARY_RUN_SPEED )
+					idealActivity = ACT_RUN;
+				else
+					idealActivity = ACT_WALK;
+			}
+		}
+
+		return idealActivity;
+	}*/
+    return ACT_IDLE;
+}
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CCSPlayerAnimState implementation.
+// ------------------------------------------------------------------------------------------------ //
+
+CCSPlayerAnimState::CCSPlayerAnimState()
+{
+	m_pOuter = NULL;
+
+	m_bJumping = false;
+	m_flJumpStartTime = 0.0f;
+	m_bFirstJumpFrame = false;
+
+	m_bReloading = false;
+	m_flReloadCycle = 0.0f;
+	m_iReloadSequence = -1;
+	m_flReloadHoldEndTime = 0.0f;
+
+	m_bFiring = false;
+	m_iFireSequence = -1;
+	m_flFireCycle = 0.0f;
+	m_delayedFire = PLAYERANIMEVENT_COUNT;
+
+	m_bThrowingGrenade = false;
+	m_bPrimingGrenade = false;
+	m_flGrenadeCycle = 0.0f;
+	m_iGrenadeSequence = -1;
+	m_iLastThrowGrenadeCounter = 0;
+	m_cachedModelIndex = -1;
+
+	m_pPlayer = NULL;
+
+	m_pHelpers = NULL;
+}
+
+
+void CCSPlayerAnimState::InitCS( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CModAnimConfig config;
+	config.m_flMaxBodyYawDegrees = 90;
+	config.m_LegAnimType = legAnimType;
+	config.m_bUseAimSequences = bUseAimSequences;
+
+	//m_pPlayer = ToCSPlayer( pEntity );
+
+	m_pHelpers = pHelpers;
+
+	BaseClass::Init( pEntity, config );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSPlayerAnimState::CheckCachedSequenceValidity( void )
+{
+	if ( m_cachedModelIndex != GetOuter()->GetModelIndex() )
+	{
+		m_namedSequence.RemoveAll();
+
+		m_cachedModelIndex = GetOuter()->GetModelIndex();
+		for ( int i=0; i<=ACT_CROUCHIDLE; ++i )
+		{
+			m_sequenceCache[i] = -1;
+		}
+
+		// precache the sequences we'll be using for movement
+		if ( m_cachedModelIndex > 0 )
+		{
+			m_sequenceCache[ACT_HOP - 1] = GetOuter()->SelectWeightedSequence( ACT_HOP );
+			m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
+			m_sequenceCache[ACT_RUN_CROUCH - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN_CROUCH );
+			m_sequenceCache[ACT_CROUCHIDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_CROUCHIDLE );
+			m_sequenceCache[ACT_RUN - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN );
+			m_sequenceCache[ACT_WALK - 1] = GetOuter()->SelectWeightedSequence( ACT_WALK );
+			m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Cache the sequence numbers for the first ACT_HOP activities, since the CS player doesn't have multiple
+ * sequences per activity.
+ */
+int CCSPlayerAnimState::SelectWeightedSequence( Activity activity )
+{
+	VPROF( "CCSPlayerAnimState::ComputeMainSequence" );
+
+	if ( activity > ACT_CROUCHIDLE || activity < 1 )
+	{
+		return GetOuter()->SelectWeightedSequence( activity );
+	}
+
+	CheckCachedSequenceValidity();
+
+	int sequence = m_sequenceCache[ activity - 1 ];
+	if ( sequence < 0 )
+	{
+		// just in case, look up the sequence if we didn't precache it above
+		sequence = m_sequenceCache[ activity - 1 ] = GetOuter()->SelectWeightedSequence( activity );
+	}
+
+#if defined(CLIENT_DLL) && defined(_DEBUG)
+	int realSequence = GetOuter()->SelectWeightedSequence( activity );
+	Assert( realSequence == sequence );
+#endif
+
+	return sequence;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Try to look up named sequences in a CUtlDict cache before falling back to the normal LookupSequence.  It's
+ * best to avoid the normal LookupSequence when your models have 750+ sequences...
+ */
+int CCSPlayerAnimState::CalcSequenceIndex( const char *pBaseName, ... )
+{
+	VPROF( "CCSPlayerAnimState::CalcSequenceIndex" );
+
+	CheckCachedSequenceValidity();
+
+	char szFullName[512];
+	va_list marker;
+	va_start( marker, pBaseName );
+	Q_vsnprintf( szFullName, sizeof( szFullName ), pBaseName, marker );
+	va_end( marker );
+
+	int iSequence = m_namedSequence.Find( szFullName );
+	if ( iSequence == m_namedSequence.InvalidIndex() )
+	{
+		iSequence = GetOuter()->LookupSequence( szFullName );
+		m_namedSequence.Insert( szFullName, iSequence );
+	}
+	else
+	{
+		iSequence = m_namedSequence[iSequence];
+	}
+
+#if defined(CLIENT_DLL) && defined(_DEBUG)
+	int realSequence = GetOuter()->LookupSequence( szFullName );
+	Assert( realSequence == iSequence );
+#endif
+	
+	// Show warnings if we can't find anything here.
+	if ( iSequence == -1 )
+	{
+		static CUtlDict<int,int> dict;
+		if ( dict.Find( szFullName ) == -1 )
+		{
+			dict.Insert( szFullName, 0 );
+			Warning( "CalcSequenceIndex: can't find '%s'.\n", szFullName );
+		}
+
+		iSequence = 0;
+	}
+
+	return iSequence;
+}
+
+
+void CCSPlayerAnimState::ClearAnimationState()
+{
+	m_bJumping = false;
+	m_bFiring = false;
+	m_bReloading = false;
+	m_flReloadHoldEndTime = 0.0f;
+	m_bThrowingGrenade = m_bPrimingGrenade = false;
+	m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+	
+	BaseClass::ClearAnimationState();
+}
+
+
+void CCSPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	Assert( event != PLAYERANIMEVENT_THROW_GRENADE );
+
+	MDLCACHE_CRITICAL_SECTION();
+	switch ( event )
+	{
+	case PLAYERANIMEVENT_FIRE_GUN_PRIMARY:
+	case PLAYERANIMEVENT_FIRE_GUN_SECONDARY:
+		// Regardless of what we're doing in the fire layer, restart it.
+		m_flFireCycle = 0;
+		m_iFireSequence = CalcFireLayerSequence( event );
+		m_bFiring = m_iFireSequence != -1;
+
+		// If we are interrupting a (shotgun) reload, cancel the reload, and fire next frame.
+		if ( m_bFiring && m_bReloading )
+		{
+			m_bReloading = false;
+			m_iReloadSequence = -1;
+
+			m_delayedFire = event;
+			m_bFiring = false;
+			m_iFireSequence = -1;
+
+			CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( RELOADSEQUENCE_LAYER );
+			if ( pLayer )
+			{
+				pLayer->m_flWeight = 0.0f;
+				pLayer->m_nOrder = 15;
+			}
+		}
+
+#ifdef CLIENT_DLL
+		if ( m_bFiring && !m_bReloading )
+		{
+			if ( m_pPlayer )
+			{
+				m_pPlayer->ProcessMuzzleFlashEvent();
+			}
+		}
+#endif
+		break;
+
+	case PLAYERANIMEVENT_JUMP:
+		// Play the jump animation.
+		m_bJumping = true;
+		m_bFirstJumpFrame = true;
+		m_flJumpStartTime = gpGlobals->curtime;
+		break;
+
+	case PLAYERANIMEVENT_RELOAD:
+		{
+			// ignore normal reload events for shotguns - they get sent to trigger sounds etc only
+			CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+			if ( pWeapon && pWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_SHOTGUN )
+			{
+				m_iReloadSequence = CalcReloadLayerSequence( event );
+				if ( m_iReloadSequence != -1 )
+				{
+					m_bReloading = true;
+					m_flReloadCycle = 0;
+				}
+				else
+				{
+					m_bReloading = false;
+				}
+			}
+		}
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_START:
+	case PLAYERANIMEVENT_RELOAD_LOOP:
+		// Set the hold time for _start and _loop anims, then fall through to the _end case
+		m_flReloadHoldEndTime = gpGlobals->curtime + 0.75f;
+
+	case PLAYERANIMEVENT_RELOAD_END:
+		{
+			// ignore shotgun reload events for non-shotguns
+			CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+			if ( pWeapon && pWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_SHOTGUN )
+			{
+				m_flReloadHoldEndTime = 0.0f;  // clear this out in case we set it in _START or _LOOP above
+			}
+			else
+			{
+				m_iReloadSequence = CalcReloadLayerSequence( event );
+				if ( m_iReloadSequence != -1 )
+				{
+					m_bReloading = true;
+					m_flReloadCycle = 0;
+				}
+				else
+				{
+					m_bReloading = false;
+				}
+			}
+		}
+		break;
+
+	default:
+		Assert( !"CCSPlayerAnimState::DoAnimationEvent" );
+	}
+}
+
+
+float g_flThrowGrenadeFraction = 0.25;
+bool CCSPlayerAnimState::IsThrowingGrenade()
+{
+	if ( m_bThrowingGrenade )
+	{
+		// An animation event would be more appropriate here.
+		return m_flGrenadeCycle < g_flThrowGrenadeFraction;
+	}
+	else
+	{
+		bool bThrowPending = (m_iLastThrowGrenadeCounter != GetOuterGrenadeThrowCounter());
+		return bThrowPending || IsOuterGrenadePrimed();
+	}
+}
+
+
+int CCSPlayerAnimState::CalcReloadLayerSequence( PlayerAnimEvent_t event )
+{
+	if ( m_delayedFire != PLAYERANIMEVENT_COUNT )
+		return -1;
+
+	const char *weaponSuffix = GetWeaponSuffix();
+	if ( !weaponSuffix )
+		return -1;
+
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return -1;
+
+	const char *prefix = "";
+	switch ( GetCurrentMainSequenceActivity() )
+	{
+		case ACT_PLAYER_RUN_FIRE:
+		case ACT_RUN:
+			prefix = "run";
+			break;
+
+		case ACT_PLAYER_WALK_FIRE:
+		case ACT_WALK:
+			prefix = "walk";
+			break;
+
+		case ACT_PLAYER_CROUCH_FIRE:
+		case ACT_CROUCHIDLE:
+			prefix = "crouch_idle";
+			break;
+
+		case ACT_PLAYER_CROUCH_WALK_FIRE:
+		case ACT_RUN_CROUCH:
+			prefix = "crouch_walk";
+			break;
+
+		default:
+		case ACT_PLAYER_IDLE_FIRE:
+			prefix = "idle";
+			break;
+	}
+
+	const char *reloadSuffix = "";
+	switch ( event )
+	{
+	case PLAYERANIMEVENT_RELOAD_START:
+		reloadSuffix = "_start";
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_LOOP:
+		reloadSuffix = "_loop";
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_END:
+		reloadSuffix = "_end";
+		break;
+	}
+
+	// First, look for <prefix>_reload_<weapon name><_start|_loop|_end>.
+	char szName[512];
+	Q_snprintf( szName, sizeof( szName ), "%s_reload_%s%s", prefix, weaponSuffix, reloadSuffix );
+	int iReloadSequence = m_pOuter->LookupSequence( szName );
+	if ( iReloadSequence != -1 )
+		return iReloadSequence;
+
+	// Next, look for reload_<weapon name><_start|_loop|_end>.
+	Q_snprintf( szName, sizeof( szName ), "reload_%s%s", weaponSuffix, reloadSuffix );
+	iReloadSequence = m_pOuter->LookupSequence( szName );
+	if ( iReloadSequence != -1 )
+		return iReloadSequence;
+
+	// Ok, look for generic categories.. pistol, shotgun, rifle, etc.
+	if ( pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_PISTOL )
+	{
+		Q_snprintf( szName, sizeof( szName ), "reload_pistol" );
+		iReloadSequence = m_pOuter->LookupSequence( szName );
+		if ( iReloadSequence != -1 )
+			return iReloadSequence;
+	}
+			
+	// Fall back to reload_m4.
+	iReloadSequence = CalcSequenceIndex( "reload_m4" );
+	if ( iReloadSequence > 0 )
+		return iReloadSequence;
+
+	return -1;
+}
+
+	void CCSPlayerAnimState::UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd )
+{
+	if ( !bEnabled || iSequence < 0 )
+		return;
+
+		// Increment the fire sequence's cycle.
+		flCurCycle += m_pOuter->GetSequenceCycleRate( pStudioHdr, iSequence ) * gpGlobals->frametime;
+		if ( flCurCycle > 1 )
+		{
+			if ( bWaitAtEnd )
+			{
+				flCurCycle = 1;
+			}
+			else
+			{
+				// Not firing anymore.
+				bEnabled = false;
+				iSequence = 0;
+				return;
+			}
+		}
+
+	// Now dump the state into its animation layer.
+	CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( iLayer );
+
+	pLayer->m_flCycle = flCurCycle;
+	pLayer->m_nSequence = iSequence;
+
+	pLayer->m_flPlaybackRate = 1.0f;
+	pLayer->m_flWeight = 1.0f;
+	pLayer->m_nOrder = iLayer;
+#ifndef CLIENT_DLL
+	pLayer->m_fFlags |= ANIM_LAYER_ACTIVE; 
+#endif
+}
+
+bool CCSPlayerAnimState::IsOuterGrenadePrimed()
+{
+	/*CBaseCombatCharacter *pChar = m_pOuter->MyCombatCharacterPointer();
+	if ( pChar )
+	{
+		CBaseCSGrenade *pGren = dynamic_cast<CBaseCSGrenade*>( pChar->GetActiveWeapon() );
+		return pGren && pGren->IsPinPulled();
+	}
+	else
+	{
+		return NULL;
+	}*/
+    return false;
+}
+
+
+void CCSPlayerAnimState::ComputeGrenadeSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeGrenadeSequence" );
+	if ( m_bThrowingGrenade )
+	{
+		UpdateLayerSequenceGeneric( pStudioHdr, GRENADESEQUENCE_LAYER, m_bThrowingGrenade, m_flGrenadeCycle, m_iGrenadeSequence, false );
+	}
+	else
+	{
+		// Priming the grenade isn't an event.. we just watch the player for it.
+		// Also play the prime animation first if he wants to throw the grenade.
+		bool bThrowPending = (m_iLastThrowGrenadeCounter != GetOuterGrenadeThrowCounter());
+		if ( IsOuterGrenadePrimed() || bThrowPending )
+		{
+			if ( !m_bPrimingGrenade )
+			{
+				// If this guy just popped into our PVS, and he's got his grenade primed, then
+				// let's assume that it's all the way primed rather than playing the prime
+				// animation from the start.
+				if ( TimeSinceLastAnimationStateClear() < 0.4f )
+				{
+					m_flGrenadeCycle = 1;
+					if ( m_pPlayer )
+					{
+                        /*
+						CBaseCombatWeapon *pWeapon = m_pPlayer->GetActiveWeapon();
+						CBaseCSGrenade *pGren = dynamic_cast<CBaseCSGrenade*>( pWeapon );
+						if ( pWeapon && !pGren )
+						{
+							// The player coming into our PVS has a non-grenade weapon equipped.
+							// Either he switched away from it or he has already thrown the grenade.  Bail.
+							m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+							return;
+						}*/
+					}
+				}
+				else
+				{
+					m_flGrenadeCycle = 0;
+				}
+					
+				m_iGrenadeSequence = CalcGrenadePrimeSequence();
+			}
+
+			m_bPrimingGrenade = true;
+			UpdateLayerSequenceGeneric( pStudioHdr, GRENADESEQUENCE_LAYER, m_bPrimingGrenade, m_flGrenadeCycle, m_iGrenadeSequence, true );
+			
+			// If we're waiting to throw and we're done playing the prime animation...
+			if ( bThrowPending && m_flGrenadeCycle == 1 )
+			{
+				m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+
+				// Now play the throw animation.
+				m_iGrenadeSequence = CalcGrenadeThrowSequence();
+				if ( m_iGrenadeSequence != -1 )
+				{
+					// Configure to start playing 
+					m_bThrowingGrenade = true;
+					m_bPrimingGrenade = false;
+					m_flGrenadeCycle = 0;
+				}
+			}
+		}
+		else
+		{
+			m_bPrimingGrenade = false;
+		}
+	}
+}
+
+
+int CCSPlayerAnimState::CalcGrenadePrimeSequence()
+{
+	return CalcSequenceIndex( "idle_shoot_gren1" );
+}
+
+
+int CCSPlayerAnimState::CalcGrenadeThrowSequence()
+{
+	return CalcSequenceIndex( "idle_shoot_gren2" );
+}
+
+
+int CCSPlayerAnimState::GetOuterGrenadeThrowCounter()
+{
+	//if ( m_pPlayer )
+	//	return m_pPlayer->m_iThrowGrenadeCounter;
+	//else
+		return 0;
+}
+
+
+void CCSPlayerAnimState::ComputeReloadSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeReloadSequence" );
+	bool hold = m_flReloadHoldEndTime > gpGlobals->curtime;
+	UpdateLayerSequenceGeneric( pStudioHdr, RELOADSEQUENCE_LAYER, m_bReloading, m_flReloadCycle, m_iReloadSequence, hold );
+	if ( !m_bReloading )
+	{
+		m_flReloadHoldEndTime = 0.0f;
+	}
+}
+
+
+int CCSPlayerAnimState::CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle )
+{
+	VPROF( "CCSPlayerAnimState::CalcAimLayerSequence" );
+
+	const char *pSuffix = GetWeaponSuffix();
+	if ( !pSuffix )
+		return 0;
+
+	if ( bForceIdle )
+	{
+		switch ( GetCurrentMainSequenceActivity() )
+		{
+			case ACT_CROUCHIDLE:
+			case ACT_RUN_CROUCH:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_IDLE_NAME, pSuffix );
+
+			default:
+				return CalcSequenceIndex( "%s%s", DEFAULT_IDLE_NAME, pSuffix );
+		}
+	}
+	else
+	{
+		switch ( GetCurrentMainSequenceActivity() )
+		{
+			case ACT_RUN:
+				return CalcSequenceIndex( "%s%s", DEFAULT_RUN_NAME, pSuffix );
+
+			case ACT_WALK:
+			case ACT_RUNTOIDLE:
+			case ACT_IDLETORUN:
+				return CalcSequenceIndex( "%s%s", DEFAULT_WALK_NAME, pSuffix );
+
+			case ACT_CROUCHIDLE:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_IDLE_NAME, pSuffix );
+
+			case ACT_RUN_CROUCH:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_WALK_NAME, pSuffix );
+
+			case ACT_IDLE:
+			default:
+				return CalcSequenceIndex( "%s%s", DEFAULT_IDLE_NAME, pSuffix );
+		}
+	}
+}
+
+
+const char* CCSPlayerAnimState::GetWeaponSuffix()
+{
+	VPROF( "CCSPlayerAnimState::GetWeaponSuffix" );
+
+	// Figure out the weapon suffix.
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return 0;
+
+	const char *pSuffix = pWeapon->GetCSWpnData().m_szAnimExtension;
+
+#ifdef CS_SHIELD_ENABLED
+	if ( m_pOuter->HasShield() == true )
+	{
+		if ( m_pOuter->IsShieldDrawn() == true )
+			pSuffix = "shield";
+		else 
+			pSuffix = "shield_undeployed";
+	}
+#endif
+
+	return pSuffix;
+}
+
+
+int CCSPlayerAnimState::CalcFireLayerSequence(PlayerAnimEvent_t event)
+{
+	// Figure out the weapon suffix.
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return -1;
+
+	const char *pSuffix = GetWeaponSuffix();
+	if ( !pSuffix )
+		return -1;
+
+	char tempsuffix[32];
+	if ( pWeapon->GetWeaponID() == WEAPON_ELITE )
+	{
+		bool bPrimary = (event == PLAYERANIMEVENT_FIRE_GUN_PRIMARY);
+		Q_snprintf( tempsuffix, sizeof(tempsuffix), "%s_%c", pSuffix, bPrimary?'r':'l' );
+		pSuffix = tempsuffix;
+	}
+
+	// Grenades handle their fire events separately
+	if ( event == PLAYERANIMEVENT_THROW_GRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_HEGRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_SMOKEGRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_FLASHBANG )
+	{
+		return -1;
+	}
+
+	switch ( GetCurrentMainSequenceActivity() )
+	{
+		case ACT_PLAYER_RUN_FIRE:
+		case ACT_RUN:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_RUN_NAME, pSuffix );
+
+		case ACT_PLAYER_WALK_FIRE:
+		case ACT_WALK:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_WALK_NAME, pSuffix );
+
+		case ACT_PLAYER_CROUCH_FIRE:
+		case ACT_CROUCHIDLE:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_CROUCH_NAME, pSuffix );
+
+		case ACT_PLAYER_CROUCH_WALK_FIRE:
+		case ACT_RUN_CROUCH:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_CROUCH_WALK_NAME, pSuffix );
+
+		default:
+		case ACT_PLAYER_IDLE_FIRE:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_IDLE_NAME, pSuffix );
+	}
+}
+
+
+bool CCSPlayerAnimState::CanThePlayerMove()
+{
+	return m_pHelpers->CSAnim_CanMove();
+}
+
+
+float CCSPlayerAnimState::GetCurrentMaxGroundSpeed()
+{
+	Activity currentActivity = 	m_pOuter->GetSequenceActivity( m_pOuter->GetSequence() );
+	if ( currentActivity == ACT_WALK || currentActivity == ACT_IDLE )
+		return ANIM_TOPSPEED_WALK;
+	else if ( currentActivity == ACT_RUN )
+	{
+		if ( m_pPlayer )
+		{
+			CBaseCombatWeapon *activeWeapon = m_pPlayer->GetActiveWeapon();
+			if ( activeWeapon )
+			{
+				CWeaponCSBase *csWeapon = dynamic_cast< CWeaponCSBase * >( activeWeapon );
+				if ( csWeapon )
+				{
+					return csWeapon->GetMaxSpeed();
+				}
+			}
+		}
+		return ANIM_TOPSPEED_RUN;
+	}
+	else if ( currentActivity == ACT_RUN_CROUCH )
+		return ANIM_TOPSPEED_RUN_CROUCH;
+	else
+		return 0;
+}
+
+
+bool CCSPlayerAnimState::HandleJumping()
+{
+	if ( m_bJumping )
+	{
+		if ( m_bFirstJumpFrame )
+		{
+			m_bFirstJumpFrame = false;
+			RestartMainSequence();	// Reset the animation.
+		}
+
+		// Don't check if he's on the ground for a sec.. sometimes the client still has the
+		// on-ground flag set right when the message comes in.
+		if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
+		{
+			if ( m_pOuter->GetFlags() & FL_ONGROUND )
+			{
+				m_bJumping = false;
+				RestartMainSequence();	// Reset the animation.
+			}
+		}
+	}
+
+	// Are we still jumping? If so, keep playing the jump animation.
+	return m_bJumping;
+}
+
+
+Activity CCSPlayerAnimState::CalcMainActivity()
+{
+	float flOuterSpeed = GetOuterXYSpeed();
+
+	if ( HandleJumping() )
+	{
+		return ACT_HOP;
+	}
+	else
+	{
+		Activity idealActivity = ACT_IDLE;
+
+		if ( m_pOuter->GetFlags() & FL_DUCKING )
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+				idealActivity = ACT_RUN_CROUCH;
+			else
+				idealActivity = ACT_CROUCHIDLE;
+		}
+		else
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+			{
+				if ( flOuterSpeed > ARBITRARY_RUN_SPEED )
+					idealActivity = ACT_RUN;
+				else
+					idealActivity = ACT_WALK;
+			}
+			else
+			{
+				idealActivity = ACT_IDLE;
+			}
+		}
+
+		return idealActivity;
+	}
+}
+
+
+void CCSPlayerAnimState::DebugShowAnimState( int iStartLine )
+{
+	engine->Con_NPrintf( iStartLine++, "fire  : %s, cycle: %.2f\n", m_bFiring ? GetSequenceName( m_pOuter->GetModelPtr(), m_iFireSequence ) : "[not firing]", m_flFireCycle );
+	engine->Con_NPrintf( iStartLine++, "reload: %s, cycle: %.2f\n", m_bReloading ? GetSequenceName( m_pOuter->GetModelPtr(), m_iReloadSequence ) : "[not reloading]", m_flReloadCycle );
+	BaseClass::DebugShowAnimState( iStartLine );
+}
+
+
+void CCSPlayerAnimState::ComputeSequences( CStudioHdr *pStudioHdr )
+{
+	BaseClass::ComputeSequences( pStudioHdr );
+
+	VPROF( "CCSPlayerAnimState::ComputeSequences" );
+
+	ComputeFireSequence( pStudioHdr );
+	ComputeReloadSequence( pStudioHdr );
+	ComputeGrenadeSequence( pStudioHdr );
+}
+
+
+void CCSPlayerAnimState::ClearAnimationLayers()
+{
+	if ( !m_pOuter )
+		return;
+
+	m_pOuter->SetNumAnimOverlays( NUM_LAYERS_WANTED );
+	for ( int i=0; i < m_pOuter->GetNumAnimOverlays(); i++ )
+	{
+		// Client obeys Order of CBaseAnimatingOverlay::MAX_OVERLAYS (15), but server trusts only the ANIM_LAYER_ACTIVE flag.
+		m_pOuter->GetAnimOverlay( i )->SetOrder( CBaseAnimatingOverlay::MAX_OVERLAYS );
+#ifndef CLIENT_DLL
+		m_pOuter->GetAnimOverlay( i )->m_fFlags = 0;
+#endif
+	}
+}
+
+
+void CCSPlayerAnimState::ComputeFireSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeFireSequence" );
+
+	if ( m_delayedFire != PLAYERANIMEVENT_COUNT )
+	{
+		DoAnimationEvent( m_delayedFire, 0 );
+		m_delayedFire = PLAYERANIMEVENT_COUNT;
+	}
+
+	UpdateLayerSequenceGeneric( pStudioHdr, FIRESEQUENCE_LAYER, m_bFiring, m_flFireCycle, m_iFireSequence, false );
+}
diff --git a/mp/src/game/shared/momentum/cs_playeranimstate.h b/mp/src/game/shared/momentum/cs_playeranimstate.h
new file mode 100644
index 000000000..edc0b5bcc
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_playeranimstate.h
@@ -0,0 +1,78 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef TF_PLAYERANIMSTATE_H
+#define TF_PLAYERANIMSTATE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "convar.h"
+#include "iplayeranimstate.h"
+#include "base_playeranimstate.h"
+#include "mom_player_shared.h"
+
+#ifdef CLIENT_DLL
+	class C_BaseAnimatingOverlay;
+	class C_WeaponCSBase;
+	#define CBaseAnimatingOverlay C_BaseAnimatingOverlay
+	#define CWeaponCSBase C_WeaponCSBase
+#else
+	class CBaseAnimatingOverlay;
+	class CWeaponCSBase; 
+#endif
+
+
+// When moving this fast, he plays run anim.
+#define ARBITRARY_RUN_SPEED		175.0f
+
+
+enum PlayerAnimEvent_t
+{
+	PLAYERANIMEVENT_FIRE_GUN_PRIMARY=0,
+	PLAYERANIMEVENT_FIRE_GUN_SECONDARY,
+	PLAYERANIMEVENT_THROW_GRENADE,
+	PLAYERANIMEVENT_JUMP,
+	PLAYERANIMEVENT_RELOAD,
+	PLAYERANIMEVENT_RELOAD_START,	///< w_model partial reload for shotguns
+	PLAYERANIMEVENT_RELOAD_LOOP,	///< w_model partial reload for shotguns
+	PLAYERANIMEVENT_RELOAD_END,		///< w_model partial reload for shotguns
+	
+	PLAYERANIMEVENT_COUNT
+};
+
+
+class ICSPlayerAnimState : virtual public IPlayerAnimState
+{
+public:
+	// This is called by both the client and the server in the same way to trigger events for
+	// players firing, jumping, throwing grenades, etc.
+	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 ) = 0;
+	
+	// Returns true if we're playing the grenade prime or throw animation.
+	virtual bool IsThrowingGrenade() = 0;
+};
+
+
+// This abstracts the differences between CS players and hostages.
+class ICSPlayerAnimStateHelpers
+{
+public:
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon() = 0;
+	virtual bool CSAnim_CanMove() = 0;
+};
+
+
+ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+ICSPlayerAnimState* CreateHostageAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+
+// If this is set, then the game code needs to make sure to send player animation events
+// to the local player if he's the one being watched.
+extern ConVar cl_showanimstate;
+
+
+#endif // TF_PLAYERANIMSTATE_H
diff --git a/mp/src/game/shared/momentum/cs_weapon_parse.cpp b/mp/src/game/shared/momentum/cs_weapon_parse.cpp
new file mode 100644
index 000000000..2341d9bd2
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_weapon_parse.cpp
@@ -0,0 +1,434 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include <KeyValues.h>
+#include "cs_weapon_parse.h"
+//#include "cs_shareddefs.h"
+#include "weapon_csbase.h"
+#include "icvar.h"
+//#include "cs_gamerules.h"
+//#include "cs_blackmarket.h"
+
+
+//--------------------------------------------------------------------------------------------------------
+struct WeaponTypeInfo
+{
+    CSWeaponType type;
+    const char * name;
+};
+
+
+//--------------------------------------------------------------------------------------------------------
+WeaponTypeInfo s_weaponTypeInfo[] =
+{
+    { WEAPONTYPE_KNIFE, "Knife" },
+    { WEAPONTYPE_PISTOL, "Pistol" },
+    { WEAPONTYPE_SUBMACHINEGUN, "Submachine Gun" },	// First match is printable
+    { WEAPONTYPE_SUBMACHINEGUN, "submachinegun" },
+    { WEAPONTYPE_SUBMACHINEGUN, "smg" },
+    { WEAPONTYPE_RIFLE, "Rifle" },
+    { WEAPONTYPE_SHOTGUN, "Shotgun" },
+    { WEAPONTYPE_SNIPER_RIFLE, "Sniper" },
+    { WEAPONTYPE_MACHINEGUN, "Machine Gun" },		// First match is printable
+    { WEAPONTYPE_MACHINEGUN, "machinegun" },
+    { WEAPONTYPE_MACHINEGUN, "mg" },
+    { WEAPONTYPE_C4, "C4" },
+    { WEAPONTYPE_GRENADE, "Grenade" },
+    { WEAPONTYPE_UNKNOWN, NULL },
+};
+
+//--------------------------------------------------------------------------------------------------------------
+static const char *WeaponNames[WEAPON_MAX] =
+{
+    "weapon_none",
+
+    "weapon_p228",
+    "weapon_glock",
+    "weapon_scout",
+    "weapon_hegrenade",
+    "weapon_xm1014",
+    "weapon_c4",
+    "weapon_mac10",
+    "weapon_aug",
+    "weapon_smokegrenade",
+    "weapon_elite",
+    "weapon_fiveseven",
+    "weapon_ump45",
+    "weapon_sg550",
+
+    "weapon_galil",
+    "weapon_famas",
+    "weapon_usp",
+    "weapon_awp",
+    "weapon_mp5navy",
+    "weapon_m249",
+    "weapon_m3",
+    "weapon_m4a1",
+    "weapon_tmp",
+    "weapon_g3sg1",
+    "weapon_flashbang",
+    "weapon_deagle",
+    "weapon_sg552",
+    "weapon_ak47",
+    "weapon_knife",
+    "weapon_p90",
+
+    "weapon_shieldgun",
+};
+
+
+CCSWeaponInfo g_EquipmentInfo[MAX_EQUIPMENT];
+
+void PrepareEquipmentInfo(void)
+{
+    /*memset( g_EquipmentInfo, 0, ARRAYSIZE( g_EquipmentInfo ) );
+
+    g_EquipmentInfo[2].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR ) );
+    g_EquipmentInfo[2].SetDefaultPrice( KEVLAR_PRICE );
+    g_EquipmentInfo[2].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_KEVLAR ) );
+    g_EquipmentInfo[2].m_iTeam = TEAM_UNASSIGNED;
+    Q_strcpy( g_EquipmentInfo[2].szClassName, "weapon_vest" );
+
+    #ifdef CLIENT_DLL
+    g_EquipmentInfo[2].iconActive = new CHudTexture;
+    g_EquipmentInfo[2].iconActive->cCharacterInFont = 't';
+    #endif
+
+    g_EquipmentInfo[1].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) );
+    g_EquipmentInfo[1].SetDefaultPrice( ASSAULTSUIT_PRICE );
+    g_EquipmentInfo[1].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_ASSAULTSUIT ) );
+    g_EquipmentInfo[1].m_iTeam = TEAM_UNASSIGNED;
+    Q_strcpy( g_EquipmentInfo[1].szClassName, "weapon_vesthelm" );
+
+    #ifdef CLIENT_DLL
+    g_EquipmentInfo[1].iconActive = new CHudTexture;
+    g_EquipmentInfo[1].iconActive->cCharacterInFont = 'u';
+    #endif
+
+    g_EquipmentInfo[0].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG ) );
+    g_EquipmentInfo[0].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_NVG ) );
+    g_EquipmentInfo[0].SetDefaultPrice( NVG_PRICE );
+    g_EquipmentInfo[0].m_iTeam = TEAM_UNASSIGNED;
+    Q_strcpy( g_EquipmentInfo[0].szClassName, "weapon_nvgs" );
+
+    #ifdef CLIENT_DLL
+    g_EquipmentInfo[0].iconActive = new CHudTexture;
+    g_EquipmentInfo[0].iconActive->cCharacterInFont = 's';
+    #endif
+    */
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCSWeaponInfo * GetWeaponInfo(CSWeaponID weaponID)
+{
+    if (weaponID == WEAPON_NONE)
+        return NULL;
+
+    if (weaponID >= WEAPON_KEVLAR)
+    {
+        int iIndex = (WEAPON_MAX - weaponID) - 1;
+
+        return &g_EquipmentInfo[iIndex];
+
+    }
+
+    const char *weaponName = WeaponNames[weaponID];
+    WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot(weaponName);
+    if (hWpnInfo == GetInvalidWeaponInfoHandle())
+    {
+        return NULL;
+    }
+
+    CCSWeaponInfo *pWeaponInfo = dynamic_cast<CCSWeaponInfo*>(GetFileWeaponInfoFromHandle(hWpnInfo));
+
+    return pWeaponInfo;
+}
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponClassAsString(CSWeaponType weaponType)
+{
+    WeaponTypeInfo *info = s_weaponTypeInfo;
+    while (info->name != NULL)
+    {
+        if (info->type == weaponType)
+        {
+            return info->name;
+        }
+        ++info;
+    }
+
+    return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromString(const char * weaponType)
+{
+    WeaponTypeInfo *info = s_weaponTypeInfo;
+    while (info->name != NULL)
+    {
+        if (!Q_stricmp(info->name, weaponType))
+        {
+            return info->type;
+        }
+        ++info;
+    }
+
+    return WEAPONTYPE_UNKNOWN;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromWeaponID(CSWeaponID weaponID)
+{
+    const char *weaponStr = WeaponIDToAlias(weaponID);
+    const char *translatedAlias = GetTranslatedWeaponAlias(weaponStr);
+
+    char wpnName[128];
+    Q_snprintf(wpnName, sizeof(wpnName), "weapon_%s", translatedAlias);
+    WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot(wpnName);
+    if (hWpnInfo != GetInvalidWeaponInfoHandle())
+    {
+        CCSWeaponInfo *pWeaponInfo = dynamic_cast<CCSWeaponInfo*>(GetFileWeaponInfoFromHandle(hWpnInfo));
+        if (pWeaponInfo)
+        {
+            return pWeaponInfo->m_WeaponType;
+        }
+    }
+
+    return WEAPONTYPE_UNKNOWN;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void ParseVector(KeyValues *keyValues, const char *keyName, Vector& vec)
+{
+    vec.x = vec.y = vec.z = 0.0f;
+
+    if (!keyValues || !keyName)
+        return;
+
+    const char *vecString = keyValues->GetString(keyName, "0 0 0");
+    if (vecString && *vecString)
+    {
+        float x, y, z;
+        if (3 == sscanf(vecString, "%f %f %f", &x, &y, &z))
+        {
+            vec.x = x;
+            vec.y = y;
+            vec.z = z;
+        }
+    }
+}
+
+FileWeaponInfo_t* CreateWeaponInfo()
+{
+    return new CCSWeaponInfo;
+}
+
+CCSWeaponInfo::CCSWeaponInfo()
+{
+    m_flMaxSpeed = 1; // This should always be set in the script.
+    m_szAddonModel[0] = 0;
+}
+
+int	CCSWeaponInfo::GetWeaponPrice(void)
+{
+    return m_iWeaponPrice;
+}
+
+int	CCSWeaponInfo::GetDefaultPrice(void)
+{
+    return m_iDefaultPrice;
+}
+
+int	CCSWeaponInfo::GetPrevousPrice(void)
+{
+    return m_iPreviousPrice;
+}
+
+
+void CCSWeaponInfo::Parse(KeyValues *pKeyValuesData, const char *szWeaponName)
+{
+    BaseClass::Parse(pKeyValuesData, szWeaponName);
+
+    m_flMaxSpeed = (float) pKeyValuesData->GetInt("MaxPlayerSpeed", 1);
+
+    m_iDefaultPrice = m_iWeaponPrice = pKeyValuesData->GetInt("WeaponPrice", -1);
+    if (m_iWeaponPrice == -1)
+    {
+        // This weapon should have the price in its script.
+        Assert(false);
+    }
+
+    /*if ( CSGameRules()->IsBlackMarket() )
+    {
+    int iWeaponID = ClassnameToWeaponID( GetTranslatedWeaponAlias ( szWeaponName ) );
+
+    m_iDefaultPrice = m_iWeaponPrice;
+    m_iPreviousPrice = CSGameRules()->GetBlackMarketPreviousPriceForWeapon( iWeaponID );
+    m_iWeaponPrice = CSGameRules()->GetBlackMarketPriceForWeapon( iWeaponID );
+    }*/
+
+    m_flArmorRatio = pKeyValuesData->GetFloat("WeaponArmorRatio", 1);
+    m_iCrosshairMinDistance = pKeyValuesData->GetInt("CrosshairMinDistance", 4);
+    m_iCrosshairDeltaDistance = pKeyValuesData->GetInt("CrosshairDeltaDistance", 3);
+    m_bCanUseWithShield = !!pKeyValuesData->GetInt("CanEquipWithShield", false);
+    m_flMuzzleScale = pKeyValuesData->GetFloat("MuzzleFlashScale", 1);
+
+    const char *pMuzzleFlashStyle = pKeyValuesData->GetString("MuzzleFlashStyle", "CS_MUZZLEFLASH_NORM");
+
+    if (pMuzzleFlashStyle)
+    {
+        if (Q_stricmp(pMuzzleFlashStyle, "CS_MUZZLEFLASH_X") == 0)
+        {
+            m_iMuzzleFlashStyle = CS_MUZZLEFLASH_X;
+        }
+        else if (Q_stricmp(pMuzzleFlashStyle, "CS_MUZZLEFLASH_NONE") == 0)
+        {
+            m_iMuzzleFlashStyle = CS_MUZZLEFLASH_NONE;
+        }
+        else
+        {
+            m_iMuzzleFlashStyle = CS_MUZZLEFLASH_NORM;
+        }
+    }
+    else
+    {
+        Assert(false);
+    }
+
+    m_iPenetration = pKeyValuesData->GetInt("Penetration", 1);
+    m_iDamage = pKeyValuesData->GetInt("Damage", 42); // Douglas Adams 1952 - 2001
+    m_flRange = pKeyValuesData->GetFloat("Range", 8192.0f);
+    m_flRangeModifier = pKeyValuesData->GetFloat("RangeModifier", 0.98f);
+    m_iBullets = pKeyValuesData->GetInt("Bullets", 1);
+    m_flCycleTime = pKeyValuesData->GetFloat("CycleTime", 0.15);
+    m_bAccuracyQuadratic = pKeyValuesData->GetBool("AccuracyQuadratic", false);
+    m_flAccuracyDivisor = pKeyValuesData->GetFloat("AccuracyDivisor", -1); // -1 = off
+    m_flAccuracyOffset = pKeyValuesData->GetFloat("AccuracyOffset", 0);
+    m_flMaxInaccuracy = pKeyValuesData->GetFloat("MaxInaccuracy", 0);
+
+    m_flTimeToIdleAfterFire = pKeyValuesData->GetFloat("TimeToIdle", 2);
+    m_flIdleInterval = pKeyValuesData->GetFloat("IdleInterval", 20);
+
+    // Figure out what team can have this weapon.
+    m_iTeam = TEAM_UNASSIGNED;
+    /*const char *pTeam = pKeyValuesData->GetString( "Team", NULL );
+    if ( pTeam )
+    {
+    if ( Q_stricmp( pTeam, "CT" ) == 0 )
+    {
+    m_iTeam = TEAM_CT;
+    }
+    else if ( Q_stricmp( pTeam, "TERRORIST" ) == 0 )
+    {
+    m_iTeam = TEAM_TERRORIST;
+    }
+    else if ( Q_stricmp( pTeam, "ANY" ) == 0 )
+    {
+    m_iTeam = TEAM_UNASSIGNED;
+    }
+    else
+    {
+    Assert( false );
+    }
+    }
+    else
+    {
+    Assert( false );
+    }*/
+
+
+    const char *pWrongTeamMsg = pKeyValuesData->GetString("WrongTeamMsg", "");
+    Q_strncpy(m_WrongTeamMsg, pWrongTeamMsg, sizeof(m_WrongTeamMsg));
+
+    const char *pShieldViewModel = pKeyValuesData->GetString("shieldviewmodel", "");
+    Q_strncpy(m_szShieldViewModel, pShieldViewModel, sizeof(m_szShieldViewModel));
+
+    const char *pAnimEx = pKeyValuesData->GetString("PlayerAnimationExtension", "m4");
+    Q_strncpy(m_szAnimExtension, pAnimEx, sizeof(m_szAnimExtension));
+
+    // Default is 2000.
+    m_flBotAudibleRange = pKeyValuesData->GetFloat("BotAudibleRange", 2000.0f);
+
+    const char *pTypeString = pKeyValuesData->GetString("WeaponType", NULL);
+
+    m_WeaponType = WEAPONTYPE_UNKNOWN;
+    if (!pTypeString)
+    {
+        Assert(false);
+    }
+    else if (Q_stricmp(pTypeString, "Knife") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_KNIFE;
+    }
+    else if (Q_stricmp(pTypeString, "Pistol") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_PISTOL;
+    }
+    else if (Q_stricmp(pTypeString, "Rifle") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_RIFLE;
+    }
+    else if (Q_stricmp(pTypeString, "Shotgun") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_SHOTGUN;
+    }
+    else if (Q_stricmp(pTypeString, "SniperRifle") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_SNIPER_RIFLE;
+    }
+    else if (Q_stricmp(pTypeString, "SubMachinegun") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_SUBMACHINEGUN;
+    }
+    else if (Q_stricmp(pTypeString, "Machinegun") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_MACHINEGUN;
+    }
+    else if (Q_stricmp(pTypeString, "C4") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_C4;
+    }
+    else if (Q_stricmp(pTypeString, "Grenade") == 0)
+    {
+        m_WeaponType = WEAPONTYPE_GRENADE;
+    }
+    else
+    {
+        Assert(false);
+    }
+
+    // Read the addon model.
+    Q_strncpy(m_szAddonModel, pKeyValuesData->GetString("AddonModel"), sizeof(m_szAddonModel));
+
+    // Read the dropped model.
+    Q_strncpy(m_szDroppedModel, pKeyValuesData->GetString("DroppedModel"), sizeof(m_szDroppedModel));
+
+    // Read the silencer model.
+    Q_strncpy(m_szSilencerModel, pKeyValuesData->GetString("SilencerModel"), sizeof(m_szSilencerModel));
+
+#ifndef CLIENT_DLL
+    // Enforce consistency for the weapon here, since that way we don't need to save off the model bounds
+    // for all time.
+    //engine->ForceExactFile( UTIL_VarArgs("scripts/%s.ctx", szWeaponName ) );
+
+    // Model bounds are rounded to the nearest integer, then extended by 1
+    engine->ForceModelBounds(szWorldModel, Vector(-15, -12, -18), Vector(44, 16, 19));
+    if (m_szAddonModel[0])
+    {
+        engine->ForceModelBounds(m_szAddonModel, Vector(-5, -5, -6), Vector(13, 5, 7));
+    }
+    if (m_szSilencerModel[0])
+    {
+        engine->ForceModelBounds(m_szSilencerModel, Vector(-15, -12, -18), Vector(44, 16, 19));
+    }
+#endif // !CLIENT_DLL
+}
+
+
diff --git a/mp/src/game/shared/momentum/cs_weapon_parse.h b/mp/src/game/shared/momentum/cs_weapon_parse.h
new file mode 100644
index 000000000..d1f360a5e
--- /dev/null
+++ b/mp/src/game/shared/momentum/cs_weapon_parse.h
@@ -0,0 +1,189 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_WEAPON_PARSE_H
+#define CS_WEAPON_PARSE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_parse.h"
+#include "networkvar.h"
+
+
+//--------------------------------------------------------------------------------------------------------
+enum CSWeaponType
+{
+
+	WEAPONTYPE_KNIFE=0,	
+	WEAPONTYPE_PISTOL,
+	WEAPONTYPE_SUBMACHINEGUN,
+	WEAPONTYPE_RIFLE,
+	WEAPONTYPE_SHOTGUN,
+	WEAPONTYPE_SNIPER_RIFLE,
+	WEAPONTYPE_MACHINEGUN,
+	WEAPONTYPE_C4,
+	WEAPONTYPE_GRENADE,
+	WEAPONTYPE_UNKNOWN
+
+};
+
+
+//--------------------------------------------------------------------------------------------------------
+enum CSWeaponID
+{
+	WEAPON_NONE = 0,
+
+	WEAPON_P228,
+	WEAPON_GLOCK,
+	WEAPON_SCOUT,
+	WEAPON_HEGRENADE,
+	WEAPON_XM1014,
+	WEAPON_C4,
+	WEAPON_MAC10,
+	WEAPON_AUG,
+	WEAPON_SMOKEGRENADE,
+	WEAPON_ELITE,
+	WEAPON_FIVESEVEN,
+	WEAPON_UMP45,
+	WEAPON_SG550,
+
+	WEAPON_GALIL,
+	WEAPON_FAMAS,
+	WEAPON_USP,
+	WEAPON_AWP,
+	WEAPON_MP5NAVY,
+	WEAPON_M249,
+	WEAPON_M3,
+	WEAPON_M4A1,
+	WEAPON_TMP,
+	WEAPON_G3SG1,
+	WEAPON_FLASHBANG,
+	WEAPON_DEAGLE,
+	WEAPON_SG552,
+	WEAPON_AK47,
+	WEAPON_KNIFE,
+	WEAPON_P90,
+
+	WEAPON_SHIELDGUN,	// BOTPORT: Is this still needed?
+
+	WEAPON_KEVLAR,
+	WEAPON_ASSAULTSUIT,
+	WEAPON_NVG,
+
+	WEAPON_MAX,		// number of weapons weapon index
+};
+
+
+#define MAX_EQUIPMENT (WEAPON_MAX - WEAPON_KEVLAR)
+
+void PrepareEquipmentInfo( void );
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponClassAsString( CSWeaponType weaponType );
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromString( const char * weaponType );
+
+//--------------------------------------------------------------------------------------------------------
+enum CSWeaponID;
+
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponClassAsString( CSWeaponType weaponType );
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromString( const char * weaponType );
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromWeaponID( CSWeaponID weaponID );
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromWeaponID( CSWeaponID weaponID );
+
+
+//--------------------------------------------------------------------------------------------------------
+class CCSWeaponInfo : public FileWeaponInfo_t
+{
+public:
+	DECLARE_CLASS_GAMEROOT( CCSWeaponInfo, FileWeaponInfo_t );
+	
+	CCSWeaponInfo();
+	
+	virtual void Parse( ::KeyValues *pKeyValuesData, const char *szWeaponName );
+
+	int GetRealWeaponPrice( void ) { return m_iWeaponPrice; }
+
+
+public:
+
+	float m_flMaxSpeed;			// How fast the player can run while this is his primary weapon.
+
+	CSWeaponType m_WeaponType;
+
+	int m_iTeam;				// Which team can have this weapon. TEAM_UNASSIGNED if both can have it.
+	float m_flBotAudibleRange;	// How far away a bot can hear this weapon.
+	float m_flArmorRatio;
+
+	int	  m_iCrosshairMinDistance;
+	int	  m_iCrosshairDeltaDistance;
+	
+	bool  m_bCanUseWithShield;
+	
+	char m_WrongTeamMsg[32];	// Reference to a string describing the error if someone tries to buy
+								// this weapon but they're on the wrong team to have it.
+								// Zero-length if no specific message for this weapon.
+
+	char m_szAnimExtension[16];
+	char m_szShieldViewModel[64];
+
+	char m_szAddonModel[MAX_WEAPON_STRING];		// If this is set, it is used as the addon model. Otherwise, szWorldModel is used.
+	char m_szDroppedModel[MAX_WEAPON_STRING];	// Alternate dropped model, if different from the szWorldModel the player holds
+	char m_szSilencerModel[MAX_WEAPON_STRING];	// Alternate model with silencer attached
+
+	int	  m_iMuzzleFlashStyle;
+	float m_flMuzzleScale;
+	
+	// Parameters for FX_FireBullets:
+	int		m_iPenetration;
+	int		m_iDamage;
+	float	m_flRange;
+	float	m_flRangeModifier;
+	int		m_iBullets;
+	float	m_flCycleTime;
+
+	// Variables that control how fast the weapon's accuracy changes as it is fired.
+	bool	m_bAccuracyQuadratic;
+	float	m_flAccuracyDivisor;
+	float	m_flAccuracyOffset;
+	float	m_flMaxInaccuracy;
+
+	// Delay until the next idle animation after shooting.
+	float	m_flTimeToIdleAfterFire;
+	float	m_flIdleInterval;
+   
+	int		GetWeaponPrice( void );
+	int		GetDefaultPrice( void );
+	int		GetPrevousPrice( void );
+	void	SetWeaponPrice( int iPrice ) { m_iWeaponPrice = iPrice; }
+	void	SetDefaultPrice( int iPrice ) { m_iDefaultPrice = iPrice; }
+	void	SetPreviousPrice( int iPrice ) { m_iPreviousPrice = iPrice; }
+    
+private:
+
+	int m_iWeaponPrice;
+	int m_iDefaultPrice;
+	int m_iPreviousPrice;
+
+};
+
+
+#endif // CS_WEAPON_PARSE_H
diff --git a/mp/src/game/shared/momentum/fx_cs_shared.cpp b/mp/src/game/shared/momentum/fx_cs_shared.cpp
new file mode 100644
index 000000000..9af61c5de
--- /dev/null
+++ b/mp/src/game/shared/momentum/fx_cs_shared.cpp
@@ -0,0 +1,264 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "fx_cs_shared.h"
+#include "weapon_csbase.h"
+
+#ifndef CLIENT_DLL
+#include "ilagcompensationmanager.h"
+#endif
+
+
+#ifdef CLIENT_DLL
+
+#include "fx_impact.h"
+
+// this is a cheap ripoff from CBaseCombatWeapon::WeaponSound():
+void FX_WeaponSound(
+    int iPlayerIndex,
+    WeaponSound_t sound_type,
+    const Vector &vOrigin,
+    CCSWeaponInfo *pWeaponInfo)
+{
+
+    // If we have some sounds from the weapon classname.txt file, play a random one of them
+    const char *shootsound = pWeaponInfo->aShootSounds[sound_type];
+    if (!shootsound || !shootsound[0])
+        return;
+
+    CBroadcastRecipientFilter filter; // this is client side only
+    if (!te->CanPredict())
+        return;
+
+    CBaseEntity::EmitSound(filter, iPlayerIndex, shootsound, &vOrigin);
+}
+
+class CGroupedSound
+{
+public:
+    string_t m_SoundName;
+    Vector m_vPos;
+};
+
+CUtlVector<CGroupedSound> g_GroupedSounds;
+
+
+// Called by the ImpactSound function.
+void ShotgunImpactSoundGroup(const char *pSoundName, const Vector &vEndPos)
+{
+    int i;
+    // Don't play the sound if it's too close to another impact sound.
+    for (i = 0; i < g_GroupedSounds.Count(); i++)
+    {
+        CGroupedSound *pSound = &g_GroupedSounds[i];
+
+        if (vEndPos.DistToSqr(pSound->m_vPos) < 300 * 300)
+        {
+            if (Q_stricmp(pSound->m_SoundName, pSoundName) == 0)
+                return;
+        }
+    }
+
+    // Ok, play the sound and add it to the list.
+    CLocalPlayerFilter filter;
+    C_BaseEntity::EmitSound(filter, NULL, pSoundName, &vEndPos);
+
+    i = g_GroupedSounds.AddToTail();
+    g_GroupedSounds[i].m_SoundName = pSoundName;
+    g_GroupedSounds[i].m_vPos = vEndPos;
+}
+
+
+void StartGroupingSounds()
+{
+    Assert(g_GroupedSounds.Count() == 0);
+    SetImpactSoundRoute(ShotgunImpactSoundGroup);
+}
+
+
+void EndGroupingSounds()
+{
+    g_GroupedSounds.Purge();
+    SetImpactSoundRoute(NULL);
+}
+
+#else
+
+#include "momentum/te_shotgun_shot.h"
+
+// Server doesn't play sounds anyway.
+void StartGroupingSounds() {}
+void EndGroupingSounds() {}
+void FX_WeaponSound ( int iPlayerIndex,
+    WeaponSound_t sound_type,
+    const Vector &vOrigin,
+    CCSWeaponInfo *pWeaponInfo ) {};
+
+#endif
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets(
+    int	iPlayerIndex,
+    const Vector &vOrigin,
+    const QAngle &vAngles,
+    int	iWeaponID,
+    int	iMode,
+    int iSeed,
+    float flSpread
+    )
+{
+    bool bDoEffects = true;
+
+#ifdef CLIENT_DLL
+    CMomentumPlayer *pPlayer = ToCMOMPlayer(ClientEntityList().GetBaseEntity(iPlayerIndex));
+#else
+    CMomentumPlayer *pPlayer = ToCMOMPlayer( UTIL_PlayerByIndex( iPlayerIndex) );
+#endif
+
+    const char * weaponAlias = WeaponIDToAlias(iWeaponID);
+
+    if (!weaponAlias)
+    {
+        DevMsg("FX_FireBullets: weapon alias for ID %i not found\n", iWeaponID);
+        return;
+    }
+
+    char wpnName[128];
+    Q_snprintf(wpnName, sizeof(wpnName), "weapon_%s", weaponAlias);
+    WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot(wpnName);
+
+    if (hWpnInfo == GetInvalidWeaponInfoHandle())
+    {
+        DevMsg("FX_FireBullets: LookupWeaponInfoSlot failed for weapon %s\n", wpnName);
+        return;
+    }
+
+    CCSWeaponInfo *pWeaponInfo = static_cast<CCSWeaponInfo*>(GetFileWeaponInfoFromHandle(hWpnInfo));
+
+    // Do the firing animation event.
+    if (pPlayer && !pPlayer->IsDormant())
+    {
+        //if (iMode == Primary_Mode)
+         //   pPlayer->GetPlayerAnimState()->DoAnimationEvent(PLAYERANIMEVENT_FIRE_GUN_PRIMARY);
+        //else
+        //    pPlayer->GetPlayerAnimState()->DoAnimationEvent(PLAYERANIMEVENT_FIRE_GUN_SECONDARY);
+    }
+
+#ifndef CLIENT_DLL
+    // if this is server code, send the effect over to client as temp entity
+    // Dispatch one message for all the bullet impacts and sounds.
+    TE_FireBullets( 
+        iPlayerIndex,
+        vOrigin, 
+        vAngles, 
+        iWeaponID,
+        iMode,
+        iSeed,
+        flSpread
+        );
+
+
+    // Let the player remember the usercmd he fired a weapon on. Assists in making decisions about lag compensation.
+    //pPlayer->NoteWeaponFired();
+
+    bDoEffects = false; // no effects on server
+#endif
+
+    iSeed++;
+
+    bool	bPrimaryMode = (iMode == Primary_Mode);
+    int		iDamage = pWeaponInfo->m_iDamage;
+    float	flRange = pWeaponInfo->m_flRange;
+    int		iPenetration = pWeaponInfo->m_iPenetration;
+    float	flRangeModifier = pWeaponInfo->m_flRangeModifier;
+    int		iAmmoType = pWeaponInfo->iAmmoType;
+
+    WeaponSound_t sound_type = SINGLE;
+
+    // CS HACK, tweak some weapon values based on primary/secondary mode
+
+    if (iWeaponID == WEAPON_GLOCK)
+    {
+        if (!bPrimaryMode)
+        {
+            iDamage = 18;	// reduced power for burst shots
+            flRangeModifier = 0.9f;
+        }
+    }
+    else if (iWeaponID == WEAPON_M4A1)
+    {
+        if (!bPrimaryMode)
+        {
+            flRangeModifier = 0.95f; // slower bullets in silenced mode
+            sound_type = SPECIAL1;
+        }
+    }
+    else if (iWeaponID == WEAPON_USP)
+    {
+        if (!bPrimaryMode)
+        {
+            iDamage = 30; // reduced damage in silenced mode
+            sound_type = SPECIAL1;
+        }
+    }
+
+
+    if (bDoEffects)
+    {
+        FX_WeaponSound(iPlayerIndex, sound_type, vOrigin, pWeaponInfo);
+    }
+
+
+    // Fire bullets, calculate impacts & effects
+
+    if (!pPlayer)
+        return;
+
+    StartGroupingSounds();
+
+#ifdef GAME_DLL
+    //pPlayer->StartNewBulletGroup();
+#endif
+
+#if !defined (CLIENT_DLL)
+    // Move other players back to history positions based on local player's lag
+    lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+
+    for (int iBullet = 0; iBullet < pWeaponInfo->m_iBullets; iBullet++)
+    {
+        RandomSeed(iSeed);	// init random system with this seed
+
+        // Get circular gaussian spread.
+        float x, y;
+        x = RandomFloat(-0.5, 0.5) + RandomFloat(-0.5, 0.5);
+        y = RandomFloat(-0.5, 0.5) + RandomFloat(-0.5, 0.5);
+
+        iSeed++; // use new seed for next bullet
+
+        pPlayer->FireBullet(
+            vOrigin,
+            vAngles,
+            flSpread,
+            flRange,
+            iPenetration,
+            iAmmoType,
+            iDamage,
+            flRangeModifier,
+            pPlayer,
+            bDoEffects,
+            x, y);
+    }
+
+#if !defined (CLIENT_DLL)
+    lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+
+    EndGroupingSounds();
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/fx_cs_shared.h b/mp/src/game/shared/momentum/fx_cs_shared.h
new file mode 100644
index 000000000..2306e92b0
--- /dev/null
+++ b/mp/src/game/shared/momentum/fx_cs_shared.h
@@ -0,0 +1,30 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef FX_CS_SHARED_H
+#define FX_CS_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mom_player_shared.h"
+
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets( 
+	int	iPlayer,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float flSpread
+	);
+
+
+#endif // FX_CS_SHARED_H
diff --git a/mp/src/game/shared/momentum/mom_gamemovement.cpp b/mp/src/game/shared/momentum/mom_gamemovement.cpp
new file mode 100644
index 000000000..d2e2b6da5
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_gamemovement.cpp
@@ -0,0 +1,1204 @@
+#include "cbase.h"
+#include "mom_gamemovement.h"
+#include "in_buttons.h"
+#include <stdarg.h>
+#include "movevars_shared.h"
+#include "engine/IEngineTrace.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "decals.h"
+#include "coordsize.h"
+
+#include "tier0/memdbgon.h"
+
+#define	STOP_EPSILON		0.1
+#define	MAX_CLIP_PLANES		5
+
+extern bool g_bMovementOptimizations;
+// remove this eventually
+ConVar sv_ramp_fix("sv_ramp_fix", "1");
+
+#ifndef CLIENT_DLL
+#include "env_player_surface_trigger.h"
+static ConVar dispcoll_drawplane("dispcoll_drawplane", "0");
+#endif
+
+#ifndef player
+#define player GetMomentumPlayer()
+
+CMomentumGameMovement::CMomentumGameMovement()
+{
+
+}
+
+float CMomentumGameMovement::LadderLateralMultiplier(void) const
+{
+    if (mv->m_nButtons & IN_DUCK)
+    {
+        return 1.0f;
+    }
+    else
+    {
+        return 0.5f;
+    }
+}
+
+float CMomentumGameMovement::ClimbSpeed(void) const
+{
+    if (mv->m_nButtons & IN_DUCK)
+    {
+        return BaseClass::ClimbSpeed() * DuckSpeedMultiplier;
+    }
+    else
+    {
+        return BaseClass::ClimbSpeed();
+    }
+}
+
+void CMomentumGameMovement::WalkMove()
+{
+    BaseClass::WalkMove();
+    CheckForLadders(player->GetGroundEntity() != NULL);
+}
+
+void CMomentumGameMovement::CheckForLadders(bool wasOnGround)
+{
+    if (!wasOnGround)
+    {
+        // If we're higher than the last place we were on the ground, bail - obviously we're not dropping
+        // past a ladder we might want to grab.
+        if (mv->GetAbsOrigin().z > player->m_lastStandingPos.z)
+            return;
+
+        Vector dir = -player->m_lastStandingPos + mv->GetAbsOrigin();
+        if (!dir.x && !dir.y)
+        {
+            // If we're dropping straight down, we don't know which way to look for a ladder.  Oh well.
+            return;
+        }
+
+        dir.z = 0.0f;
+        float dist = dir.NormalizeInPlace();
+        if (dist > 64.0f)
+        {
+            // Don't grab ladders too far behind us.
+            return;
+        }
+
+        trace_t trace;
+
+        TracePlayerBBox(
+            mv->GetAbsOrigin(),
+            player->m_lastStandingPos - dir*(5 + dist),
+            (PlayerSolidMask() & (~CONTENTS_PLAYERCLIP)), COLLISION_GROUP_PLAYER_MOVEMENT, trace);
+
+        if (trace.fraction != 1.0f && OnLadder(trace) && trace.plane.normal.z != 1.0f)
+        {
+            if (player->CanGrabLadder(trace.endpos, trace.plane.normal))
+            {
+                player->SetMoveType(MOVETYPE_LADDER);
+                player->SetMoveCollide(MOVECOLLIDE_DEFAULT);
+
+                player->SetLadderNormal(trace.plane.normal);
+                mv->m_vecVelocity.Init();
+
+                // The ladder check ignored playerclips, to fix a bug exposed by de_train, where a clipbrush is
+                // flush with a ladder.  This causes the above tracehull to fail unless we ignore playerclips.
+                // However, we have to check for playerclips before we snap to that pos, so we don't warp a
+                // player into a clipbrush.
+                TracePlayerBBox(
+                    mv->GetAbsOrigin(),
+                    player->m_lastStandingPos - dir*(5 + dist),
+                    PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace);
+
+                mv->SetAbsOrigin(trace.endpos);
+            }
+        }
+    }
+    else
+    {
+        player->m_lastStandingPos = mv->GetAbsOrigin();
+    }
+}
+
+bool CMomentumGameMovement::LadderMove(void)
+{
+    bool isOnLadder = BaseClass::LadderMove();
+    if (isOnLadder && player)
+    {
+        player->SurpressLadderChecks(mv->GetAbsOrigin(), player->m_vecLadderNormal);
+    }
+    return isOnLadder;
+
+}
+
+bool CMomentumGameMovement::OnLadder(trace_t &trace)
+{
+    if (trace.plane.normal.z == 1.0f)
+        return false;
+
+    return BaseClass::OnLadder(trace);
+}
+
+void CMomentumGameMovement::HandleDuckingSpeedCrop()
+{
+    if (!m_iSpeedCropped && (player->GetFlags() & FL_DUCKING))
+    {
+        float frac = 0.34f;//0.33333333f;
+        mv->m_flForwardMove *= frac;
+        mv->m_flSideMove *= frac;
+        mv->m_flUpMove *= frac;
+        m_iSpeedCropped = true;
+    }
+}
+
+bool CMomentumGameMovement::CanUnduck()
+{
+    trace_t trace;
+    Vector newOrigin;
+
+    VectorCopy(mv->GetAbsOrigin(), newOrigin);
+
+    if (player->GetGroundEntity() != NULL)
+    {
+        newOrigin += VEC_DUCK_HULL_MIN - VEC_HULL_MIN;
+    }
+    else
+    {
+        // If in air an letting go of croush, make sure we can offset origin to make
+        //  up for uncrouching
+        Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
+        Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;
+
+        newOrigin += -0.5f * (hullSizeNormal - hullSizeCrouch);
+    }
+
+    UTIL_TraceHull(mv->GetAbsOrigin(), newOrigin, VEC_HULL_MIN, VEC_HULL_MAX, PlayerSolidMask(), player, COLLISION_GROUP_PLAYER_MOVEMENT, &trace);
+
+    if (trace.startsolid || (trace.fraction != 1.0f))
+        return false;
+
+    return true;
+}
+
+void CMomentumGameMovement::Duck(void)
+{
+    int buttonsChanged = (mv->m_nOldButtons ^ mv->m_nButtons);	// These buttons have changed this frame
+    int buttonsPressed = buttonsChanged & mv->m_nButtons;			// The changed ones still down are "pressed"
+    int buttonsReleased = buttonsChanged & mv->m_nOldButtons;		// The changed ones which were previously down are "released"
+
+    if (mv->m_nButtons & IN_DUCK)
+    {
+        mv->m_nOldButtons |= IN_DUCK;
+    }
+    else
+    {
+        mv->m_nOldButtons &= ~IN_DUCK;
+    }
+
+    if (IsDead())
+    {
+        // Unduck
+        if (player->GetFlags() & FL_DUCKING)
+        {
+            FinishUnDuck();
+        }
+        return;
+    }
+
+    HandleDuckingSpeedCrop();
+
+    // Holding duck, in process of ducking or fully ducked?
+    if ((mv->m_nButtons & IN_DUCK) || (player->m_Local.m_bDucking) || (player->GetFlags() & FL_DUCKING))
+    {
+        if (mv->m_nButtons & IN_DUCK)
+        {
+            bool alreadyDucked = (player->GetFlags() & FL_DUCKING) ? true : false;
+
+            if ((buttonsPressed & IN_DUCK) && !(player->GetFlags() & FL_DUCKING))
+            {
+                // Use 1 second so super long jump will work
+                player->m_Local.m_flDucktime = 1000;
+                player->m_Local.m_bDucking = true;
+            }
+
+            float duckmilliseconds = max(0.0f, 1000.0f - (float) player->m_Local.m_flDucktime);
+            float duckseconds = duckmilliseconds / 1000.0f;
+
+            //time = max( 0.0, ( 1.0 - (float)player->m_Local.m_flDucktime / 1000.0 ) );
+
+            if (player->m_Local.m_bDucking)
+            {
+                // Finish ducking immediately if duck time is over or not on ground
+                if ((duckseconds > TIME_TO_DUCK) ||
+                    (player->GetGroundEntity() == NULL) ||
+                    alreadyDucked)
+                {
+                    FinishDuck();
+                }
+                else
+                {
+                    // Calc parametric time
+                    float duckFraction = SimpleSpline(duckseconds / TIME_TO_DUCK);
+                    SetDuckedEyeOffset(duckFraction);
+                }
+            }
+        }
+        else
+        {
+            // Try to unduck unless automovement is not allowed
+            // NOTE: When not onground, you can always unduck
+            if (player->m_Local.m_bAllowAutoMovement || player->GetGroundEntity() == NULL)
+            {
+                if ((buttonsReleased & IN_DUCK) && (player->GetFlags() & FL_DUCKING))
+                {
+                    // Use 1 second so super long jump will work
+                    player->m_Local.m_flDucktime = 1000;
+                    player->m_Local.m_bDucking = true;  // or unducking
+                }
+
+                float duckmilliseconds = max(0.0f, 1000.0f - (float) player->m_Local.m_flDucktime);
+                float duckseconds = duckmilliseconds / 1000.0f;
+
+                if (CanUnduck())
+                {
+                    if (player->m_Local.m_bDucking ||
+                        player->m_Local.m_bDucked) // or unducking
+                    {
+                        // Finish ducking immediately if duck time is over or not on ground
+                        if ((duckseconds > TIME_TO_UNDUCK) ||
+                            (player->GetGroundEntity() == NULL))
+                        {
+                            FinishUnDuck();
+                        }
+                        else
+                        {
+                            // Calc parametric time
+                            float duckFraction = SimpleSpline(1.0f - (duckseconds / TIME_TO_UNDUCK));
+                            SetDuckedEyeOffset(duckFraction);
+                        }
+                    }
+                }
+                else
+                {
+                    // Still under something where we can't unduck, so make sure we reset this timer so
+                    //  that we'll unduck once we exit the tunnel, etc.
+                    player->m_Local.m_flDucktime = 1000;
+                }
+            }
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop ducking
+//-----------------------------------------------------------------------------
+void CMomentumGameMovement::FinishUnDuck(void)
+{
+    trace_t trace;
+    Vector newOrigin;
+
+    VectorCopy(mv->GetAbsOrigin(), newOrigin);
+
+    if (player->GetGroundEntity() != NULL)
+    {
+        newOrigin += VEC_DUCK_HULL_MIN - VEC_HULL_MIN;
+    }
+    else
+    {
+        // If in air an letting go of croush, make sure we can offset origin to make
+        //  up for uncrouching
+        Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
+        Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;
+
+        Vector viewDelta = -0.5f * (hullSizeNormal - hullSizeCrouch);
+
+        VectorAdd(newOrigin, viewDelta, newOrigin);
+    }
+
+    player->m_Local.m_bDucked = false;
+    player->RemoveFlag(FL_DUCKING);
+    player->m_Local.m_bDucking = false;
+    player->SetViewOffset(GetPlayerViewOffset(false));
+    player->m_Local.m_flDucktime = 0;
+
+    mv->SetAbsOrigin(newOrigin);
+
+    // Recategorize position since ducking can change origin
+    CategorizePosition();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finish ducking
+//-----------------------------------------------------------------------------
+void CMomentumGameMovement::FinishDuck(void)
+{
+    Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
+    Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;
+
+    Vector viewDelta = 0.5f * (hullSizeNormal - hullSizeCrouch);
+
+    player->SetViewOffset(GetPlayerViewOffset(true));
+    player->AddFlag(FL_DUCKING);
+    player->m_Local.m_bDucking = false;
+
+    if (!player->m_Local.m_bDucked)
+    {
+
+        Vector org = mv->GetAbsOrigin();
+
+        if (player->GetGroundEntity() != NULL)
+        {
+            org -= VEC_DUCK_HULL_MIN - VEC_HULL_MIN;
+        }
+        else
+        {
+            org += viewDelta;
+        }
+        mv->SetAbsOrigin(org);
+
+        player->m_Local.m_bDucked = true;
+    }
+
+    // See if we are stuck?
+    FixPlayerCrouchStuck(true);
+
+    // Recategorize position since ducking can change origin
+    CategorizePosition();
+}
+
+
+void CMomentumGameMovement::PlayerMove()
+{
+    BaseClass::PlayerMove();
+
+    if (player->IsAlive())
+    {
+        // Check if our eye height is too close to the ceiling and lower it.
+        // This is needed because we have taller models with the old collision bounds.
+
+        const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling
+
+        Vector offset = player->GetViewOffset();
+
+        Vector vHullMin = GetPlayerMins(player->m_Local.m_bDucked);
+        vHullMin.z = 0.0f;
+        Vector vHullMax = GetPlayerMaxs(player->m_Local.m_bDucked);
+
+        Vector start = player->GetAbsOrigin();
+        start.z += vHullMax.z;
+        Vector end = start;
+        end.z += eyeClearance - vHullMax.z;
+        end.z += player->m_Local.m_bDucked ? VEC_DUCK_VIEW.z : VEC_VIEW.z;
+
+        vHullMax.z = 0.0f;
+
+        Vector fudge(1, 1, 0);
+        vHullMin += fudge;
+        vHullMax -= fudge;
+
+        trace_t trace;
+        Ray_t ray;
+        ray.Init(start, end, vHullMin, vHullMax);
+        UTIL_TraceRay(ray, PlayerSolidMask(), mv->m_nPlayerHandle.Get(), COLLISION_GROUP_PLAYER_MOVEMENT, &trace);
+
+        if (trace.fraction < 1.0f)
+        {
+            float est = start.z + trace.fraction * (end.z - start.z) - player->GetAbsOrigin().z - eyeClearance;
+            if ((player->GetFlags() & FL_DUCKING) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked)
+            {
+                offset.z = est;
+            }
+            else
+            {
+                offset.z = min(est, offset.z);
+            }
+            player->SetViewOffset(offset);
+        }
+        else
+        {
+            if ((player->GetFlags() & FL_DUCKING) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked)
+            {
+                player->SetViewOffset(VEC_VIEW);
+            }
+            else if (player->m_Local.m_bDucked && !player->m_Local.m_bDucking)
+            {
+                player->SetViewOffset(VEC_DUCK_VIEW);
+            }
+        }
+    }
+}
+
+
+bool CMomentumGameMovement::CheckJumpButton()
+{
+
+    if (player->pl.deadflag)
+    {
+        mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+        return false;
+    }
+
+    // See if we are waterjumping.  If so, decrement count and return.
+    if (player->m_flWaterJumpTime)
+    {
+        player->m_flWaterJumpTime -= gpGlobals->frametime;
+        if (player->m_flWaterJumpTime < 0)
+            player->m_flWaterJumpTime = 0;
+
+        return false;
+    }
+
+    // If we are in the water most of the way...
+    if (player->GetWaterLevel() >= 2)
+    {
+        // swimming, not jumping
+        SetGroundEntity(NULL);
+
+        if (player->GetWaterType() == CONTENTS_WATER)    // We move up a certain amount
+            mv->m_vecVelocity[2] = 100;
+        else if (player->GetWaterType() == CONTENTS_SLIME)
+            mv->m_vecVelocity[2] = 80;
+
+        // play swiming sound
+        if (player->m_flSwimSoundTime <= 0)
+        {
+            // Don't play sound again for 1 second
+            player->m_flSwimSoundTime = 1000;
+            PlaySwimSound();
+        }
+
+        return false;
+    }
+
+    // No more effect
+    if (player->GetGroundEntity() == NULL)
+    {
+        mv->m_nOldButtons |= IN_JUMP;
+        return false;		// in air, so no effect
+    }
+
+    //if (mv->m_nOldButtons & IN_JUMP)
+    //	return false;		// don't pogo stick
+
+    // In the air now.
+    SetGroundEntity(NULL);
+
+    player->PlayStepSound((Vector &) mv->GetAbsOrigin(), player->m_pSurfaceData, 1.0, true);
+
+    //MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
+    //player->DoAnimationEvent(PLAYERANIMEVENT_JUMP);
+
+    float flGroundFactor = 1.0f;
+    if (player->m_pSurfaceData)
+    {
+        flGroundFactor = player->m_pSurfaceData->game.jumpFactor;
+    }
+
+    // if we weren't ducking, bots and hostages do a crouchjump programatically
+    if ((!player || player->IsBot()) && !(mv->m_nButtons & IN_DUCK))
+    {
+        //player->m_duckUntilOnGround = true;
+        FinishDuck();
+    }
+
+    // Acclerate upward
+    // If we are ducking...
+    float startz = mv->m_vecVelocity[2];
+    if ((player->m_Local.m_bDucking) || (player->GetFlags() & FL_DUCKING))
+    {
+        mv->m_vecVelocity[2] = flGroundFactor * sqrt(2 * 800 * 57.0);  // 2 * gravity * height
+    }
+    else
+    {
+        mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 57.0);  // 2 * gravity * height
+    }
+
+    FinishGravity();
+
+    mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
+    mv->m_outStepHeight += 0.1f;
+
+    // Flag that we jumped.
+    mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+    return true;
+
+}
+
+void CMomentumGameMovement::CategorizePosition()
+{
+    Vector point;
+    trace_t pm;
+
+    // Reset this each time we-recategorize, otherwise we have bogus friction when we jump into water and plunge downward really quickly
+    player->m_surfaceFriction = 1.0f;
+
+    // if the player hull point one unit down is solid, the player
+    // is on ground
+
+    // see if standing on something solid	
+
+    // Doing this before we move may introduce a potential latency in water detection, but
+    // doing it after can get us stuck on the bottom in water if the amount we move up
+    // is less than the 1 pixel 'threshold' we're about to snap to.	Also, we'll call
+    // this several times per frame, so we really need to avoid sticking to the bottom of
+    // water on each call, and the converse case will correct itself if called twice.
+    CheckWater();
+
+    // observers don't have a ground entity
+    if (player->IsObserver())
+        return;
+
+    float flOffset = 2.0f;
+
+    point[0] = mv->GetAbsOrigin()[0];
+    point[1] = mv->GetAbsOrigin()[1];
+    point[2] = mv->GetAbsOrigin()[2] - flOffset;
+
+    Vector bumpOrigin;
+    bumpOrigin = mv->GetAbsOrigin();
+
+    // Shooting up really fast.  Definitely not on ground.
+    // On ladder moving up, so not on ground either
+    // NOTE: 145 is a jump.
+#define NON_JUMP_VELOCITY 140.0f
+
+    float zvel = mv->m_vecVelocity[2];
+    bool bMovingUp = zvel > 0.0f;
+    bool bMovingUpRapidly = zvel > NON_JUMP_VELOCITY;
+    float flGroundEntityVelZ = 0.0f;
+    if (bMovingUpRapidly)
+    {
+        // Tracker 73219, 75878:  ywb 8/2/07
+        // After save/restore (and maybe at other times), we can get a case where we were saved on a lift and 
+        //  after restore we'll have a high local velocity due to the lift making our abs velocity appear high.  
+        // We need to account for standing on a moving ground object in that case in order to determine if we really 
+        //  are moving away from the object we are standing on at too rapid a speed.  Note that CheckJump already sets
+        //  ground entity to NULL, so this wouldn't have any effect unless we are moving up rapidly not from the jump button.
+        CBaseEntity *ground = player->GetGroundEntity();
+        if (ground)
+        {
+            flGroundEntityVelZ = ground->GetAbsVelocity().z;
+            bMovingUpRapidly = (zvel - flGroundEntityVelZ) > NON_JUMP_VELOCITY;
+        }
+    }
+
+    // Was on ground, but now suddenly am not
+    if (bMovingUpRapidly ||
+        (bMovingUp && player->GetMoveType() == MOVETYPE_LADDER))
+    {
+        SetGroundEntity(NULL);
+    }
+    else
+    {
+        // Try and move down.
+        TryTouchGround(bumpOrigin, point, GetPlayerMins(), GetPlayerMaxs(), MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm);
+
+        // Was on ground, but now suddenly am not.  If we hit a steep plane, we are not on ground
+        if (!pm.m_pEnt || pm.plane.normal[2] < 0.7)
+        {
+            // Test four sub-boxes, to see if any of them would have found shallower slope we could actually stand on
+            TryTouchGroundInQuadrants(bumpOrigin, point, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm);
+
+            if (!pm.m_pEnt || pm.plane.normal[2] < 0.7)
+            {
+                SetGroundEntity(NULL);
+                // probably want to add a check for a +z velocity too!
+                if ((mv->m_vecVelocity.z > 0.0f) &&
+                    (player->GetMoveType() != MOVETYPE_NOCLIP))
+                {
+                    player->m_surfaceFriction = 0.25f;
+                }
+            }
+            else
+            {
+                if (m_flReflectNormal == NO_REFL_NORMAL_CHANGE)
+                {
+                    DoLateReflect();
+                    CategorizePosition();
+
+                    return;
+                }
+
+                SetGroundEntity(&pm);
+            }
+        }
+        else
+        {
+            if (m_flReflectNormal == NO_REFL_NORMAL_CHANGE)
+            {
+                DoLateReflect();
+                CategorizePosition();
+
+                return;
+            }
+
+            SetGroundEntity(&pm);  // Otherwise, point to index of ent under us.
+        }
+
+#ifndef CLIENT_DLL
+
+        // If our gamematerial has changed, tell any player surface triggers that are watching
+        IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
+        surfacedata_t *pSurfaceProp = physprops->GetSurfaceData(pm.surface.surfaceProps);
+        char cCurrGameMaterial = pSurfaceProp->game.material;
+        if (!player->GetGroundEntity())
+        {
+            cCurrGameMaterial = 0;
+        }
+
+        // Changed?
+        if (player->m_chPreviousTextureType != cCurrGameMaterial)
+        {
+            CEnvPlayerSurfaceTrigger::SetPlayerSurface(player, cCurrGameMaterial);
+        }
+
+        player->m_chPreviousTextureType = cCurrGameMaterial;
+#endif
+    }
+}
+
+void CMomentumGameMovement::FullWalkMove()
+{
+    if (!CheckWater())
+    {
+        StartGravity();
+    }
+
+    // If we are leaping out of the water, just update the counters.
+    if (player->m_flWaterJumpTime)
+    {
+        WaterJump();
+        TryPlayerMove();
+        // See if we are still in water?
+        CheckWater();
+        return;
+    }
+
+    // If we are swimming in the water, see if we are nudging against a place we can jump up out
+    //  of, and, if so, start out jump.  Otherwise, if we are not moving up, then reset jump timer to 0
+    if (player->GetWaterLevel() >= WL_Waist)
+    {
+        if (player->GetWaterLevel() == WL_Waist)
+        {
+            CheckWaterJump();
+        }
+
+        // If we are falling again, then we must not trying to jump out of water any more.
+        if (mv->m_vecVelocity[2] < 0 &&
+            player->m_flWaterJumpTime)
+        {
+            player->m_flWaterJumpTime = 0;
+        }
+
+        // Was jump button pressed?
+        if (mv->m_nButtons & IN_JUMP)
+        {
+            CheckJumpButton();
+        }
+        else
+        {
+            mv->m_nOldButtons &= ~IN_JUMP;
+        }
+
+        // Perform regular water movement
+        WaterMove();
+
+        // Redetermine position vars
+        CategorizePosition();
+
+        // If we are on ground, no downward velocity.
+        if (player->GetGroundEntity() != NULL)
+        {
+            mv->m_vecVelocity[2] = 0;
+        }
+    }
+    else
+        // Not fully underwater
+    {
+        // Was jump button pressed?
+        if (mv->m_nButtons & IN_JUMP)
+        {
+            CheckJumpButton();
+        }
+        else
+        {
+            mv->m_nOldButtons &= ~IN_JUMP;
+        }
+
+        // Fricion is handled before we add in any base velocity. That way, if we are on a conveyor, 
+        //  we don't slow when standing still, relative to the conveyor.
+        if (player->GetGroundEntity() != NULL)
+        {
+            mv->m_vecVelocity[2] = 0.0;
+            Friction();
+        }
+
+        // Make sure velocity is valid.
+        CheckVelocity();
+
+        // By default assume we did the reflect for WalkMove()
+        m_flReflectNormal = 1.0f;
+
+        if (player->GetGroundEntity() != NULL)
+        {
+            WalkMove();
+        }
+        else
+        {
+            AirMove();  // Take into account movement when in air.
+        }
+
+        // Set final flags.
+        CategorizePosition();
+
+        // Make sure velocity is valid.
+        CheckVelocity();
+
+        // Add any remaining gravitational component.
+        if (!CheckWater())
+        {
+            FinishGravity();
+        }
+
+        // If we are on ground, no downward velocity.
+        if (player->GetGroundEntity() != NULL)
+        {
+            mv->m_vecVelocity[2] = 0;
+        }
+        CheckFalling();
+    }
+
+    if ((m_nOldWaterLevel == WL_NotInWater && player->GetWaterLevel() != WL_NotInWater) ||
+        (m_nOldWaterLevel != WL_NotInWater && player->GetWaterLevel() == WL_NotInWater))
+    {
+        PlaySwimSound();
+#if !defined( CLIENT_DLL )
+        player->Splash();
+#endif
+    }
+}
+
+
+void CMomentumGameMovement::AirMove(void)
+{
+    int			i;
+    Vector		wishvel;
+    float		fmove, smove;
+    Vector		wishdir;
+    float		wishspeed;
+    Vector forward, right, up;
+
+    AngleVectors(mv->m_vecViewAngles, &forward, &right, &up);  // Determine movement angles
+
+    // Copy movement amounts
+    fmove = mv->m_flForwardMove;
+    smove = mv->m_flSideMove;
+
+    // Zero out z components of movement vectors
+    forward[2] = 0;
+    right[2] = 0;
+    VectorNormalize(forward);  // Normalize remainder of vectors
+    VectorNormalize(right);    // 
+
+    for (i = 0; i<2; i++)       // Determine x and y parts of velocity
+        wishvel[i] = forward[i] * fmove + right[i] * smove;
+    wishvel[2] = 0;             // Zero out z part of velocity
+
+    VectorCopy(wishvel, wishdir);   // Determine maginitude of speed of move
+    wishspeed = VectorNormalize(wishdir);
+
+    //
+    // clamp to server defined max speed
+    //
+    if (wishspeed != 0 && (wishspeed > mv->m_flMaxSpeed))
+    {
+        VectorScale(wishvel, mv->m_flMaxSpeed / wishspeed, wishvel);
+        wishspeed = mv->m_flMaxSpeed;
+    }
+
+    AirAccelerate(wishdir, wishspeed, sv_airaccelerate.GetFloat());
+
+    // Add in any base velocity to the current velocity.
+    VectorAdd(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+    m_flReflectNormal = NO_REFL_NORMAL_CHANGE;
+    TryPlayerMove(NULL, NULL);
+
+    // Now pull the base velocity back out.   Base velocity is set if you are on a moving object, like a conveyor (or maybe another monster?)
+    VectorSubtract(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+    CheckForLadders(false);
+    //return bDidReflect;
+}
+
+void CMomentumGameMovement::DoLateReflect(void)
+{
+    // Don't attempt to reflect after this.
+    // Return below was causing recursion.
+    m_flReflectNormal = 1.0f;
+
+
+    if (mv->m_vecVelocity.Length() == 0.0f || player->GetGroundEntity() != NULL)
+        return;
+
+
+    Vector prevpos = mv->m_vecAbsOrigin;
+    Vector prevvel = mv->m_vecVelocity;
+
+
+    VectorAdd(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+    // Since we're doing two moves in one frame, only apply changes if we did the reflect and we gained speed.
+    TryPlayerMove();
+    if (m_flReflectNormal == 1.0f || prevvel.Length2DSqr() > mv->m_vecVelocity.Length2DSqr())
+    {
+        VectorCopy(prevpos, mv->m_vecAbsOrigin);
+        VectorCopy(prevvel, mv->m_vecVelocity);
+    }
+    else
+    {
+        VectorSubtract(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+        DevMsg("Successful late reflect! Normal: %.2f\n", m_flReflectNormal);
+    }
+}
+
+int CMomentumGameMovement::TryPlayerMove(Vector *pFirstDest, trace_t *pFirstTrace)
+{
+    int			bumpcount, numbumps;
+    Vector		dir;
+    float		d;
+    int			numplanes;
+    Vector		planes[MAX_CLIP_PLANES];
+    Vector		primal_velocity, original_velocity;
+    Vector      new_velocity;
+    int			i, j;
+    trace_t	pm;
+    Vector		end;
+    float		time_left, allFraction;
+    int			blocked;
+
+    numbumps = 4;           // Bump up to four times
+
+    blocked = 0;           // Assume not blocked
+    numplanes = 0;           //  and not sliding along any planes
+
+    VectorCopy(mv->m_vecVelocity, original_velocity);  // Store original velocity
+    VectorCopy(mv->m_vecVelocity, primal_velocity);
+
+    allFraction = 0;
+    time_left = gpGlobals->frametime;   // Total time for this movement operation.
+
+    new_velocity.Init();
+
+    for (bumpcount = 0; bumpcount < numbumps; bumpcount++)
+    {
+        if (mv->m_vecVelocity.Length() == 0.0)
+            break;
+
+        // Assume we can move all the way from the current origin to the
+        //  end point.
+        VectorMA(mv->GetAbsOrigin(), time_left, mv->m_vecVelocity, end);
+
+        // See if we can make it from origin to end point.
+        if (g_bMovementOptimizations)
+        {
+            // If their velocity Z is 0, then we can avoid an extra trace here during WalkMove.
+            if (pFirstDest && end == *pFirstDest)
+                pm = *pFirstTrace;
+            else
+            {
+#if defined( PLAYER_GETTING_STUCK_TESTING )
+                trace_t foo;
+                TracePlayerBBox(mv->GetAbsOrigin(), mv->GetAbsOrigin(), PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, foo);
+                if (foo.startsolid || foo.fraction != 1.0f)
+                {
+                    Msg("bah\n");
+                }
+#endif
+                TracePlayerBBox(mv->GetAbsOrigin(), end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm);
+            }
+        }
+        else
+        {
+            TracePlayerBBox(mv->GetAbsOrigin(), end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm);
+        }
+
+        allFraction += pm.fraction;
+
+        // If we started in a solid object, or we were in solid space
+        //  the whole way, zero out our velocity and return that we
+        //  are blocked by floor and wall.
+        if (pm.allsolid)
+        {
+            // entity is trapped in another solid
+            VectorCopy(vec3_origin, mv->m_vecVelocity);
+            return 4;
+        }
+
+        // If we moved some portion of the total distance, then
+        //  copy the end position into the pmove.origin and 
+        //  zero the plane counter.
+        if (pm.fraction > 0)
+        {
+            if (numbumps > 0 && pm.fraction == 1)
+            {
+                // There's a precision issue with terrain tracing that can cause a swept box to successfully trace
+                // when the end position is stuck in the triangle.  Re-run the test with an uswept box to catch that
+                // case until the bug is fixed.
+                // If we detect getting stuck, don't allow the movement
+                trace_t stuck;
+                TracePlayerBBox(pm.endpos, pm.endpos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, stuck);
+                if (stuck.startsolid || stuck.fraction != 1.0f)
+                {
+                    Msg("Player will become stuck!!!\n");
+                    VectorCopy(vec3_origin, mv->m_vecVelocity);
+                    break;
+                }
+            }
+
+#if defined( PLAYER_GETTING_STUCK_TESTING )
+            trace_t foo;
+            TracePlayerBBox(pm.endpos, pm.endpos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, foo);
+            if (foo.startsolid || foo.fraction != 1.0f)
+            {
+                Msg("Player will become stuck!!!\n");
+            }
+#endif
+            // actually covered some distance
+            mv->SetAbsOrigin(pm.endpos);
+            VectorCopy(mv->m_vecVelocity, original_velocity);
+            numplanes = 0;
+        }
+
+        // If we covered the entire distance, we are done
+        //  and can return.
+        if (pm.fraction == 1)
+        {
+            break;		// moved the entire distance
+        }
+
+        // Save entity that blocked us (since fraction was < 1.0)
+        //  for contact
+        // Add it if it's not already in the list!!!
+        MoveHelper()->AddToTouched(pm, mv->m_vecVelocity);
+
+        // If the plane we hit has a high z component in the normal, then
+        //  it's probably a floor
+        if (pm.plane.normal[2] > 0.7)
+        {
+            blocked |= 1;		// floor
+        }
+        // If the plane has a zero z component in the normal, then it's a 
+        //  step or wall
+        if (!pm.plane.normal[2])
+        {
+            blocked |= 2;		// step / wall
+        }
+
+        // Reduce amount of m_flFrameTime left by total time left * fraction
+        //  that we covered.
+        time_left -= time_left * pm.fraction;
+
+        // Did we run out of planes to clip against?
+        if (numplanes >= MAX_CLIP_PLANES)
+        {
+            // this shouldn't really happen
+            //  Stop our movement if so.
+            VectorCopy(vec3_origin, mv->m_vecVelocity);
+            //Con_DPrintf("Too many planes 4\n");
+
+            break;
+        }
+
+        // Set up next clipping plane
+        VectorCopy(pm.plane.normal, planes[numplanes]);
+        numplanes++;
+
+        // modify original_velocity so it parallels all of the clip planes
+        //
+
+        // reflect player velocity 
+        // Only give this a try for first impact plane because you can get yourself stuck in an acute corner by jumping in place
+        //  and pressing forward and nobody was really using this bounce/reflection feature anyway...
+        if (numplanes == 1 &&
+            player->GetMoveType() == MOVETYPE_WALK &&
+            player->GetGroundEntity() == NULL)
+        {
+            //Vector cross = mv->m_vecVelocity.Cross(planes[0]);
+
+            //if (cross[1] > 0)//Are we going up a slope?
+            //    flReflectNormal = 1.0f;//Don't bother trying to do a LateReflect
+            //else
+            m_flReflectNormal = planes[0][2];//Determine in CategorizePosition
+            
+
+            for (i = 0; i < numplanes; i++)
+            {
+                if (planes[i][2] > 0.7)
+                {
+                    // floor or slope
+                    ClipVelocity(original_velocity, planes[i], new_velocity, 1);
+                    VectorCopy(new_velocity, original_velocity);
+                }
+                else
+                {
+                    ClipVelocity(original_velocity, planes[i], new_velocity, 1.0 + sv_bounce.GetFloat() * (1 - player->m_surfaceFriction));
+                }
+            }
+
+            VectorCopy(new_velocity, mv->m_vecVelocity);
+            VectorCopy(new_velocity, original_velocity);
+        }
+        else
+        {
+            for (i = 0; i < numplanes; i++)
+            {
+                ClipVelocity(
+                    original_velocity,
+                    planes[i],
+                    mv->m_vecVelocity,
+                    1);
+
+                for (j = 0; j < numplanes; j++)
+                    if (j != i)
+                    {
+                        // Are we now moving against this plane?
+                        if (mv->m_vecVelocity.Dot(planes[j]) < 0)
+                            break;	// not ok
+                    }
+                if (j == numplanes)  // Didn't have to clip, so we're ok
+                    break;
+            }
+
+            // Did we go all the way through plane set
+            if (i != numplanes)
+            {	// go along this plane
+                // pmove.velocity is set in clipping call, no need to set again.
+                ;
+            }
+            else
+            {	// go along the crease
+                if (numplanes != 2)
+                {
+                    VectorCopy(vec3_origin, mv->m_vecVelocity);
+                    break;
+                }
+                CrossProduct(planes[0], planes[1], dir);
+                dir.NormalizeInPlace();
+                d = dir.Dot(mv->m_vecVelocity);
+                VectorScale(dir, d, mv->m_vecVelocity);
+            }
+
+            //
+            // if original velocity is against the original velocity, stop dead
+            // to avoid tiny occilations in sloping corners
+            //
+            d = mv->m_vecVelocity.Dot(primal_velocity);
+            if (d <= 0)
+            {
+                //Con_DPrintf("Back\n");
+                if (!sv_ramp_fix.GetBool())
+                    VectorCopy(vec3_origin, mv->m_vecVelocity); // RAMPBUG FIX #2
+                break;
+            }
+        }
+    }
+
+    if (allFraction == 0)
+    {
+        if (!sv_ramp_fix.GetBool())
+            VectorCopy(vec3_origin, mv->m_vecVelocity); // RAMPBUG FIX #1
+    }
+
+    // Check if they slammed into a wall
+    float fSlamVol = 0.0f;
+
+    float fLateralStoppingAmount = primal_velocity.Length2D() - mv->m_vecVelocity.Length2D();
+    if (fLateralStoppingAmount > PLAYER_MAX_SAFE_FALL_SPEED * 2.0f)
+    {
+        fSlamVol = 1.0f;
+    }
+    else if (fLateralStoppingAmount > PLAYER_MAX_SAFE_FALL_SPEED)
+    {
+        fSlamVol = 0.85f;
+    }
+
+    PlayerRoughLandingEffects(fSlamVol);
+
+    return blocked;
+}
+
+
+// This was the virtual void, overriding it for snow friction
+void CMomentumGameMovement::SetGroundEntity(trace_t *pm)
+{
+    //CMomentumPlayer *player = GetMomentumPlayer();
+
+    CBaseEntity *newGround = pm ? pm->m_pEnt : NULL;
+
+    CBaseEntity *oldGround = player->GetGroundEntity();
+    Vector vecBaseVelocity = player->GetBaseVelocity();
+
+    if (!oldGround && newGround)
+    {
+        // Subtract ground velocity at instant we hit ground jumping
+        vecBaseVelocity -= newGround->GetAbsVelocity();
+        vecBaseVelocity.z = newGround->GetAbsVelocity().z;
+    }
+    else if (oldGround && !newGround)
+    {
+        // Add in ground velocity at instant we started jumping
+        vecBaseVelocity += oldGround->GetAbsVelocity();
+        vecBaseVelocity.z = oldGround->GetAbsVelocity().z;
+    }
+
+    player->SetBaseVelocity(vecBaseVelocity);
+    player->SetGroundEntity(newGround);
+
+    // If we are on something...
+
+    if (newGround)
+    {
+        CategorizeGroundSurface(*pm);//Snow friction override
+
+        // Then we are not in water jump sequence
+        player->m_flWaterJumpTime = 0;
+
+        // Standing on an entity other than the world, so signal that we are touching something.
+        if (!pm->DidHitWorld())
+        {
+            MoveHelper()->AddToTouched(*pm, mv->m_vecVelocity);
+        }
+
+        mv->m_vecVelocity.z = 0.0f;
+    }
+}
+
+void CMomentumGameMovement::CategorizeGroundSurface(trace_t &pm)
+{
+    IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
+    //CMomentumPlayer *player = GetMomentumPlayer();
+
+    player->m_surfaceProps = pm.surface.surfaceProps;
+    player->m_pSurfaceData = physprops->GetSurfaceData(player->m_surfaceProps);
+    physprops->GetPhysicsProperties(player->m_surfaceProps, NULL, NULL, &player->m_surfaceFriction, NULL);
+
+    // HACKHACK: Scale this to fudge the relationship between vphysics friction values and player friction values.
+    // A value of 0.8f feels pretty normal for vphysics, whereas 1.0f is normal for players.
+    // This scaling trivially makes them equivalent.  REVISIT if this affects low friction surfaces too much.
+    player->m_surfaceFriction *= 1.25f;
+    if (player->m_surfaceFriction > 1.0f || (player->m_pSurfaceData->game.material == 'D'
+        && player->m_pSurfaceData->physics.friction == 0.35f))
+        player->m_surfaceFriction = 1.0f;//fix for snow friction
+
+    player->m_chTextureType = player->m_pSurfaceData->game.material;
+}
+
+// Expose our interface.
+static CMomentumGameMovement g_GameMovement;
+IGameMovement *g_pGameMovement = (IGameMovement *) &g_GameMovement;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CGameMovement, IGameMovement, INTERFACENAME_GAMEMOVEMENT, g_GameMovement);
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_gamemovement.h b/mp/src/game/shared/momentum/mom_gamemovement.h
new file mode 100644
index 000000000..6f2b33623
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_gamemovement.h
@@ -0,0 +1,84 @@
+
+#include "gamemovement.h"
+#include "func_ladder.h"
+#include "mom_player_shared.h"
+#include "baseplayer_shared.h"
+
+
+struct surface_data_t;
+
+class CMomentumPlayer;
+
+#define NO_REFL_NORMAL_CHANGE -2.0f
+
+class CMomentumGameMovement : public CGameMovement
+{
+    typedef CGameMovement BaseClass;
+public:
+
+    CMomentumGameMovement();
+
+    // Overrides
+    virtual bool LadderMove(void); // REPLACED
+    virtual bool OnLadder(trace_t &trace); // REPLACED
+    virtual void SetGroundEntity(trace_t *pm);
+    virtual bool CanAccelerate(void) { BaseClass::CanAccelerate(); return true; }//C+P from HL2GM
+    virtual bool CheckJumpButton(void);
+    virtual void PlayerMove(void);
+    virtual void AirMove(void);//Overridden for rampboost fix
+    virtual void WalkMove(void);
+    virtual void CheckForLadders(bool);
+
+    virtual void CategorizeGroundSurface(trace_t&);
+
+
+    //added ladder
+    virtual float LadderDistance(void) const
+    {
+        if (player->GetMoveType() == MOVETYPE_LADDER)
+            return 10.0f;
+        return 2.0f;
+    }
+
+    virtual unsigned int LadderMask(void) const
+    {
+        return MASK_PLAYERSOLID & (~CONTENTS_PLAYERCLIP);
+    }
+
+    virtual float ClimbSpeed(void) const;
+    virtual float LadderLateralMultiplier(void) const;
+    const float DuckSpeedMultiplier = 0.34f;
+
+    //Overrides for fixing rampboost
+    virtual int TryPlayerMove(Vector *pFirstDest = NULL, trace_t *pFirstTrace = NULL);
+    virtual void FullWalkMove();
+    void DoLateReflect();
+    void CategorizePosition();
+
+
+    // Duck
+    virtual void Duck(void);
+    virtual void FinishUnDuck(void);
+    virtual void FinishDuck(void);
+    virtual bool CanUnduck();
+    virtual void HandleDuckingSpeedCrop();
+    virtual void CheckParameters(void) { BaseClass::CheckParameters(); }
+
+private:
+
+    float m_flReflectNormal = NO_REFL_NORMAL_CHANGE;//Used by rampboost fix
+
+    // Given a list of nearby ladders, find the best ladder and the "mount" origin
+    void		Findladder(float maxdist, CFuncLadder **ppLadder, Vector& ladderOrigin, const CFuncLadder *skipLadder);
+
+    // Debounce the +USE key
+    void		SwallowUseKey();
+    CMomentumPlayer *GetMomentumPlayer();
+};
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+inline CMomentumPlayer	*CMomentumGameMovement::GetMomentumPlayer()
+{
+    return static_cast<CMomentumPlayer *>(player);
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_gamerules.cpp b/mp/src/game/shared/momentum/mom_gamerules.cpp
new file mode 100644
index 000000000..26e7a540d
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_gamerules.cpp
@@ -0,0 +1,294 @@
+#include "cbase.h"
+#include "mom_gamerules.h"
+#include "cs_ammodef.h"
+#include "weapon_csbase.h"
+#include "voice_gamemgr.h"
+#include "mom_shareddefs.h"
+
+#include "tier0/memdbgon.h"
+
+REGISTER_GAMERULES_CLASS(CMomentum);
+
+
+
+// shared ammo definition
+// JAY: Trying to make a more physical bullet response
+#define BULLET_MASS_GRAINS_TO_LB(grains)	(0.002285*(grains)/16.0f)
+#define BULLET_MASS_GRAINS_TO_KG(grains)	lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))
+
+// exaggerate all of the forces, but use real numbers to keep them consistent
+#define BULLET_IMPULSE_EXAGGERATION			1	
+
+// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
+#define BULLET_IMPULSE(grains, ftpersec)	((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)
+
+static CAmmoDef ammoDef;
+
+CAmmoDef* GetAmmoDef()
+{
+    static bool bInitted = false;
+
+    if (!bInitted)
+    {
+        bInitted = true;
+
+        ammoDef.AddAmmoType(BULLET_PLAYER_50AE, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_50AE_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14);
+        ammoDef.AddAmmoType(BULLET_PLAYER_762MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_762mm_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14);
+        ammoDef.AddAmmoType(BULLET_PLAYER_556MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14);
+        ammoDef.AddAmmoType(BULLET_PLAYER_556MM_BOX, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_box_max", 2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14);
+        ammoDef.AddAmmoType(BULLET_PLAYER_338MAG, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_338mag_max", 2800 * BULLET_IMPULSE_EXAGGERATION, 0, 12, 16);
+        ammoDef.AddAmmoType(BULLET_PLAYER_9MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_9mm_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 5, 10);
+        ammoDef.AddAmmoType(BULLET_PLAYER_BUCKSHOT, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_buckshot_max", 600 * BULLET_IMPULSE_EXAGGERATION, 0, 3, 6);
+        ammoDef.AddAmmoType(BULLET_PLAYER_45ACP, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_45acp_max", 2100 * BULLET_IMPULSE_EXAGGERATION, 0, 6, 10);
+        ammoDef.AddAmmoType(BULLET_PLAYER_357SIG, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_357sig_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8);
+        ammoDef.AddAmmoType(BULLET_PLAYER_57MM, DMG_BULLET, TRACER_LINE, 0, 0, "ammo_57mm_max", 2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8);
+        ammoDef.AddAmmoType(AMMO_TYPE_HEGRENADE, DMG_BLAST, TRACER_LINE, 0, 0, 1/*max carry*/, 1, 0);
+        ammoDef.AddAmmoType(AMMO_TYPE_FLASHBANG, 0, TRACER_LINE, 0, 0, 2/*max carry*/, 1, 0);
+        ammoDef.AddAmmoType(AMMO_TYPE_SMOKEGRENADE, 0, TRACER_LINE, 0, 0, 1/*max carry*/, 1, 0);
+    }
+
+    return &ammoDef;
+}
+
+/*
+ConVar ammo_50AE_max( "ammo_50AE_max", "35", FCVAR_REPLICATED );
+ConVar ammo_762mm_max( "ammo_762mm_max", "90", FCVAR_REPLICATED );
+ConVar ammo_556mm_max( "ammo_556mm_max", "90", FCVAR_REPLICATED );
+ConVar ammo_556mm_box_max( "ammo_556mm_box_max", "200", FCVAR_REPLICATED );
+ConVar ammo_338mag_max( "ammo_338mag_max", "30", FCVAR_REPLICATED );
+ConVar ammo_9mm_max( "ammo_9mm_max", "120", FCVAR_REPLICATED );
+ConVar ammo_buckshot_max( "ammo_buckshot_max", "32", FCVAR_REPLICATED );
+ConVar ammo_45acp_max( "ammo_45acp_max", "100", FCVAR_REPLICATED );
+ConVar ammo_357sig_max( "ammo_357sig_max", "52", FCVAR_REPLICATED );
+ConVar ammo_57mm_max( "ammo_57mm_max", "100", FCVAR_REPLICATED );
+ConVar ammo_hegrenade_max( "ammo_hegrenade_max", "1", FCVAR_REPLICATED );
+ConVar ammo_flashbang_max( "ammo_flashbang_max", "2", FCVAR_REPLICATED );
+ConVar ammo_smokegrenade_max( "ammo_smokegrenade_max", "1", FCVAR_REPLICATED );
+*/
+
+ConVar ammo_50AE_max("ammo_50AE_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_762mm_max("ammo_762mm_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_556mm_max("ammo_556mm_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_556mm_box_max("ammo_556mm_box_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_338mag_max("ammo_338mag_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_9mm_max("ammo_9mm_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_buckshot_max("ammo_buckshot_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_45acp_max("ammo_45acp_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_357sig_max("ammo_357sig_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_57mm_max("ammo_57mm_max", "-2", FCVAR_REPLICATED);
+ConVar ammo_hegrenade_max("ammo_hegrenade_max", "1", FCVAR_REPLICATED);
+ConVar ammo_flashbang_max("ammo_flashbang_max", "2", FCVAR_REPLICATED);
+ConVar ammo_smokegrenade_max("ammo_smokegrenade_max", "1", FCVAR_REPLICATED);
+
+CMomentum::CMomentum()
+{
+    //m_iGameMode = 0;
+}
+
+CMomentum::~CMomentum()
+{
+}
+
+#ifndef CLIENT_DLL
+LINK_ENTITY_TO_CLASS(info_player_terrorist, CPointEntity);
+LINK_ENTITY_TO_CLASS(info_player_counterterrorist, CPointEntity);
+LINK_ENTITY_TO_CLASS(info_player_logo, CPointEntity);
+
+
+
+Vector CMomentum::DropToGround(
+    CBaseEntity *pMainEnt,
+    const Vector &vPos,
+    const Vector &vMins,
+    const Vector &vMaxs)
+{
+    trace_t trace;
+    UTIL_TraceHull(vPos, vPos + Vector(0, 0, -500), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace);
+    return trace.endpos;
+}
+
+CBaseEntity *CMomentum::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
+{
+    // gat valid spwan point
+    if (pPlayer)
+    {
+        CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();
+        if (pSpawnSpot)
+        {
+            // drop down to ground
+            Vector GroundPos = DropToGround(pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX);
+
+            // Move the player to the place it said.
+            pPlayer->Teleport(&pSpawnSpot->GetAbsOrigin(), &pSpawnSpot->GetLocalAngles(), &vec3_origin);
+            pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
+            return pSpawnSpot;
+        }
+    }
+    return NULL;
+}
+
+// checks if the spot is clear of players
+bool CMomentum::IsSpawnPointValid(CBaseEntity *pSpot, CBasePlayer *pPlayer)
+{
+    if (!pSpot->IsTriggered(pPlayer))
+    {
+        return false;
+    }
+
+    Vector mins = GetViewVectors()->m_vHullMin;
+    Vector maxs = GetViewVectors()->m_vHullMax;
+
+    Vector vTestMins = pSpot->GetAbsOrigin() + mins;
+    Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
+
+    // First test the starting origin.
+    return UTIL_IsSpaceEmpty(pPlayer, vTestMins, vTestMaxs);
+}
+
+bool CMomentum::ClientCommand(CBaseEntity *pEdict, const CCommand &args)
+{
+    if (BaseClass::ClientCommand(pEdict, args))
+        return true;
+
+    CMomentumPlayer *pPlayer = (CMomentumPlayer *) pEdict;
+
+    return pPlayer->ClientCommand(args);
+}
+
+static void OnGamemodeChanged(IConVar *var, const char* pOldValue, float fOldValue)
+{
+    int toCheck = ((ConVar*) var)->GetInt();
+    if (toCheck == fOldValue) return;
+    if (toCheck < 0)
+    {
+        // This will never happen. but better be safe than sorry, right?
+        Warning("Cannot set a game mode under 0!\n");
+        var->SetValue(((ConVar*) var)->GetDefault());
+        return;
+    }
+    bool result = TickSet::SetTickrate(toCheck);
+    if (result)
+    {
+        Msg("Successfully changed the tickrate to %f!\n", TickSet::GetTickrate());
+        gpGlobals->interval_per_tick = TickSet::GetTickrate();
+    }
+    else Warning("Failed to change interval per tick, cannot set tick rate!\n");
+}
+
+static ConVar gamemode("mom_gamemode", "0", FCVAR_REPLICATED | FCVAR_NOT_CONNECTED | FCVAR_HIDDEN, "", true, 0, false, 0,OnGamemodeChanged);
+
+static ConVar allow_custom("mom_allow_custom_maps", "0", FCVAR_ARCHIVE | FCVAR_REPLICATED, "Allow loading custom maps that aren't of an official gametype.", true ,0, true ,1);
+
+static ConVar give_weapon("mom_spawn_with_weapon", "1", FCVAR_NONE, "Spawn the player with a weapon?", true, 0, true, 1);
+
+void CMomentum::PlayerSpawn(CBasePlayer* pPlayer)
+{
+    if (gamemode.GetInt() == 0 && !allow_custom.GetBool())
+    {
+        engine->ServerCommand("disconnect\n"); 
+        Warning("\n\nBeware, beware!\nYou have been disconnected from the map because custom maps are not allowed if %s is 0.\nPlease set it to 1 in order to play custom maps.\n\n", allow_custom.GetName());
+    }
+
+    ConVarRef map("host_map");
+    const char *pMapName = map.GetString();
+
+    if (gpGlobals->eLoadType == MapLoad_Background || !Q_strcmp(pMapName, "credits.bsp"))
+    {
+        //Hide timer/speedometer on background maps
+        pPlayer->m_Local.m_iHideHUD |= HIDEHUD_WEAPONSELECTION;
+    }
+    else
+    {
+        // Turn them back on
+        pPlayer->m_Local.m_iHideHUD &= ~HIDEHUD_WEAPONSELECTION;
+    }
+
+    
+    //MOM_TODO: could this change to gamemode != ALLOWED ?
+    if (give_weapon.GetBool() && !Q_strcmp(pMapName, "credits.bsp") && !(Q_strnicmp(pMapName, "background", Q_strlen("background"))))
+        pPlayer->Weapon_Create("weapon_momentum_gun");
+    //MOM_TODO: keep track of holstering (convar?)
+}
+
+
+class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+{
+public:
+    virtual bool		CanPlayerHearPlayer(CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity)
+    {
+        return true;
+    }
+};
+CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: MULTIPLAYER BODY QUE HANDLING
+//-----------------------------------------------------------------------------
+class CCorpse : public CBaseAnimating
+{
+public:
+    DECLARE_CLASS(CCorpse, CBaseAnimating);
+    DECLARE_SERVERCLASS();
+
+    virtual int ObjectCaps(void) { return FCAP_DONT_SAVE; }
+
+public:
+    CNetworkVar(int, m_nReferencePlayer);
+};
+
+IMPLEMENT_SERVERCLASS_ST(CCorpse, DT_Corpse)
+SendPropInt(SENDINFO(m_nReferencePlayer), 10, SPROP_UNSIGNED)
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS(bodyque, CCorpse);
+
+
+CCorpse		*g_pBodyQueueHead;
+
+void InitBodyQue(void)
+{
+    CCorpse *pEntity = (CCorpse *) CreateEntityByName("bodyque");
+    pEntity->AddEFlags(EFL_KEEP_ON_RECREATE_ENTITIES);
+    g_pBodyQueueHead = pEntity;
+    CCorpse *p = g_pBodyQueueHead;
+
+    // Reserve 3 more slots for dead bodies
+    for (int i = 0; i < 3; i++)
+    {
+        CCorpse *next = (CCorpse *) CreateEntityByName("bodyque");
+        next->AddEFlags(EFL_KEEP_ON_RECREATE_ENTITIES);
+        p->SetOwnerEntity(next);
+        p = next;
+    }
+
+    p->SetOwnerEntity(g_pBodyQueueHead);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: make a body que entry for the given ent so the ent can be respawned elsewhere
+// GLOBALS ASSUMED SET:  g_eoBodyQueueHead
+//-----------------------------------------------------------------------------
+void CopyToBodyQue(CBaseAnimating *pCorpse)
+{
+    if (pCorpse->IsEffectActive(EF_NODRAW))
+        return;
+
+    CCorpse *pHead = g_pBodyQueueHead;
+
+    pHead->CopyAnimationDataFrom(pCorpse);
+
+    pHead->SetMoveType(MOVETYPE_FLYGRAVITY);
+    pHead->SetAbsVelocity(pCorpse->GetAbsVelocity());
+    pHead->ClearFlags();
+    pHead->m_nReferencePlayer = ENTINDEX(pCorpse);
+
+    pHead->SetLocalAngles(pCorpse->GetAbsAngles());
+    UTIL_SetOrigin(pHead, pCorpse->GetAbsOrigin());
+
+    UTIL_SetSize(pHead, pCorpse->WorldAlignMins(), pCorpse->WorldAlignMaxs());
+    g_pBodyQueueHead = (CCorpse *) pHead->GetOwnerEntity();
+}
+
+#endif
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_gamerules.h b/mp/src/game/shared/momentum/mom_gamerules.h
new file mode 100644
index 000000000..951578828
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_gamerules.h
@@ -0,0 +1,68 @@
+#ifndef MOM_GAMERULES_H
+#define MOM_GAMERULES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+#include "gamerules.h"
+#include "singleplay_gamerules.h"
+#include "mom_player_shared.h"
+
+#ifdef CLIENT_DLL
+#define CMomentum C_Momentum
+#else
+#include "momentum/tickset.h"
+#endif
+
+
+class CMomentum : public CSingleplayRules
+{
+public:
+    DECLARE_CLASS(CMomentum, CSingleplayRules);
+
+#ifdef CLIENT_DLL
+
+    DECLARE_CLIENTCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+#else
+    DECLARE_SERVERCLASS_NOBASE();
+    
+
+    //virtual void			Think(void);
+
+    virtual bool			ClientCommand(CBaseEntity *pEdict, const CCommand &args);
+    virtual void			PlayerSpawn(CBasePlayer *pPlayer);
+    virtual bool			IsSpawnPointValid(CBaseEntity *pSpot, CBasePlayer *pPlayer);
+    virtual CBaseEntity*    GetPlayerSpawnSpot(CBasePlayer *pPlayer);
+    virtual const char *GetGameDescription(void) { return "Momentum"; }
+
+    // Ammo
+    virtual void			PlayerThink(CBasePlayer *pPlayer) {}
+   // virtual float			GetAmmoDamage(CBaseEntity *pAttacker, CBaseEntity *pVictim, int nAmmoType);
+
+private:
+
+    //void AdjustPlayerDamageTaken(CTakeDamageInfo *pInfo);
+    //float AdjustPlayerDamageInflicted(float damage);
+    Vector DropToGround(
+        CBaseEntity *pMainEnt,
+        const Vector &vPos,
+        const Vector &vMins,
+        const Vector &vMaxs);
+    int DefaultFOV(void) { return 90; }
+#endif
+
+public:
+
+    CMomentum();
+    ~CMomentum();
+
+};
+
+inline CMomentum *GetMomentumGamerules()
+{
+    return static_cast<CMomentum*>(g_pGameRules);
+}
+
+#endif// MOM_GAMERULES_H
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_player_shared.cpp b/mp/src/game/shared/momentum/mom_player_shared.cpp
new file mode 100644
index 000000000..683490685
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_player_shared.cpp
@@ -0,0 +1,424 @@
+#include "cbase.h"
+#include "mom_player_shared.h"
+
+
+#include "effect_dispatch_data.h"
+#ifdef GAME_DLL
+#include "te_effect_dispatch.h"
+#else
+#include "c_te_effect_dispatch.h"
+#endif
+#include "weapon_csbase.h"
+#include "engine/ivdebugoverlay.h"
+#include "decals.h"
+
+#include "tier0/memdbgon.h"
+
+
+ConVar sv_showimpacts("sv_showimpacts", "0", FCVAR_REPLICATED, "Shows client (red) and server (blue) bullet impact point (1=both, 2=client-only, 3=server-only)");
+
+void CMomentumPlayer::GetBulletTypeParameters(
+    int iBulletType,
+    float &fPenetrationPower,
+    float &flPenetrationDistance)
+{
+
+    //MIKETODO: make ammo types come from a script file.
+    if (IsAmmoType(iBulletType, BULLET_PLAYER_50AE))
+    {
+        fPenetrationPower = 30;
+        flPenetrationDistance = 1000.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_762MM))
+    {
+        fPenetrationPower = 39;
+        flPenetrationDistance = 5000.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_556MM) ||
+        IsAmmoType(iBulletType, BULLET_PLAYER_556MM_BOX))
+    {
+        fPenetrationPower = 35;
+        flPenetrationDistance = 4000.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_338MAG))
+    {
+        fPenetrationPower = 45;
+        flPenetrationDistance = 8000.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_9MM))
+    {
+        fPenetrationPower = 21;
+        flPenetrationDistance = 800.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_BUCKSHOT))
+    {
+        fPenetrationPower = 0;
+        flPenetrationDistance = 0.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_45ACP))
+    {
+        fPenetrationPower = 15;
+        flPenetrationDistance = 500.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_357SIG))
+    {
+        fPenetrationPower = 25;
+        flPenetrationDistance = 800.0;
+    }
+    else if (IsAmmoType(iBulletType, BULLET_PLAYER_57MM))
+    {
+        fPenetrationPower = 30;
+        flPenetrationDistance = 2000.0;
+    }
+    else
+    {
+        // What kind of ammo is this?
+        Assert(false);
+        fPenetrationPower = 0;
+        flPenetrationDistance = 0.0;
+    }
+}
+
+static bool TraceToExit(Vector &start, Vector &dir, Vector &end, float flStepSize, float flMaxDistance)
+{
+    float flDistance = 0;
+    Vector last = start;
+
+    while (flDistance <= flMaxDistance)
+    {
+        flDistance += flStepSize;
+
+        end = start + flDistance *dir;
+
+        if ((UTIL_PointContents(end) & MASK_SOLID) == 0)
+        {
+            // found first free point
+            return true;
+        }
+    }
+
+    return false;
+}
+
+inline void UTIL_TraceLineIgnoreTwoEntities(const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask,
+    const IHandleEntity *ignore, const IHandleEntity *ignore2, int collisionGroup, trace_t *ptr)
+{
+    Ray_t ray;
+    ray.Init(vecAbsStart, vecAbsEnd);
+    CTraceFilterSkipTwoEntities traceFilter(ignore, ignore2, collisionGroup);
+    enginetrace->TraceRay(ray, mask, &traceFilter, ptr);
+    if (r_visualizetraces.GetBool())
+    {
+        DebugDrawLine(ptr->startpos, ptr->endpos, 255, 0, 0, true, -1.0f);
+    }
+}
+
+
+void CMomentumPlayer::FireBullet(
+    Vector vecSrc,	// shooting postion
+    const QAngle &shootAngles,  //shooting angle
+    float vecSpread, // spread vector
+    float flDistance, // max distance 
+    int iPenetration, // how many obstacles can be penetrated
+    int iBulletType, // ammo type
+    int iDamage, // base damage
+    float flRangeModifier, // damage range modifier
+    CBaseEntity *pevAttacker, // shooter
+    bool bDoEffects,
+    float x,
+    float y
+    )
+{
+    float fCurrentDamage = iDamage;   // damage of the bullet at it's current trajectory
+    float flCurrentDistance = 0.0;  //distance that the bullet has traveled so far
+
+    Vector vecDirShooting, vecRight, vecUp;
+    AngleVectors(shootAngles, &vecDirShooting, &vecRight, &vecUp);
+
+    // MIKETODO: put all the ammo parameters into a script file and allow for CS-specific params.
+    float flPenetrationPower = 0;		// thickness of a wall that this bullet can penetrate
+    float flPenetrationDistance = 0;	// distance at which the bullet is capable of penetrating a wall
+    float flDamageModifier = 0.5;		// default modification of bullets power after they go through a wall.
+    float flPenetrationModifier = 1.f;
+
+    GetBulletTypeParameters(iBulletType, flPenetrationPower, flPenetrationDistance);
+
+
+    if (!pevAttacker)
+        pevAttacker = this;  // the default attacker is ourselves
+
+    // add the spray 
+    Vector vecDir = vecDirShooting +
+        x * vecSpread * vecRight +
+        y * vecSpread * vecUp;
+
+    VectorNormalize(vecDir);
+
+    bool bFirstHit = true;
+
+    CBasePlayer *lastPlayerHit = NULL;
+
+    //MDLCACHE_CRITICAL_SECTION();
+    while (fCurrentDamage > 0)
+    {
+        Vector vecEnd = vecSrc + vecDir * flDistance;
+
+        trace_t tr; // main enter bullet trace
+
+        UTIL_TraceLineIgnoreTwoEntities(vecSrc, vecEnd, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, this, lastPlayerHit, COLLISION_GROUP_NONE, &tr);
+        {
+            CTraceFilterSkipTwoEntities filter(this, lastPlayerHit, COLLISION_GROUP_NONE);
+
+            // Check for player hitboxes extending outside their collision bounds
+            const float rayExtension = 40.0f;
+            UTIL_ClipTraceToPlayers(vecSrc, vecEnd + vecDir * rayExtension, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, &filter, &tr);
+        }
+
+        lastPlayerHit = ToBasePlayer(tr.m_pEnt);
+
+        if (tr.fraction == 1.0f)
+            break; // we didn't hit anything, stop tracing shoot
+
+
+        bFirstHit = false;
+
+#ifndef CLIENT_DLL
+        //
+        // Propogate a bullet impact event
+        // @todo Add this for shotgun pellets (which dont go thru here)
+        //
+        IGameEvent * event = gameeventmanager->CreateEvent("bullet_impact");
+        if (event)
+        {
+            event->SetInt("userid", GetUserID());
+            event->SetFloat("x", tr.endpos.x);
+            event->SetFloat("y", tr.endpos.y);
+            event->SetFloat("z", tr.endpos.z);
+            gameeventmanager->FireEvent(event);
+        }
+#endif
+
+        /************* MATERIAL DETECTION ***********/
+        surfacedata_t *pSurfaceData = physprops->GetSurfaceData(tr.surface.surfaceProps);
+        int iEnterMaterial = pSurfaceData->game.material;
+
+        //GetMaterialParameters(iEnterMaterial, flPenetrationModifier, flDamageModifier);
+
+        bool hitGrate = ((tr.contents & CONTENTS_GRATE) == 1);
+
+        // since some railings in de_inferno are CONTENTS_GRATE but CHAR_TEX_CONCRETE, we'll trust the
+        // CONTENTS_GRATE and use a high damage modifier.
+        if (hitGrate)
+        {
+            // If we're a concrete grate (TOOLS/TOOLSINVISIBLE texture) allow more penetrating power.
+            flPenetrationModifier = 1.0f;
+            flDamageModifier = 0.99f;
+        }
+
+#ifdef CLIENT_DLL
+        if (sv_showimpacts.GetInt() == 1 || sv_showimpacts.GetInt() == 2)
+        {
+            // draw red client impact markers
+            debugoverlay->AddBoxOverlay(tr.endpos, Vector(-2, -2, -2), Vector(2, 2, 2), QAngle(0, 0, 0), 255, 0, 0, 127, 4);
+
+            if (tr.m_pEnt && tr.m_pEnt->IsPlayer())
+            {
+                C_BasePlayer *player = ToBasePlayer(tr.m_pEnt);
+                player->DrawClientHitboxes(4, true);
+            }
+        }
+#else
+        if (sv_showimpacts.GetInt() == 1 || sv_showimpacts.GetInt() == 3)
+        {
+            // draw blue server impact markers
+            NDebugOverlay::Box(tr.endpos, Vector(-2, -2, -2), Vector(2, 2, 2), 0, 0, 255, 127, 4);
+
+            if (tr.m_pEnt && tr.m_pEnt->IsPlayer())
+            {
+                CBasePlayer *player = ToBasePlayer(tr.m_pEnt);
+                player->DrawServerHitboxes(4, true);
+            }
+        }
+#endif
+
+        //calculate the damage based on the distance the bullet travelled.
+        flCurrentDistance += tr.fraction * flDistance;
+        fCurrentDamage *= pow(flRangeModifier, (flCurrentDistance / 500));
+
+        // check if we reach penetration distance, no more penetrations after that
+        if (flCurrentDistance > flPenetrationDistance && iPenetration > 0)
+            iPenetration = 0;
+
+        int iDamageType = DMG_BULLET | DMG_NEVERGIB;
+
+        if (bDoEffects)
+        {
+            // See if the bullet ended up underwater + started out of the water
+            if (enginetrace->GetPointContents(tr.endpos) & (CONTENTS_WATER | CONTENTS_SLIME))
+            {
+                trace_t waterTrace;
+                UTIL_TraceLine(vecSrc, tr.endpos, (MASK_SHOT | CONTENTS_WATER | CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &waterTrace);
+
+                if (waterTrace.allsolid != 1)
+                {
+                    CEffectData	data;
+                    data.m_vOrigin = waterTrace.endpos;
+                    data.m_vNormal = waterTrace.plane.normal;
+                    data.m_flScale = random->RandomFloat(8, 12);
+
+                    if (waterTrace.contents & CONTENTS_SLIME)
+                    {
+                        data.m_fFlags |= FX_WATER_IN_SLIME;
+                    }
+
+                    DispatchEffect("gunshotsplash", data);
+                }
+            }
+            else
+            {
+                //Do Regular hit effects
+
+                // Don't decal nodraw surfaces
+                if (!(tr.surface.flags & (SURF_SKY | SURF_NODRAW | SURF_HINT | SURF_SKIP)))
+                {
+                    CBaseEntity *pEntity = tr.m_pEnt;
+                    //MOM_TODO: question the 
+                    if (pEntity)
+                        UTIL_ImpactTrace(&tr, iDamageType);
+                    //if (!(pEntity && pEntity->GetTeamNumber() == GetTeamNumber()))
+                    //{
+                    //    UTIL_ImpactTrace(&tr, iDamageType);
+                    //}
+                }
+            }
+        } // bDoEffects
+
+        // add damage to entity that we hit
+
+#ifndef CLIENT_DLL
+        ClearMultiDamage();
+
+        CTakeDamageInfo info(pevAttacker, pevAttacker, fCurrentDamage, iDamageType);
+        CalculateBulletDamageForce(&info, iBulletType, vecDir, tr.endpos);
+        tr.m_pEnt->DispatchTraceAttack(info, vecDir, &tr);
+
+        TraceAttackToTriggers(info, tr.startpos, tr.endpos, vecDir);
+
+        ApplyMultiDamage();
+#endif
+
+        // check if bullet can penetarte another entity
+        if (iPenetration == 0 && !hitGrate)
+            break; // no, stop
+
+        // If we hit a grate with iPenetration == 0, stop on the next thing we hit
+        if (iPenetration < 0)
+            break;
+
+        Vector penetrationEnd;
+
+        // try to penetrate object, maximum penetration is 128 inch
+        if (!TraceToExit(tr.endpos, vecDir, penetrationEnd, 24, 128))
+            break;
+
+        // find exact penetration exit
+        trace_t exitTr;
+        UTIL_TraceLine(penetrationEnd, tr.endpos, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, NULL, &exitTr);
+
+        if (exitTr.m_pEnt != tr.m_pEnt && exitTr.m_pEnt != NULL)
+        {
+            // something was blocking, trace again
+            UTIL_TraceLine(penetrationEnd, tr.endpos, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, exitTr.m_pEnt, COLLISION_GROUP_NONE, &exitTr);
+        }
+
+        // get material at exit point
+        pSurfaceData = physprops->GetSurfaceData(exitTr.surface.surfaceProps);
+        int iExitMaterial = pSurfaceData->game.material;
+
+        hitGrate = hitGrate && (exitTr.contents & CONTENTS_GRATE);
+
+        // if enter & exit point is wood or metal we assume this is 
+        // a hollow crate or barrel and give a penetration bonus
+        if (iEnterMaterial == iExitMaterial)
+        {
+            if (iExitMaterial == CHAR_TEX_WOOD ||
+                iExitMaterial == CHAR_TEX_METAL)
+            {
+                flPenetrationModifier *= 2;
+            }
+        }
+
+        float flTraceDistance = VectorLength(exitTr.endpos - tr.endpos);
+
+        // check if bullet has enough power to penetrate this distance for this material
+        if (flTraceDistance > (flPenetrationPower * flPenetrationModifier))
+            break; // bullet hasn't enough power to penetrate this distance
+
+        // penetration was successful
+
+        // bullet did penetrate object, exit Decal
+        if (bDoEffects)
+        {
+            UTIL_ImpactTrace(&exitTr, iDamageType);
+        }
+
+        //setup new start end parameters for successive trace
+
+        flPenetrationPower -= flTraceDistance / flPenetrationModifier;
+        flCurrentDistance += flTraceDistance;
+
+        // NDebugOverlay::Box( exitTr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,255,0,127, 8 );
+
+        vecSrc = exitTr.endpos;
+        flDistance = (flDistance - flCurrentDistance) * 0.5;
+
+        // reduce damage power each time we hit something other than a grate
+        fCurrentDamage *= flDamageModifier;
+
+        // reduce penetration counter
+        iPenetration--;
+    }
+
+}
+
+void CMomentumPlayer::KickBack(float up_base, float lateral_base, float up_modifier, float lateral_modifier, float up_max, float lateral_max, int direction_change)
+{
+    float flKickUp;
+    float flKickLateral;
+
+    if (m_iShotsFired == 1) // This is the first round fired
+    {
+        flKickUp = up_base;
+        flKickLateral = lateral_base;
+    }
+    else
+    {
+        flKickUp = up_base + m_iShotsFired*up_modifier;
+        flKickLateral = lateral_base + m_iShotsFired*lateral_modifier;
+    }
+
+
+    QAngle angle = GetPunchAngle();
+
+    angle.x -= flKickUp;
+    if (angle.x < -1 * up_max)
+        angle.x = -1 * up_max;
+
+    if (m_iDirection == 1)
+    {
+        angle.y += flKickLateral;
+        if (angle.y > lateral_max)
+            angle.y = lateral_max;
+    }
+    else
+    {
+        angle.y -= flKickLateral;
+        if (angle.y < -1 * lateral_max)
+            angle.y = -1 * lateral_max;
+    }
+
+    if (!SharedRandomInt("KickBack", 0, direction_change))
+        m_iDirection = 1 - m_iDirection;
+
+    SetPunchAngle(angle);
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_player_shared.h b/mp/src/game/shared/momentum/mom_player_shared.h
new file mode 100644
index 000000000..e6e4cca6c
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_player_shared.h
@@ -0,0 +1,24 @@
+#ifndef MOM_PLAYER_SHARED_H
+#define MOM_PLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cbase.h"
+
+#ifdef CLIENT_DLL
+#include "momentum/c_mom_player.h"
+#define CMomentumPlayer C_MomentumPlayer
+#else
+#include "momentum/mom_player.h"
+#endif
+
+
+inline CMomentumPlayer *ToCMOMPlayer(CBaseEntity *pEntity)
+{
+    if (!pEntity || !pEntity->IsPlayer())
+        return NULL;
+    return dynamic_cast<CMomentumPlayer*>(pEntity);
+}
+
+#endif // MOM_PLAYER_SHARED_H
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_shareddefs.h b/mp/src/game/shared/momentum/mom_shareddefs.h
new file mode 100644
index 000000000..ca362b339
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_shareddefs.h
@@ -0,0 +1,21 @@
+#ifndef MOM_SHAREDDEFS_H
+#define MOM_SHAREDDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "const.h"
+#include "shareddefs.h"
+
+// Gamemode for momentum
+typedef enum MOMGM
+{
+    MOMGM_UNKNOWN = 0,
+    MOMGM_SURF,
+    MOMGM_BHOP,
+    MOMGM_SCROLL,
+    MOMGM_ALLOWED, //not "official gamemode" but must be allowed for other reasons
+    
+} GAMEMODES;
+#endif // MOM_SHAREDDEFS_H
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/mom_usermessages.cpp b/mp/src/game/shared/momentum/mom_usermessages.cpp
new file mode 100644
index 000000000..5f0a47e97
--- /dev/null
+++ b/mp/src/game/shared/momentum/mom_usermessages.cpp
@@ -0,0 +1,53 @@
+#include "cbase.h"
+#include "usermessages.h"
+#include "shake.h"
+#include "voice_gamemgr.h"
+#include "haptics/haptic_msgs.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//MOM_TODO: go through and remove the usermessages we don't need anymore
+void RegisterUserMessages(void)
+{
+    usermessages->Register("Geiger", 1);
+    usermessages->Register("Train", 1);
+    usermessages->Register("HudText", -1);
+    usermessages->Register("SayText", -1);
+    usermessages->Register("SayText2", -1);
+    usermessages->Register("TextMsg", -1);
+    usermessages->Register("HudMsg", -1);
+    usermessages->Register("ResetHUD", 1);		// called every respawn
+    usermessages->Register("GameTitle", 0);
+    usermessages->Register("ItemPickup", -1);
+    usermessages->Register("ShowMenu", -1);
+    usermessages->Register("Shake", 13);
+    usermessages->Register("Fade", 10);
+    usermessages->Register("VGUIMenu", -1);	// Show VGUI menu
+    //usermessages->Register("Rumble", 3);	// Send a rumble to a controller
+    //usermessages->Register("Battery", 2);
+    usermessages->Register("Damage", 18);		// BUG: floats are sent for coords, no variable bitfields in hud & fixed size Msg
+    usermessages->Register("VoiceMask", VOICE_MAX_PLAYERS_DW * 4 * 2 + 1);
+    usermessages->Register("RequestState", 0);
+    usermessages->Register("CloseCaption", -1); // Show a caption (by string id number)(duration in 10th of a second)
+    usermessages->Register("HintText", -1);	// Displays hint text display
+    usermessages->Register("KeyHintText", -1);	// Displays hint text display
+    //usermessages->Register("SquadMemberDied", 0);
+    usermessages->Register("AmmoDenied", 2);
+    usermessages->Register("CreditsMsg", 1);
+    usermessages->Register("LogoTimeMsg", 4);
+    usermessages->Register("AchievementEvent", -1);
+    //usermessages->Register("UpdateJalopyRadar", -1);
+
+    usermessages->Register("ReloadEffect", 2);			// a player reloading..
+    usermessages->Register("PlayerAnimEvent", -1);	// jumping, firing, reload, etc.
+
+    usermessages->Register("Timer_State", 5);
+    usermessages->Register("Timer_PauseTime", -1);
+    usermessages->Register("Timer_Reset", 0);
+    usermessages->Register("Timer_Checkpoint", 9);
+    usermessages->Register("Timer_Stage", 4);
+    usermessages->Register("Timer_StageCount", 4);
+    //usermessages->Register("Timer_GameMode", 4);
+    RegisterHapticMessages();
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/util/mom_util.cpp b/mp/src/game/shared/momentum/util/mom_util.cpp
new file mode 100644
index 000000000..bc7832118
--- /dev/null
+++ b/mp/src/game/shared/momentum/util/mom_util.cpp
@@ -0,0 +1,143 @@
+#include "cbase.h"
+#include "mom_util.h"
+#include "filesystem.h"
+
+#include "tier0/memdbgon.h"
+
+extern IFileSystem* filesystem;
+
+#ifdef GAME_DLL
+void MomentumUtil::DownloadCallback(HTTPRequestCompleted_t *pCallback, bool bIOFailure)
+{
+    if (bIOFailure) return;
+
+    FileHandle_t file;
+    //MOM_TODO: Read the MOM_TODO DownloadMap(), we're going to need to save the zone files too
+    file = filesystem->Open("testmapdownload.bsp", "w+b", "MOD");
+    uint32 size;
+    steamapicontext->SteamHTTP()->GetHTTPResponseBodySize(pCallback->m_hRequest, &size);
+    DevLog("Size of body: %u\n", size);
+    uint8 *pData = new uint8[size];
+    steamapicontext->SteamHTTP()->GetHTTPResponseBodyData(pCallback->m_hRequest, pData, size);
+    //write the file
+    filesystem->Write(pData, size, file);
+    //save the file
+    filesystem->Close(file);
+    DevLog("Successfully written file\n");
+
+    //Free resources
+    steamapicontext->SteamHTTP()->ReleaseHTTPRequest(pCallback->m_hRequest);
+}
+
+void MomentumUtil::PostTimeCallback(HTTPRequestCompleted_t *pCallback, bool bIOFailure)
+{
+    if (bIOFailure) return;
+    uint32 size;
+    steamapicontext->SteamHTTP()->GetHTTPResponseBodySize(pCallback->m_hRequest, &size);
+    DevLog("Size of body: %u\n", size);
+    uint8 *pData = new uint8[size];
+    steamapicontext->SteamHTTP()->GetHTTPResponseBodyData(pCallback->m_hRequest, pData, size);
+
+    JsonValue val;//Outer object
+    JsonAllocator alloc;
+    char* pDataPtr = reinterpret_cast<char*>(pData);
+    DevLog("pDataPtr: %s\n", pDataPtr);
+    char *endPtr;
+    int status = jsonParse(pDataPtr, &endPtr, &val, alloc);
+
+    if (status == JSON_OK)
+    {
+        DevLog("JSON Parsed!\n");
+        if (val.getTag() == JSON_OBJECT)//Outer should be a JSON Object
+        {
+            //toNode() returns the >>payload<< of the JSON object !!!
+
+            DevLog("Outer is JSON OBJECT!\n");
+            JsonNode *node = val.toNode();
+            DevLog("Outer has key %s with value %s\n", node->key, node->value.toString());
+
+            if (node && node->value.getTag() == JSON_TRUE)
+            {
+                DevLog("RESPONSE WAS TRUE!\n");
+                // Necesary so TimeDisplay scoreboard knows it has to update;
+                IGameEvent *postEvent = gameeventmanager->CreateEvent("runtime_posted");
+                if (postEvent)
+                    gameeventmanager->FireEvent(postEvent);
+
+                //MOM_TODO: Once the server updates this to contain more info, parse and do more with the response
+            }
+        }
+    }
+    else
+    {
+        Warning("%s at %zd\n", jsonStrError(status), endPtr - pDataPtr);
+    }
+    //Last but not least, free resources
+    alloc.deallocate();
+    steamapicontext->SteamHTTP()->ReleaseHTTPRequest(pCallback->m_hRequest);
+}
+
+void MomentumUtil::PostTime(const char* szURL)
+{
+    CreateAndSendHTTPReq(szURL, &cbPostTimeCallback, &MomentumUtil::PostTimeCallback);
+}
+
+void MomentumUtil::DownloadMap(const char* szMapname)
+{
+    if (!steamapicontext->SteamHTTP())
+    {
+        Warning("Failed to download map, cannot access HTTP!\n");
+        return;
+    }
+    //MOM_TODO: 
+    //This should only be called if the user has the outdated map version or
+    //doesn't have the map at all
+
+    //The two different URLs:
+    //cdn.momentum-mod.org/maps/MAPNAME/MAPNAME.bsp
+    //and
+    //cdn.momentum-mod.org/maps/MAPNAME/MAPNAME.zon
+    //We're going to need to build requests for and download both of these files
+
+    //Uncomment the following when we build the URLS (MOM_TODO)
+    //CreateAndSendHTTPReq(mapfileURL, &cbDownloadCallback, &MomentumUtil::DownloadCallback);
+    //CreateAndSendHTTPReq(zonFileURL, &cbDownloadCallback, &MomentumUtil::DownloadCallback);
+}
+
+
+void MomentumUtil::CreateAndSendHTTPReq(const char* szURL, CCallResult<MomentumUtil, HTTPRequestCompleted_t>* callback,
+    CCallResult<MomentumUtil, HTTPRequestCompleted_t>::func_t func)
+{
+    HTTPRequestHandle handle = steamapicontext->SteamHTTP()->CreateHTTPRequest(k_EHTTPMethodGET, szURL);
+    SteamAPICall_t apiHandle;
+    if (steamapicontext->SteamHTTP()->SendHTTPRequest(handle, &apiHandle))
+    {
+        callback->Set(apiHandle, this, func);
+    }
+    else
+    {
+        Warning("Failed to send HTTP Request to post scores online!\n");
+        steamapicontext->SteamHTTP()->ReleaseHTTPRequest(handle);//GC
+    }
+}
+
+#endif
+
+void MomentumUtil::FormatTime(float ticks, float rate, char *pOut)
+{
+    float m_flSecondsTime = ticks * rate;
+
+    int hours = m_flSecondsTime / (60.0f * 60.0f);
+    int minutes = fmod(m_flSecondsTime / 60.0f, 60.0f);
+    int seconds = fmod(m_flSecondsTime, 60.0f);
+    int millis = fmod(m_flSecondsTime, 1.0f) * 1000.0f;
+
+    Q_snprintf(pOut, 15, "%02d:%02d:%02d.%03d",
+        hours,
+        minutes,
+        seconds,
+        millis
+        );
+}
+
+MomentumUtil mom_UTIL;
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/util/mom_util.h b/mp/src/game/shared/momentum/util/mom_util.h
new file mode 100644
index 000000000..acbe38deb
--- /dev/null
+++ b/mp/src/game/shared/momentum/util/mom_util.h
@@ -0,0 +1,36 @@
+#ifndef MOM_UTIL_H
+#define MOM_UTIL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "filesystem.h"
+#include "gason.h"
+
+class MomentumUtil
+{
+public:
+
+#ifdef GAME_DLL
+    void PostTimeCallback(HTTPRequestCompleted_t*, bool);
+    void DownloadCallback(HTTPRequestCompleted_t*, bool);
+    void PostTime(const char* URL);
+    void DownloadMap(const char*);
+
+    void CreateAndSendHTTPReq(const char*, CCallResult<MomentumUtil, HTTPRequestCompleted_t>*,
+        CCallResult<MomentumUtil, HTTPRequestCompleted_t>::func_t);
+
+    CCallResult<MomentumUtil, HTTPRequestCompleted_t> cbDownloadCallback;
+    CCallResult<MomentumUtil, HTTPRequestCompleted_t> cbPostTimeCallback;
+#endif
+
+    //Formats time in ticks by a given tickrate into
+    //"HH:MM:SS.mmmm"
+    void FormatTime(float ticks, float rate, char *pOut);
+
+    
+};
+
+extern MomentumUtil mom_UTIL;
+
+#endif //MOM_UTIL_H
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_basecsgrenade.cpp b/mp/src/game/shared/momentum/weapon_basecsgrenade.cpp
new file mode 100644
index 000000000..016725b0b
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_basecsgrenade.cpp
@@ -0,0 +1,410 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_basecsgrenade.h"
+#include "in_buttons.h"	
+#include "datacache/imdlcache.h"
+#include "mom_player_shared.h"
+
+#ifndef CLIENT_DLL
+
+#include "items.h"
+
+#endif
+
+
+#define GRENADE_TIMER	1.5f //Seconds
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED(BaseCSGrenade, DT_BaseCSGrenade)
+
+BEGIN_NETWORK_TABLE(CBaseCSGrenade, DT_BaseCSGrenade)
+
+#ifndef CLIENT_DLL
+SendPropBool(SENDINFO(m_bRedraw)),
+SendPropBool(SENDINFO(m_bPinPulled)),
+SendPropFloat(SENDINFO(m_fThrowTime), 0, SPROP_NOSCALE),
+#else
+RecvPropBool( RECVINFO(m_bRedraw) ),
+RecvPropBool( RECVINFO(m_bPinPulled) ),
+RecvPropFloat( RECVINFO(m_fThrowTime) ),
+#endif
+
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CBaseCSGrenade )
+DEFINE_PRED_FIELD( m_bRedraw, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+DEFINE_PRED_FIELD( m_bRedraw, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS(weapon_basecsgrenade, CBaseCSGrenade);
+
+
+CBaseCSGrenade::CBaseCSGrenade()
+{
+    m_bRedraw = false;
+    m_bPinPulled = false;
+    m_fThrowTime = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::Precache()
+{
+    BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Deploy()
+{
+    m_bRedraw = false;
+    m_bPinPulled = false;
+    m_fThrowTime = 0;
+
+#ifndef CLIENT_DLL
+    // if we're officially out of grenades, ditch this weapon
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        pPlayer->Weapon_Drop(this, NULL, NULL);
+        UTIL_Remove(this);
+        return false;
+    }
+#endif
+
+    return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Holster(CBaseCombatWeapon *pSwitchingTo)
+{
+    m_bRedraw = false;
+    m_bPinPulled = false; // when this is holstered make sure the pin isn’t pulled.
+    m_fThrowTime = 0;
+
+#ifndef CLIENT_DLL
+    // If they attempt to switch weapons before the throw animation is done, 
+    // allow it, but kill the weapon if we have to.
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        CBaseCombatCharacter *pOwner = (CBaseCombatCharacter *) pPlayer;
+        pOwner->Weapon_Drop(this);
+        UTIL_Remove(this);
+    }
+#endif
+
+    return BaseClass::Holster(pSwitchingTo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::PrimaryAttack()
+{
+    if (m_bRedraw || m_bPinPulled || m_fThrowTime > 0.0f)
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer || pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+        return;
+
+    // The pull pin animation has to finish, then we wait until they aren't holding the primary
+    // attack button, then throw the grenade.
+    SendWeaponAnim(ACT_VM_PULLPIN);
+    m_bPinPulled = true;
+
+    // Don't let weapon idle interfere in the middle of a throw!
+    MDLCACHE_CRITICAL_SECTION();
+    SetWeaponIdleTime(gpGlobals->curtime + SequenceDuration());
+
+    m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::SecondaryAttack()
+{
+    if (m_bRedraw)
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer == NULL)
+        return;
+
+    //See if we're ducking
+    if (pPlayer->GetFlags() & FL_DUCKING)
+    {
+        //Send the weapon animation
+        SendWeaponAnim(ACT_VM_SECONDARYATTACK);
+    }
+    else
+    {
+        //Send the weapon animation
+        SendWeaponAnim(ACT_VM_HAULBACK);
+    }
+
+    // Don't let weapon idle interfere in the middle of a throw!
+    SetWeaponIdleTime(gpGlobals->curtime + SequenceDuration());
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Reload()
+{
+    if ((m_bRedraw) && (m_flNextPrimaryAttack <= gpGlobals->curtime) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+    {
+        //Redraw the weapon
+        SendWeaponAnim(ACT_VM_DRAW);
+
+        //Update our times
+        m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+        m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
+
+        SetWeaponIdleTime(gpGlobals->curtime + SequenceDuration());
+
+        //Mark this as done
+        //	m_bRedraw = false;
+    }
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::ItemPostFrame()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    CBaseViewModel *vm = pPlayer->GetViewModel(m_nViewModelIndex);
+    if (!vm)
+        return;
+
+    // If they let go of the fire button, they want to throw the grenade.
+    if (m_bPinPulled && !(pPlayer->m_nButtons & IN_ATTACK))
+    {
+        //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_THROW_GRENADE );
+
+        StartGrenadeThrow();
+
+        MDLCACHE_CRITICAL_SECTION();
+        m_bPinPulled = false;
+        SendWeaponAnim(ACT_VM_THROW);
+        SetWeaponIdleTime(gpGlobals->curtime + SequenceDuration());
+
+        m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration(); // we're still throwing, so reset our next primary attack
+
+#ifndef CLIENT_DLL
+        IGameEvent * event = gameeventmanager->CreateEvent("weapon_fire");
+        if (event)
+        {
+            const char *weaponName = STRING(m_iClassname);
+            if (strncmp(weaponName, "weapon_", 7) == 0)
+            {
+                weaponName += 7;
+            }
+
+            event->SetInt("userid", pPlayer->GetUserID());
+            event->SetString("weapon", weaponName);
+            gameeventmanager->FireEvent(event);
+        }
+#endif
+    }
+    else if ((m_fThrowTime > 0) && (m_fThrowTime < gpGlobals->curtime))
+    {
+        // only decrement our ammo when we actually create the projectile
+        DecrementAmmo(pPlayer);
+
+        ThrowGrenade();
+    }
+    else if (m_bRedraw)
+    {
+        // Has the throw animation finished playing
+        if (m_flTimeWeaponIdle < gpGlobals->curtime)
+        {
+#ifdef GAME_DLL
+            // if we're officially out of grenades, ditch this weapon
+            if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+            {
+                pPlayer->Weapon_Drop(this, NULL, NULL);
+                UTIL_Remove(this);
+            }
+            else
+            {
+                pPlayer->SwitchToNextBestWeapon(this);
+            }
+#endif
+            return;	//don't animate this grenade any more!
+        }
+    }
+    else if (!m_bRedraw)
+    {
+        BaseClass::ItemPostFrame();
+    }
+}
+
+
+
+#ifdef CLIENT_DLL
+
+void CBaseCSGrenade::DecrementAmmo( CBaseCombatCharacter *pOwner )
+{
+}
+
+void CBaseCSGrenade::DropGrenade()
+{
+    m_bRedraw = true;
+    m_fThrowTime = 0.0f;
+}
+
+void CBaseCSGrenade::ThrowGrenade()
+{
+    m_bRedraw = true;
+    m_fThrowTime = 0.0f;
+}
+
+void CBaseCSGrenade::StartGrenadeThrow()
+{
+    m_fThrowTime = gpGlobals->curtime + 0.1f;
+}
+
+#else
+
+BEGIN_DATADESC(CBaseCSGrenade)
+DEFINE_FIELD(m_bRedraw, FIELD_BOOLEAN),
+END_DATADESC()
+
+int CBaseCSGrenade::CapabilitiesGet()
+{
+    return bits_CAP_WEAPON_RANGE_ATTACK1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pOwner - 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::DecrementAmmo(CBaseCombatCharacter *pOwner)
+{
+    pOwner->RemoveAmmo(1, m_iPrimaryAmmoType);
+}
+
+void CBaseCSGrenade::StartGrenadeThrow()
+{
+    m_fThrowTime = gpGlobals->curtime + 0.1f;
+}
+
+void CBaseCSGrenade::ThrowGrenade()
+{
+    CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+    if (!pPlayer)
+    {
+        Assert(false);
+        return;
+    }
+
+    QAngle angThrow = pPlayer->LocalEyeAngles();
+
+    Vector vForward, vRight, vUp;
+
+    if (angThrow.x < 90)
+        angThrow.x = -10 + angThrow.x * ((90 + 10) / 90.0);
+    else
+    {
+        angThrow.x = 360.0f - angThrow.x;
+        angThrow.x = -10 + angThrow.x * -((90 - 10) / 90.0);
+    }
+
+    float flVel = (90 - angThrow.x) * 6;
+
+    if (flVel > 750)
+        flVel = 750;
+
+    AngleVectors(angThrow, &vForward, &vRight, &vUp);
+
+    Vector vecSrc = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset();
+
+    // We want to throw the grenade from 16 units out.  But that can cause problems if we're facing
+    // a thin wall.  Do a hull trace to be safe.
+    trace_t trace;
+    Vector mins(-2, -2, -2);
+    Vector maxs(2, 2, 2);
+    UTIL_TraceHull(vecSrc, vecSrc + vForward * 16, mins, maxs, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &trace);
+    vecSrc = trace.endpos;
+
+    Vector vecThrow = vForward * flVel + pPlayer->GetAbsVelocity();
+
+    EmitGrenade(vecSrc, vec3_angle, vecThrow, AngularImpulse(600, random->RandomInt(-1200, 1200), 0), pPlayer);
+
+    m_bRedraw = true;
+    m_fThrowTime = 0.0f;
+
+    //CMomentumPlayer *pCSPlayer = ToCMOMPlayer( pPlayer );
+
+    //if( pCSPlayer )
+    //	pCSPlayer->Radio( "Radio.FireInTheHole",   "#Cstrike_TitlesTXT_Fire_in_the_hole" );
+}
+
+void CBaseCSGrenade::DropGrenade()
+{
+    CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+    if (!pPlayer)
+    {
+        Assert(false);
+        return;
+    }
+
+    Vector vForward;
+    pPlayer->EyeVectors(&vForward);
+    Vector vecSrc = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset() + vForward * 16;
+
+    Vector vecVel = pPlayer->GetAbsVelocity();
+
+    EmitGrenade(vecSrc, vec3_angle, vecVel, AngularImpulse(600, random->RandomInt(-1200, 1200), 0), pPlayer);
+
+    m_bRedraw = true;
+    m_fThrowTime = 0.0f;
+}
+
+void CBaseCSGrenade::EmitGrenade(Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer)
+{
+    Assert(0 && "CBaseCSGrenade::EmitGrenade should not be called. Make sure to implement this in your subclass!\n");
+}
+
+bool CBaseCSGrenade::AllowsAutoSwitchFrom(void) const
+{
+    return !m_bPinPulled;
+}
+
+#endif
+
diff --git a/mp/src/game/shared/momentum/weapon_basecsgrenade.h b/mp/src/game/shared/momentum/weapon_basecsgrenade.h
new file mode 100644
index 000000000..d1f0296fe
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_basecsgrenade.h
@@ -0,0 +1,80 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_BASECSGRENADE_H
+#define WEAPON_BASECSGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CBaseCSGrenade C_BaseCSGrenade
+
+#endif
+
+
+class CBaseCSGrenade : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CBaseCSGrenade, CWeaponCSBase );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseCSGrenade();
+
+	virtual void	Precache();
+
+	bool			Deploy();
+	bool			Holster( CBaseCombatWeapon *pSwitchingTo );
+
+	void			PrimaryAttack();
+	void			SecondaryAttack();
+
+	bool			Reload();
+
+	virtual void	ItemPostFrame();
+	
+	void			DecrementAmmo( CBaseCombatCharacter *pOwner );
+	virtual void	StartGrenadeThrow();
+	virtual void	ThrowGrenade();
+	virtual void	DropGrenade();
+
+	bool IsPinPulled() const;
+	bool IsBeingThrown() const { return m_fThrowTime > 0; }
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+
+	virtual bool AllowsAutoSwitchFrom( void ) const;
+
+	int		CapabilitiesGet();
+	
+	// Each derived grenade class implements this.
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+#endif
+
+protected:
+	CNetworkVar( bool, m_bRedraw );	// Draw the weapon again after throwing a grenade
+	CNetworkVar( bool, m_bPinPulled );	// Set to true when the pin has been pulled but the grenade hasn't been thrown yet.
+	CNetworkVar( float, m_fThrowTime ); // the time at which the grenade will be thrown.  If this value is 0 then the time hasn't been set yet.
+
+private:
+	CBaseCSGrenade( const CBaseCSGrenade & ) {}
+};
+
+
+inline bool CBaseCSGrenade::IsPinPulled() const
+{
+	return m_bPinPulled;
+}
+
+
+#endif // WEAPON_BASECSGRENADE_H
diff --git a/mp/src/game/shared/momentum/weapon_cs_heavy.cpp b/mp/src/game/shared/momentum/weapon_cs_heavy.cpp
new file mode 100644
index 000000000..fdf647cc0
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_cs_heavy.cpp
@@ -0,0 +1,594 @@
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "fx_cs_shared.h"
+#include "mom_player_shared.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponM249 C_WeaponM249
+#define CWeaponM3 C_WeaponM3
+#define CWeaponXM1014 C_WeaponXM1014
+#else
+#include "momentum/te_shotgun_shot.h"
+#endif
+
+#include "tier0/memdbgon.h"
+
+//M3
+
+class CWeaponM3 : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponM3, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponM3();
+
+    virtual void PrimaryAttack();
+    virtual bool Reload();
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_M3; }
+
+
+private:
+
+    CWeaponM3(const CWeaponM3 &);
+
+    float m_flPumpTime;
+    CNetworkVar(int, m_fInSpecialReload);
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponM3, DT_WeaponM3)
+
+BEGIN_NETWORK_TABLE(CWeaponM3, DT_WeaponM3)
+
+#ifdef CLIENT_DLL
+RecvPropInt(RECVINFO(m_fInSpecialReload))
+#else
+SendPropInt(SENDINFO(m_fInSpecialReload), 2, SPROP_UNSIGNED)
+#endif
+
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponM3)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_m3, CWeaponM3);
+PRECACHE_WEAPON_REGISTER(weapon_m3);
+
+
+
+CWeaponM3::CWeaponM3()
+{
+    m_flPumpTime = 0;
+}
+
+void CWeaponM3::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // don't fire underwater
+    if (pPlayer->GetWaterLevel() == 3)
+    {
+        PlayEmptySound();
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+        return;
+    }
+
+    // Out of ammo?
+    if (m_iClip1 <= 0)
+    {
+        Reload();
+        if (m_iClip1 == 0)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+
+    m_iClip1--;
+    pPlayer->DoMuzzleFlash();
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    // Dispatch the FX right away with full accuracy.
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+        0.0675);
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    if (m_iClip1 != 0)
+        m_flPumpTime = gpGlobals->curtime + 0.5;
+
+    m_flNextPrimaryAttack = gpGlobals->curtime + 0.875;
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.875;
+    if (m_iClip1 != 0)
+        SetWeaponIdleTime(gpGlobals->curtime + 2.5);
+    else
+        SetWeaponIdleTime(gpGlobals->curtime + 0.875);
+    m_fInSpecialReload = 0;
+
+    // Update punch angles.
+    QAngle angle = pPlayer->GetPunchAngle();
+
+    if (pPlayer->GetFlags() & FL_ONGROUND)
+    {
+        angle.x -= SharedRandomInt("M3PunchAngleGround", 4, 6);
+    }
+    else
+    {
+        angle.x -= SharedRandomInt("M3PunchAngleAir", 8, 11);
+    }
+
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponM3::Reload()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 || m_iClip1 == GetMaxClip1())
+        return true;
+
+    // don't reload until recoil is done
+    if (m_flNextPrimaryAttack > gpGlobals->curtime)
+        return true;
+
+    // check to see if we're ready to reload
+    if (m_fInSpecialReload == 0)
+    {
+        pPlayer->SetAnimation(PLAYER_RELOAD);
+
+        SendWeaponAnim(ACT_SHOTGUN_RELOAD_START);
+        m_fInSpecialReload = 1;
+        pPlayer->m_flNextAttack = gpGlobals->curtime + 0.5;
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+        m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+        SetWeaponIdleTime(gpGlobals->curtime + 0.5);
+
+#ifdef GAME_DLL
+        //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_START );
+#endif
+
+        return true;
+    }
+    else if (m_fInSpecialReload == 1)
+    {
+        if (m_flTimeWeaponIdle > gpGlobals->curtime)
+            return true;
+        // was waiting for gun to move to side
+        m_fInSpecialReload = 2;
+
+        SendWeaponAnim(ACT_VM_RELOAD);
+        SetWeaponIdleTime(gpGlobals->curtime + 0.5);
+#ifdef GAME_DLL
+        if (m_iClip1 == 7)
+        {
+            //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_END );
+        }
+        else
+        {
+            //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_LOOP );
+        }
+#endif
+    }
+    else
+    {
+        // Add them to the clip
+        m_iClip1 += 1;
+
+#ifdef GAME_DLL
+        SendReloadEvents();
+#endif
+
+        CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+        if (pPlayer)
+            pPlayer->RemoveAmmo(1, m_iPrimaryAmmoType);
+
+        m_fInSpecialReload = 1;
+    }
+
+    return true;
+}
+
+
+void CWeaponM3::WeaponIdle()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_flPumpTime && m_flPumpTime < gpGlobals->curtime)
+    {
+        // play pumping sound
+        m_flPumpTime = 0;
+    }
+
+    if (m_flTimeWeaponIdle < gpGlobals->curtime)
+    {
+        if (m_iClip1 == 0 && m_fInSpecialReload == 0 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType))
+        {
+            Reload();
+        }
+        else if (m_fInSpecialReload != 0)
+        {
+            if (m_iClip1 != 8 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType))
+            {
+                Reload();
+            }
+            else
+            {
+                // reload debounce has timed out
+                //MIKETODO: shotgun anims
+                SendWeaponAnim(ACT_SHOTGUN_RELOAD_FINISH);
+
+                // play cocking sound
+                m_fInSpecialReload = 0;
+                SetWeaponIdleTime(gpGlobals->curtime + 1.5);
+            }
+        }
+        else
+        {
+            SendWeaponAnim(ACT_VM_IDLE);
+        }
+    }
+}
+
+//M249
+
+class CWeaponM249 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponM249, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponM249();
+
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_M249; }
+
+
+private:
+
+    CWeaponM249(const CWeaponM249 &);
+
+    void M249Fire(float flSpread);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponM249, DT_WeaponM249)
+
+BEGIN_NETWORK_TABLE(CWeaponM249, DT_WeaponM249)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponM249)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_m249, CWeaponM249);
+PRECACHE_WEAPON_REGISTER(weapon_m249);
+
+
+
+CWeaponM249::CWeaponM249()
+{
+}
+
+
+void CWeaponM249::PrimaryAttack(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        M249Fire(0.045f + 0.5f * m_flAccuracy);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        M249Fire(0.045f + 0.095f * m_flAccuracy);
+    else
+        M249Fire(0.03f * m_flAccuracy);
+}
+
+void CWeaponM249::M249Fire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.8, 0.65, 0.45, 0.125, 5, 3.5, 8);
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1.1, 0.5, 0.3, 0.06, 4, 3, 8);
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.75, 0.325, 0.25, 0.025, 3.5, 2.5, 9);
+
+    else
+        pPlayer->KickBack(0.8, 0.35, 0.3, 0.03, 3.75, 3, 9);
+}
+
+//XM1014
+class CWeaponXM1014 : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponXM1014, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponXM1014();
+
+    virtual void Spawn();
+    virtual void PrimaryAttack();
+    virtual bool Reload();
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_XM1014; }
+
+
+private:
+
+    CWeaponXM1014(const CWeaponXM1014 &);
+
+    float m_flPumpTime;
+    CNetworkVar(int, m_fInSpecialReload);
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponXM1014, DT_WeaponXM1014)
+
+BEGIN_NETWORK_TABLE(CWeaponXM1014, DT_WeaponXM1014)
+#ifdef CLIENT_DLL
+RecvPropInt(RECVINFO(m_fInSpecialReload))
+#else
+SendPropInt(SENDINFO(m_fInSpecialReload), 2, SPROP_UNSIGNED)
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponXM1014)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_xm1014, CWeaponXM1014);
+PRECACHE_WEAPON_REGISTER(weapon_xm1014);
+
+
+
+CWeaponXM1014::CWeaponXM1014()
+{
+    m_flPumpTime = 0;
+}
+
+void CWeaponXM1014::Spawn()
+{
+    //m_iDefaultAmmo = M3_DEFAULT_GIVE;
+    //FallInit();// get ready to fall
+    BaseClass::Spawn();
+}
+
+
+void CWeaponXM1014::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // don't fire underwater
+    if (pPlayer->GetWaterLevel() == 3)
+    {
+        PlayEmptySound();
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+        return;
+    }
+
+    if (m_iClip1 <= 0)
+    {
+        Reload();
+
+        if (m_iClip1 == 0)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
+        }
+
+        return;
+    }
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+
+    //pPlayer->m_iWeaponVolume = LOUD_GUN_VOLUME;
+    //pPlayer->m_iWeaponFlash = BRIGHT_GUN_FLASH;
+
+    m_iClip1--;
+    pPlayer->DoMuzzleFlash();
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    // Dispatch the FX right away with full accuracy.
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+        0.0725 // flSpread
+        );
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    if (m_iClip1 != 0)
+        m_flPumpTime = gpGlobals->curtime + 0.5;
+
+    m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.25;
+    if (m_iClip1 != 0)
+        SetWeaponIdleTime(gpGlobals->curtime + 2.5);
+    else
+        SetWeaponIdleTime(gpGlobals->curtime + 0.25);
+    m_fInSpecialReload = 0;
+
+    // Update punch angles.
+    QAngle angle = pPlayer->GetPunchAngle();
+
+    if (pPlayer->GetFlags() & FL_ONGROUND)
+    {
+        angle.x -= SharedRandomInt("XM1014PunchAngleGround", 3, 5);
+    }
+    else
+    {
+        angle.x -= SharedRandomInt("XM1014PunchAngleAir", 7, 10);
+    }
+
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponXM1014::Reload()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 || m_iClip1 == GetMaxClip1())
+        return true;
+
+    // don't reload until recoil is done
+    if (m_flNextPrimaryAttack > gpGlobals->curtime)
+        return true;
+
+    //MIKETODO: shotgun reloading (wait until we get content)
+
+    // check to see if we're ready to reload
+    if (m_fInSpecialReload == 0)
+    {
+        pPlayer->SetAnimation(PLAYER_RELOAD);
+
+        SendWeaponAnim(ACT_SHOTGUN_RELOAD_START);
+        m_fInSpecialReload = 1;
+        pPlayer->m_flNextAttack = gpGlobals->curtime + 0.5;
+        SetWeaponIdleTime(gpGlobals->curtime + 0.5);
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+        m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+
+#ifdef GAME_DLL
+        //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_START );
+#endif
+
+        return true;
+    }
+    else if (m_fInSpecialReload == 1)
+    {
+        if (m_flTimeWeaponIdle > gpGlobals->curtime)
+            return true;
+        // was waiting for gun to move to side
+        m_fInSpecialReload = 2;
+
+        SendWeaponAnim(ACT_VM_RELOAD);
+        SetWeaponIdleTime(gpGlobals->curtime + 0.5);
+#ifdef GAME_DLL
+        if (m_iClip1 == 6)
+        {
+            //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_END );
+        }
+        else
+        {
+            //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_LOOP );
+        }
+#endif
+    }
+    else
+    {
+        // Add them to the clip
+        m_iClip1 += 1;
+
+#ifdef GAME_DLL
+        SendReloadEvents();
+#endif
+
+        CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+        if (pPlayer)
+            pPlayer->RemoveAmmo(1, m_iPrimaryAmmoType);
+
+        m_fInSpecialReload = 1;
+    }
+
+
+    return true;
+}
+
+
+void CWeaponXM1014::WeaponIdle()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_flPumpTime && m_flPumpTime < gpGlobals->curtime)
+    {
+        // play pumping sound
+        m_flPumpTime = 0;
+    }
+
+    if (m_flTimeWeaponIdle < gpGlobals->curtime)
+    {
+        if (m_iClip1 == 0 && m_fInSpecialReload == 0 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType))
+        {
+            Reload();
+        }
+        else if (m_fInSpecialReload != 0)
+        {
+            if (m_iClip1 != 7 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType))
+            {
+                Reload();
+            }
+            else
+            {
+                // reload debounce has timed out
+                //MIKETODO: shotgun anims
+                SendWeaponAnim(ACT_SHOTGUN_RELOAD_FINISH);
+
+                // play cocking sound
+                m_fInSpecialReload = 0;
+                SetWeaponIdleTime(gpGlobals->curtime + 1.5);
+            }
+        }
+        else
+        {
+            SendWeaponAnim(ACT_VM_IDLE);
+        }
+    }
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_cs_pistols.cpp b/mp/src/game/shared/momentum/weapon_cs_pistols.cpp
new file mode 100644
index 000000000..661e218b4
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_cs_pistols.cpp
@@ -0,0 +1,1596 @@
+#include "cbase.h" 
+#include "decals.h" 
+#include "shake.h" 
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+#include "mom_player_shared.h"
+
+
+#ifdef CLIENT_DLL
+#include "c_te_effect_dispatch.h"
+
+#define CDEagle C_DEagle
+#define CDEagleOverride C_DEagleOverride
+#define CWeaponElite C_WeaponElite
+#define CWeaponFiveSeven C_WeaponFiveSeven
+#define CWeaponGlock C_WeaponGlock
+#define CWeaponP228 C_WeaponP228
+#define CWeaponUSP C_WeaponUSP
+#else
+#include "hierarchy.h"
+#endif
+
+
+#include "tier0/memdbgon.h"
+
+
+//DEAGLE
+
+#define DEAGLE_WEIGHT   7
+#define DEAGLE_MAX_CLIP 7
+
+enum deagle_e
+{
+    DEAGLE_IDLE1 = 0,
+    DEAGLE_SHOOT1,
+    DEAGLE_SHOOT2,
+    DEAGLE_SHOOT_EMPTY,
+    DEAGLE_RELOAD,
+    DEAGLE_DRAW,
+};
+
+class CDEagle : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CDEagle, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CDEagle();
+
+    void Spawn();
+
+    void PrimaryAttack();
+    void DEAGLEFire(float flSpread);
+    virtual bool Deploy();
+    bool Reload();
+    void WeaponIdle();
+    void MakeBeam();
+    void BeamUpdate();
+    virtual bool UseDecrement() { return true; };
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_DEAGLE; }
+
+public:
+
+    float m_flLastFire;
+
+
+private:
+    CDEagle(const CDEagle &);
+};
+
+//This is an example of an override class
+//We're going to want to point the entity 
+class CDEagleOverride : public CBaseCombatWeapon
+{
+public:
+    DECLARE_CLASS(CDEagleOverride, CBaseCombatWeapon);
+    DECLARE_NETWORKCLASS();
+
+    CDEagleOverride();
+
+    void DefaultTouch(CBaseEntity* pActivator)
+    {
+#ifdef GAME_DLL
+        if (pActivator->IsPlayer())
+        {
+            CMomentumPlayer *pPlayer = static_cast<CMomentumPlayer*>(pActivator);
+            CUtlVector<CBaseEntity *> children;
+            if (GetAllChildren(this, children) > 0)
+            {
+                FOR_EACH_VEC(children, i)
+                {
+                    if (children[i])
+                    {
+                        Vector offset = children[i]->GetLocalOrigin();
+                        //QAngle offsetAng = children[i]->GetLocalAngles();
+                        //offset.z -= pActivator->GetViewOffset().z;
+
+                        children[i]->SetParent(pPlayer->GetActiveWeapon());
+                        children[i]->SetLocalOrigin(offset);
+                        //children[i]->SetLocalAngles(offsetAng);
+                    }
+                }
+                //CMomentumPlayer *pPlay = dynamic_cast<CMomentumPlayer*>(pActivator);
+                //if (pPlay)
+                //    SetParent(pPlay);
+            }
+        }
+#endif
+    };
+
+    void OnPickedUp(CBaseCombatCharacter* pNewOwner)
+    {
+        //Use(pNewOwner, NULL, , NULL);
+    }
+
+    void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) {};
+
+private:
+    CDEagleOverride(const CDEagleOverride&);
+};
+
+CDEagleOverride::CDEagleOverride()
+{
+    SetSolid(SOLID_NONE);
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED(DEagle, DT_WeaponDEagle)
+
+IMPLEMENT_NETWORKCLASS_ALIASED(DEagleOverride, DT_DEagleOverride)
+
+BEGIN_NETWORK_TABLE(CDEagle, DT_WeaponDEagle)
+END_NETWORK_TABLE()
+
+BEGIN_NETWORK_TABLE(CDEagleOverride, DT_DEagleOverride)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CDEagle)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_deagle, CDEagleOverride);
+PRECACHE_WEAPON_REGISTER(weapon_deagle);
+
+
+
+CDEagle::CDEagle()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CDEagle::Spawn()
+{
+    BaseClass::Spawn();
+    m_flAccuracy = 0.9;
+}
+
+
+bool CDEagle::Deploy()
+{
+    m_flAccuracy = 0.9;
+    return BaseClass::Deploy();
+}
+
+
+void CDEagle::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        DEAGLEFire(1.5f * (1 - m_flAccuracy));
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        DEAGLEFire(0.25f * (1 - m_flAccuracy));
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        DEAGLEFire(0.115f * (1 - m_flAccuracy));
+
+    else
+        DEAGLEFire(0.13f * (1 - m_flAccuracy));
+}
+
+
+void CDEagle::DEAGLEFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    pPlayer->m_iShotsFired++;
+
+    if (pPlayer->m_iShotsFired > 1)
+        return;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.35)*(0.4 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.9)
+        m_flAccuracy = 0.9;
+    else if (m_flAccuracy < 0.55)
+        m_flAccuracy = 0.55;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_iClip1--;
+
+    pPlayer->DoMuzzleFlash();
+
+    if (m_iClip1 > 0)
+        SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+    else
+        SendWeaponAnim(ACT_VM_DRYFIRE);
+
+    //SetPlayerShieldAnim();
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    //pPlayer->m_iWeaponVolume = BIG_EXPLOSION_VOLUME;
+    //pPlayer->m_iWeaponFlash = BRIGHT_GUN_FLASH;
+
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        flSpread);	// bullets
+
+    m_flNextPrimaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 1.8);
+
+    QAngle punchAngle = pPlayer->GetPunchAngle();
+    punchAngle.x -= 2;
+    pPlayer->SetPunchAngle(punchAngle);
+
+    //ResetPlayerShieldAnim();
+}
+
+
+bool CDEagle::Reload()
+{
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.9;
+    return true;
+}
+
+void CDEagle::WeaponIdle()
+{
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    SetWeaponIdleTime(gpGlobals->curtime + 20);
+
+    if (m_iClip1 != 0)
+    {
+        SendWeaponAnim(ACT_VM_IDLE);
+    }
+
+    //if ( FBitSet(m_iWeaponState, WPNSTATE_SHIELD_DRAWN) )
+    //	 SendWeaponAnim( SHIELDGUN_DRAWN_IDLE, UseDecrement() ? 1:0 );
+}
+
+
+/*
+ELITES
+*/
+class CWeaponElite : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponElite, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponElite();
+
+    virtual void Spawn();
+    virtual void Precache();
+
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+
+    void ELITEFire(float flSpread);
+
+    virtual bool Reload();
+
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_ELITE; }
+
+#ifdef CLIENT_DLL
+    virtual int		GetMuzzleAttachment(void);
+    virtual bool OnFireEvent(C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options);
+#endif
+
+    virtual const char		*GetWorldModel(void) const;
+    virtual int				GetWorldModelIndex(void);
+
+private:
+
+    CWeaponElite(const CWeaponElite &);
+    float		m_flLastFire;
+    CNetworkVar(bool, m_bFireRight);
+
+    int m_droppedModelIndex;
+    bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponElite, DT_WeaponElite)
+
+BEGIN_NETWORK_TABLE(CWeaponElite, DT_WeaponElite)
+#ifdef CLIENT_DLL
+RecvPropBool(RECVINFO(m_bFireRight)),
+#else
+SendPropBool(SENDINFO(m_bFireRight)),
+#endif
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA(CWeaponElite)
+DEFINE_PRED_FIELD(m_bFireRight, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE)
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS(weapon_elite, CWeaponElite);
+PRECACHE_WEAPON_REGISTER(weapon_elite);
+
+CWeaponElite::CWeaponElite()
+{
+    m_flLastFire = gpGlobals->curtime;
+    m_inPrecache = false;
+}
+
+
+void CWeaponElite::Spawn()
+{
+    m_flAccuracy = 0.88;
+    m_bFireRight = false;
+
+    BaseClass::Spawn();
+}
+
+
+void CWeaponElite::Precache()
+{
+    m_inPrecache = true;
+    BaseClass::Precache();
+
+    PrecacheModel("models/weapons/w_eq_eholster_elite.mdl");
+    PrecacheModel("models/weapons/w_eq_eholster.mdl");
+    PrecacheModel("models/weapons/w_pist_elite_single.mdl");
+    m_droppedModelIndex = CBaseEntity::PrecacheModel(GetCSWpnData().m_szDroppedModel);
+    m_inPrecache = false;
+}
+
+bool CWeaponElite::Deploy()
+{
+    m_flAccuracy = 0.88;
+    return BaseClass::Deploy();
+}
+
+int CWeaponElite::GetWorldModelIndex(void)
+{
+    if (GetOwner() || m_inPrecache)
+    {
+        return m_iWorldModelIndex;
+    }
+    else
+    {
+        return m_droppedModelIndex;
+    }
+}
+
+const char * CWeaponElite::GetWorldModel(void) const
+{
+    if (GetOwner() || m_inPrecache)
+    {
+        return BaseClass::GetWorldModel();
+    }
+    else
+    {
+        return GetCSWpnData().m_szDroppedModel;
+    }
+}
+
+void CWeaponElite::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        ELITEFire(1.3f * (1 - m_flAccuracy));
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        ELITEFire(0.175f * (1 - m_flAccuracy));
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        ELITEFire(0.08f * (1 - m_flAccuracy));
+
+    else
+        ELITEFire(0.1f * (1 - m_flAccuracy));
+}
+
+void CWeaponElite::ELITEFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    pPlayer->m_iShotsFired++;
+
+    if (pPlayer->m_iShotsFired > 1)
+        return;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.275)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.88)
+        m_flAccuracy = 0.88;
+    else if (m_flAccuracy < 0.55)
+        m_flAccuracy = 0.55;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_iClip1--;
+    m_bFireRight = !m_bFireRight; // flip side
+
+    pPlayer->DoMuzzleFlash();
+
+    //SetPlayerShieldAnim();
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        m_bFireRight ? Primary_Mode : Secondary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        flSpread);
+
+    m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 2.5);
+
+    if (m_bFireRight)  //even number
+    {
+        if (m_iClip1 > 1)
+            SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+        else
+            SendWeaponAnim(ACT_VM_DRYFIRE_LEFT);
+    }
+    else
+    {
+        if (m_iClip1 > 0)
+            SendWeaponAnim(ACT_VM_SECONDARYATTACK);
+        else
+            SendWeaponAnim(ACT_VM_DRYFIRE);
+    }
+
+    QAngle punchAngle = pPlayer->GetPunchAngle();
+    punchAngle.x -= 2;
+    pPlayer->SetPunchAngle(punchAngle);
+
+    //ResetPlayerShieldAnim();
+}
+
+
+bool CWeaponElite::Reload()
+{
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.88;
+    m_bFireRight = false;
+    return true;
+}
+
+void CWeaponElite::WeaponIdle()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        if (m_iClip1 == 1)
+            SendWeaponAnim(ACT_VM_IDLE_EMPTY_LEFT);
+        else
+            SendWeaponAnim(ACT_VM_IDLE);
+    }
+
+}
+
+#ifdef CLIENT_DLL
+
+bool CWeaponElite::OnFireEvent(C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options)
+{
+    if (event == 5001)
+    {
+        CMomentumPlayer *pPlayer = GetPlayerOwner();
+        if (pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed())
+            return true;
+
+        CEffectData data;
+        data.m_fFlags = 0;
+        data.m_hEntity = pViewModel->GetRefEHandle();
+        data.m_nAttachmentIndex = m_bFireRight ? 2 : 1; // toggle muzzle flash
+        data.m_flScale = GetCSWpnData().m_flMuzzleScale;
+
+        DispatchEffect("CS_MuzzleFlash", data);
+
+        return true;
+    }
+
+    return BaseClass::OnFireEvent(pViewModel, origin, angles, event, options);
+}
+
+int CWeaponElite::GetMuzzleAttachment(void)
+{
+    if (m_bFireRight)  //even number
+    {
+        return LookupAttachment("muzzle_flash_r");
+    }
+    else
+    {
+        return LookupAttachment("muzzle_flash_l");
+    }
+}
+
+#endif
+
+
+// FIVESEVEN
+class CWeaponFiveSeven : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponFiveSeven, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponFiveSeven();
+
+    virtual void Spawn();
+
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+    virtual bool Deploy();
+
+    virtual bool Reload();
+
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_FIVESEVEN; }
+
+private:
+
+    CWeaponFiveSeven(const CWeaponFiveSeven &);
+
+    void FiveSevenFire(float flSpread);
+
+    float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponFiveSeven, DT_WeaponFiveSeven)
+
+BEGIN_NETWORK_TABLE(CWeaponFiveSeven, DT_WeaponFiveSeven)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponFiveSeven)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_fiveseven, CWeaponFiveSeven);
+PRECACHE_WEAPON_REGISTER(weapon_fiveseven);
+
+
+
+CWeaponFiveSeven::CWeaponFiveSeven()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CWeaponFiveSeven::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_flAccuracy = 0.92;
+}
+
+bool CWeaponFiveSeven::Deploy()
+{
+    m_flAccuracy = 0.92;
+    return BaseClass::Deploy();
+}
+
+void CWeaponFiveSeven::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        FiveSevenFire(1.5f * (1 - m_flAccuracy));
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        FiveSevenFire(0.255f * (1 - m_flAccuracy));
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        FiveSevenFire(0.075f * (1 - m_flAccuracy));
+    else
+        FiveSevenFire(0.15f * (1 - m_flAccuracy));
+}
+
+void CWeaponFiveSeven::SecondaryAttack()
+{
+}
+
+void CWeaponFiveSeven::FiveSevenFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    pPlayer->m_iShotsFired++;
+
+    if (pPlayer->m_iShotsFired > 1)
+        return;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.25)*(0.275 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.92)
+        m_flAccuracy = 0.92;
+    else if (m_flAccuracy < 0.725)
+        m_flAccuracy = 0.725;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_iClip1--;
+    pPlayer->DoMuzzleFlash();
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        flSpread);
+
+    m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 2);
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= 2;
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponFiveSeven::Reload()
+{
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.92;
+    return true;
+}
+
+void CWeaponFiveSeven::WeaponIdle()
+{
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        SetWeaponIdleTime(gpGlobals->curtime + 4);
+        SendWeaponAnim(ACT_VM_IDLE);
+    }
+}
+
+
+//GLOCK
+class CWeaponGlock : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponGlock, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponGlock();
+
+    virtual void Spawn();
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+    virtual bool Deploy();
+
+    virtual void ItemPostFrame();
+
+    void GlockFire(float flSpread, bool bFireBurst);
+    void FireRemaining(int &shotsFired, float &shootTime);
+
+    virtual bool Reload();
+
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_GLOCK; }
+
+private:
+
+    CWeaponGlock(const CWeaponGlock &);
+
+    CNetworkVar(bool, m_bBurstMode);
+
+    int		m_iGlock18ShotsFired;	// used to keep track of the shots fired during the Glock18 burst fire mode.
+    float	m_flGlock18Shoot;		// time to shoot the remaining bullets of the glock18 burst fire
+    float	m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponGlock, DT_WeaponGlock)
+
+BEGIN_NETWORK_TABLE(CWeaponGlock, DT_WeaponGlock)
+#ifdef CLIENT_DLL
+RecvPropBool(RECVINFO(m_bBurstMode))
+#else
+SendPropBool(SENDINFO(m_bBurstMode))
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponGlock)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_glock, CWeaponGlock);
+PRECACHE_WEAPON_REGISTER(weapon_glock);
+
+
+
+CWeaponGlock::CWeaponGlock()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CWeaponGlock::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_bBurstMode = false;
+    m_iGlock18ShotsFired = 0;
+    m_flGlock18Shoot = 0.0;
+    m_flAccuracy = 0.9;
+}
+
+bool CWeaponGlock::Deploy()
+{
+    m_iGlock18ShotsFired = 0;
+    m_flGlock18Shoot = 0.0;
+    m_flAccuracy = 0.9;
+
+    return BaseClass::Deploy();
+}
+
+void CWeaponGlock::SecondaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_bBurstMode)
+    {
+        ClientPrint(pPlayer, HUD_PRINTCENTER, "#Switch_To_SemiAuto");
+        m_bBurstMode = false;
+    }
+    else
+    {
+        ClientPrint(pPlayer, HUD_PRINTCENTER, "#Switch_To_BurstFire");
+        m_bBurstMode = true;
+    }
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+void CWeaponGlock::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_bBurstMode)
+    {
+        if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+            GlockFire(1.2f * (1 - m_flAccuracy), true);
+
+        else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+            GlockFire(0.185f * (1 - m_flAccuracy), true);
+
+        else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+            GlockFire(0.095f * (1 - m_flAccuracy), true);
+
+        else
+            GlockFire(0.3f * (1 - m_flAccuracy), true);
+    }
+    else
+    {
+        if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+            GlockFire(1.0f * (1 - m_flAccuracy), false);
+
+        else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+            GlockFire(0.165f * (1 - m_flAccuracy), false);
+
+        else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+            GlockFire(0.075f * (1 - m_flAccuracy), false);
+
+        else
+            GlockFire(0.1f * (1 - m_flAccuracy), false);
+    }
+}
+
+
+// GOOSEMAN : FireRemaining used by Glock18
+void CWeaponGlock::FireRemaining(int &shotsFired, float &shootTime)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        Error("!pPlayer");
+
+    float nexttime = 0.1;
+    m_iClip1--;
+    if (m_iClip1 < 0)
+    {
+        m_iClip1 = 0;
+        shotsFired = 3;
+        shootTime = 0.0f;
+        return;
+    }
+
+    // TODO FIXME damage = 18, rangemode 0.9
+
+    // Dispatch the FX right away with full accuracy.
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Secondary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+        0.05);
+
+    /*
+    #if defined( CLIENT_WEAPONS )
+    int flag = FEV_NOTHOST;
+    #else
+    int flag = 0;
+    #endif
+
+    PLAYBACK_EVENT_FULL( flag, m_pPlayer->edict(), m_usFireGlock18,
+    0.0, (float *)&g_vecZero, (float *)&g_vecZero,
+    vecDir.x,
+    vecDir.y,
+    m_pPlayer->pev->punchangle.x * 10000,
+    m_pPlayer->pev->punchangle.y * 10000,
+    m_iClip1 ? 0 : 1, 0 );
+    */
+
+    //pPlayer->pev->effects = (int)(m_pPlayer->pev->effects) | EF_MUZZLEFLASH;
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    shotsFired++;
+
+    if (shotsFired != 3)
+        shootTime = gpGlobals->curtime + nexttime;
+    else
+        shootTime = 0.0;
+}
+
+
+void CWeaponGlock::ItemPostFrame()
+{
+    if (m_flGlock18Shoot != 0.0)
+        FireRemaining(m_iGlock18ShotsFired, m_flGlock18Shoot);
+
+    BaseClass::ItemPostFrame();
+}
+
+
+void CWeaponGlock::GlockFire(float flSpread, bool bFireBurst)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+    if (bFireBurst)
+    {
+        m_iGlock18ShotsFired = 0;
+        flCycleTime = 0.5f;
+    }
+    else
+    {
+        pPlayer->m_iShotsFired++;
+
+        if (pPlayer->m_iShotsFired > 1)
+            return;
+    }
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.275)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.9)
+        m_flAccuracy = 0.9;
+    else if (m_flAccuracy < 0.6)
+        m_flAccuracy = 0.6;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_iClip1--;
+
+    pPlayer->DoMuzzleFlash();
+
+    //SetPlayerShieldAnim();
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    // non-silenced
+    //pPlayer->m_iWeaponVolume = NORMAL_GUN_VOLUME;
+    //pPlayer->m_iWeaponFlash = NORMAL_GUN_FLASH;
+
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+        flSpread);
+
+    m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 2.5);
+
+    if (bFireBurst)
+    {
+        // Fire off the next two rounds
+        m_flGlock18Shoot = gpGlobals->curtime + 0.1;
+        m_iGlock18ShotsFired++;
+
+        SendWeaponAnim(ACT_VM_SECONDARYATTACK);
+    }
+    else
+    {
+        SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+    }
+
+    //ResetPlayerShieldAnim();
+}
+
+
+bool CWeaponGlock::Reload()
+{
+    if (m_flGlock18Shoot != 0)
+        return true;
+
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.9;
+    return true;
+}
+
+void CWeaponGlock::WeaponIdle()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        SendWeaponAnim(ACT_VM_IDLE);
+    }
+}
+
+
+//P228
+class CWeaponP228 : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponP228, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponP228();
+
+    virtual void Spawn();
+
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+
+    virtual bool Reload();
+    virtual void WeaponIdle();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_P228; }
+
+
+private:
+
+    CWeaponP228(const CWeaponP228 &);
+    void P228Fire(float flSpread);
+
+    float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponP228, DT_WeaponP228)
+
+BEGIN_NETWORK_TABLE(CWeaponP228, DT_WeaponP228)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponP228)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_p228, CWeaponP228);
+PRECACHE_WEAPON_REGISTER(weapon_p228);
+
+
+
+CWeaponP228::CWeaponP228()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CWeaponP228::Spawn()
+{
+    m_flAccuracy = 0.9;
+
+    BaseClass::Spawn();
+}
+
+
+bool CWeaponP228::Deploy()
+{
+    m_flAccuracy = 0.9;
+
+    return BaseClass::Deploy();
+}
+
+void CWeaponP228::PrimaryAttack(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        P228Fire(1.5f * (1 - m_flAccuracy));
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        P228Fire(0.255f * (1 - m_flAccuracy));
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        P228Fire(0.075f * (1 - m_flAccuracy));
+    else
+        P228Fire(0.15f * (1 - m_flAccuracy));
+}
+
+void CWeaponP228::P228Fire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    pPlayer->m_iShotsFired++;
+
+    if (pPlayer->m_iShotsFired > 1)
+        return;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.3)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.9)
+        m_flAccuracy = 0.9;
+    else if (m_flAccuracy < 0.6)
+        m_flAccuracy = 0.6;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_iClip1--;
+
+    pPlayer->DoMuzzleFlash();
+    //SetPlayerShieldAnim();
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    // Aiming
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        flSpread);
+
+    m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 2);
+
+    //ResetPlayerShieldAnim();
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= 2;
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponP228::Reload()
+{
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.9;
+    return true;
+}
+
+void CWeaponP228::WeaponIdle()
+{
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        SetWeaponIdleTime(gpGlobals->curtime + 3.0);
+        SendWeaponAnim(ACT_VM_IDLE);
+    }
+}
+
+
+//USP
+class CWeaponUSP : public CWeaponCSBase
+{
+public:
+    DECLARE_CLASS(CWeaponUSP, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponUSP();
+
+    virtual void Spawn();
+    virtual void Precache();
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+    virtual bool Deploy();
+    virtual bool Holster(CBaseCombatWeapon *pSwitchingTo);
+
+    virtual bool Reload();
+    virtual void WeaponIdle();
+
+    // We overload this so we can translate all weapon activities to silenced versions.
+    virtual bool SendWeaponAnim(int iActivity);
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_USP; }
+
+    // return true if this weapon has a silencer equipped
+    virtual bool IsSilenced(void) const { return m_bSilencerOn; }
+
+    virtual Activity GetDeployActivity(void);
+
+#ifdef CLIENT_DLL
+    virtual int GetMuzzleFlashStyle(void);
+#endif
+
+    virtual const char		*GetWorldModel(void) const;
+    virtual int				GetWorldModelIndex(void);
+
+private:
+
+    CWeaponUSP(const CWeaponUSP &);
+    void USPFire(float flSpread);
+
+    CNetworkVar(bool, m_bSilencerOn);
+    CNetworkVar(float, m_flDoneSwitchingSilencer);	// soonest time switching the silencer will be complete
+    float m_flLastFire;
+
+    int m_silencedModelIndex;
+    bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponUSP, DT_WeaponUSP)
+
+BEGIN_NETWORK_TABLE(CWeaponUSP, DT_WeaponUSP)
+#ifdef CLIENT_DLL
+RecvPropBool(RECVINFO(m_bSilencerOn)),
+RecvPropTime(RECVINFO(m_flDoneSwitchingSilencer)),
+#else
+SendPropBool(SENDINFO(m_bSilencerOn)),
+SendPropTime(SENDINFO(m_flDoneSwitchingSilencer)),
+#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA(CWeaponUSP)
+DEFINE_PRED_FIELD(m_bSilencerOn, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE)
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS(weapon_usp, CWeaponUSP);
+PRECACHE_WEAPON_REGISTER(weapon_usp);
+
+
+Activity g_SilencedTranslations[][2] =
+{
+    { ACT_VM_RELOAD, ACT_VM_RELOAD_SILENCED },
+    { ACT_VM_PRIMARYATTACK, ACT_VM_PRIMARYATTACK_SILENCED },
+    { ACT_VM_DRAW, ACT_VM_DRAW_SILENCED },
+};
+
+
+
+CWeaponUSP::CWeaponUSP()
+{
+    m_flLastFire = gpGlobals->curtime;
+    m_bSilencerOn = false;
+    m_flDoneSwitchingSilencer = 0.0f;
+    m_inPrecache = false;
+}
+
+
+void CWeaponUSP::Spawn()
+{
+    //m_iDefaultAmmo = 12;
+    m_flAccuracy = 0.92;
+    m_bSilencerOn = false;
+    m_flDoneSwitchingSilencer = 0.0f;
+
+    //FallInit();// get ready to fall down.
+    BaseClass::Spawn();
+}
+
+
+void CWeaponUSP::Precache()
+{
+    m_inPrecache = true;
+    BaseClass::Precache();
+
+    m_silencedModelIndex = CBaseEntity::PrecacheModel(GetCSWpnData().m_szSilencerModel);
+    m_inPrecache = false;
+}
+
+
+int CWeaponUSP::GetWorldModelIndex(void)
+{
+    if (!m_bSilencerOn || m_inPrecache)
+    {
+        return m_iWorldModelIndex;
+    }
+    else
+    {
+        return m_silencedModelIndex;
+    }
+}
+
+
+const char * CWeaponUSP::GetWorldModel(void) const
+{
+    if (!m_bSilencerOn || m_inPrecache)
+    {
+        return BaseClass::GetWorldModel();
+    }
+    else
+    {
+        return GetCSWpnData().m_szSilencerModel;
+    }
+}
+
+
+bool CWeaponUSP::Deploy()
+{
+    m_flAccuracy = 0.92;
+    m_flDoneSwitchingSilencer = 0.0f;
+
+    return BaseClass::Deploy();
+}
+
+bool CWeaponUSP::Holster(CBaseCombatWeapon *pSwitchingTo)
+{
+    if (m_flDoneSwitchingSilencer > 0.0f && m_flDoneSwitchingSilencer > gpGlobals->curtime)
+    {
+        // still switching the silencer.  Cancel the switch.
+        m_bSilencerOn = !m_bSilencerOn;
+        SetWeaponModelIndex(GetWorldModel());
+    }
+
+    return BaseClass::Holster(pSwitchingTo);
+}
+
+Activity CWeaponUSP::GetDeployActivity(void)
+{
+    if (IsSilenced())
+    {
+        return ACT_VM_DRAW_SILENCED;
+    }
+    else
+    {
+        return ACT_VM_DRAW;
+    }
+}
+
+void CWeaponUSP::SecondaryAttack()
+{
+    if (m_bSilencerOn)
+    {
+        SendWeaponAnim(ACT_VM_DETACH_SILENCER);
+    }
+    else
+    {
+        SendWeaponAnim(ACT_VM_ATTACH_SILENCER);
+    }
+    m_bSilencerOn = !m_bSilencerOn;
+    m_flDoneSwitchingSilencer = gpGlobals->curtime + 3;
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 3;
+    m_flNextPrimaryAttack = gpGlobals->curtime + 3;
+    SetWeaponIdleTime(gpGlobals->curtime + 3);
+
+    SetWeaponModelIndex(GetWorldModel());
+}
+
+
+void CWeaponUSP::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_bSilencerOn)
+    {
+        if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+            USPFire(1.3f * (1 - m_flAccuracy));
+        else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+            USPFire(0.25f * (1 - m_flAccuracy));
+        else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+            USPFire(0.125f * (1 - m_flAccuracy));
+        else
+            USPFire(0.15f * (1 - m_flAccuracy));
+    }
+    else
+    {
+        if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+            USPFire(1.2f * (1 - m_flAccuracy));
+        else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+            USPFire(0.225f * (1 - m_flAccuracy));
+        else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+            USPFire(0.08f * (1 - m_flAccuracy));
+        else
+            USPFire(0.1f * (1 - m_flAccuracy));
+    }
+
+}
+
+void CWeaponUSP::USPFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+    pPlayer->m_iShotsFired++;
+
+    if (pPlayer->m_iShotsFired > 1)
+        return;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy -= (0.275)*(0.3 - (gpGlobals->curtime - m_flLastFire));
+
+    if (m_flAccuracy > 0.92)
+        m_flAccuracy = 0.92;
+    else if (m_flAccuracy < 0.6)
+        m_flAccuracy = 0.6;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (m_iClip1 <= 0)
+    {
+        if (m_bFireOnEmpty)
+        {
+            PlayEmptySound();
+            m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+        }
+
+        return;
+    }
+
+    m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
+
+    m_iClip1--;
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+
+    // player "shoot" animation
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+
+    if (!m_bSilencerOn)
+    {
+        pPlayer->DoMuzzleFlash();
+    }
+
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        m_bSilencerOn ? Secondary_Mode : Primary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        flSpread);
+
+    if (!m_iClip1 && pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0)
+    {
+        // HEV suit - indicate out of ammo condition
+        pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+    }
+
+    SetWeaponIdleTime(gpGlobals->curtime + 2);
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= 2;
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponUSP::Reload()
+{
+    if (!DefaultPistolReload())
+        return false;
+
+    m_flAccuracy = 0.92;
+    return true;
+}
+
+void CWeaponUSP::WeaponIdle()
+{
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        SetWeaponIdleTime(gpGlobals->curtime + 6.0);
+    }
+}
+
+bool CWeaponUSP::SendWeaponAnim(int iActivity)
+{
+    // Translate the activity?
+    if (m_bSilencerOn)
+    {
+        for (int i = 0; i < ARRAYSIZE(g_SilencedTranslations); i++)
+        {
+            if (g_SilencedTranslations[i][0] == iActivity)
+            {
+                iActivity = g_SilencedTranslations[i][1];
+                break;
+            }
+        }
+    }
+
+    return BaseClass::SendWeaponAnim(iActivity);
+}
+
+
+#ifdef CLIENT_DLL
+int CWeaponUSP::GetMuzzleFlashStyle(void)
+{
+    if (m_bSilencerOn)
+    {
+        return CS_MUZZLEFLASH_NONE;
+    }
+    else
+    {
+        return CS_MUZZLEFLASH_NORM;
+    }
+}
+#endif
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_cs_rifles.cpp b/mp/src/game/shared/momentum/weapon_cs_rifles.cpp
new file mode 100644
index 000000000..e05b562e6
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_cs_rifles.cpp
@@ -0,0 +1,1665 @@
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "mom_player_shared.h"
+#include "fx_cs_shared.h"
+
+#ifdef CLIENT_DLL
+#define CAK47 C_AK47
+#define CWeaponAug C_WeaponAug
+#define CWeaponAWP C_WeaponAWP
+#define CWeaponFamas C_WeaponFamas
+#define CWeaponG3SG1 C_WeaponG3SG1
+#define CWeaponGalil C_WeaponGalil
+#define CWeaponM4A1 C_WeaponM4A1
+#define CWeaponScout C_WeaponScout
+#define CWeaponSG550 C_WeaponSG550
+#define CWeaponSG552 C_WeaponSG552
+#else
+#include "KeyValues.h"
+#endif
+
+#include "tier0/memdbgon.h"
+
+
+/*****************
+AK47
+*****************/
+class CAK47 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CAK47, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CAK47();
+
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_AK47; }
+
+private:
+
+    void AK47Fire(float flSpread);
+
+    CAK47(const CAK47 &);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(AK47, DT_WeaponAK47)
+
+BEGIN_NETWORK_TABLE(CAK47, DT_WeaponAK47)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CAK47)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_ak47, CAK47);
+PRECACHE_WEAPON_REGISTER(weapon_ak47);
+
+// ---------------------------------------------------------------------------- //
+// CAK47 implementation.
+// ---------------------------------------------------------------------------- //
+
+CAK47::CAK47()
+{
+}
+
+void CAK47::AK47Fire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1.5, 0.45, 0.225, 0.05, 6.5, 2.5, 7);
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(2, 1.0, 0.5, 0.35, 9, 6, 5);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.9, 0.35, 0.15, 0.025, 5.5, 1.5, 9);
+    else
+        pPlayer->KickBack(1, 0.375, 0.175, 0.0375, 5.75, 1.75, 8);
+}
+
+
+void CAK47::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        AK47Fire(0.04f + 0.4f * m_flAccuracy);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        AK47Fire(0.04f + 0.07f * m_flAccuracy);
+    else
+        AK47Fire(0.0275f * m_flAccuracy);
+}
+
+
+
+
+/*
+AUG
+*/
+class CWeaponAug : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponAug, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponAug();
+
+    virtual void SecondaryAttack();
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_AUG; }
+
+#ifdef CLIENT_DLL
+    virtual bool	HideViewModelWhenZoomed(void) { return false; }
+#endif
+
+private:
+
+    void AUGFire(float flSpread, bool bZoomed);
+
+    CWeaponAug(const CWeaponAug &);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponAug, DT_WeaponAug)
+
+BEGIN_NETWORK_TABLE(CWeaponAug, DT_WeaponAug)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponAug)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_aug, CWeaponAug);
+PRECACHE_WEAPON_REGISTER(weapon_aug);
+
+
+
+CWeaponAug::CWeaponAug()
+{
+}
+
+void CWeaponAug::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 55, 0.2f);
+    }
+    else if (pPlayer->GetFOV() == 55)
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.15f);
+    }
+    else
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV());
+    }
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+
+void CWeaponAug::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    bool bZoomed = pPlayer->GetFOV() < pPlayer->GetDefaultFOV();
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        AUGFire(0.035f + 0.4f * m_flAccuracy, bZoomed);
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        AUGFire(0.035f + 0.07f * m_flAccuracy, bZoomed);
+    else
+        AUGFire(0.02f * m_flAccuracy, bZoomed);
+}
+
+
+void CWeaponAug::AUGFire(float flSpread, bool bZoomed)
+{
+    float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+    if (bZoomed)
+        flCycleTime = 0.135f;
+
+    if (!CSBaseGunFire(flSpread, flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1, 0.45, 0.275, 0.05, 4, 2.5, 7);
+
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.25, 0.45, 0.22, 0.18, 5.5, 4, 5);
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.575, 0.325, 0.2, 0.011, 3.25, 2, 8);
+
+    else
+        pPlayer->KickBack(0.625, 0.375, 0.25, 0.0125, 3.5, 2.25, 8);
+}
+
+
+
+
+/*
+AWP
+*/
+#define SNIPER_ZOOM_CONTEXT		"SniperRifleThink"
+class CWeaponAWP : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponAWP, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+#ifndef CLIENT_DLL
+    DECLARE_DATADESC();
+#endif
+
+    CWeaponAWP();
+
+    virtual void Spawn();
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+
+    virtual void AWPFire(float flSpread);
+
+    virtual float GetMaxSpeed() const;
+    virtual bool IsAwp() const;
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_AWP; }
+
+private:
+
+#ifndef CLIENT_DLL
+    void				UnzoomThink(void);
+#endif
+
+    CWeaponAWP(const CWeaponAWP &);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponAWP, DT_WeaponAWP)
+
+BEGIN_NETWORK_TABLE(CWeaponAWP, DT_WeaponAWP)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponAWP)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_awp, CWeaponAWP);
+PRECACHE_WEAPON_REGISTER(weapon_awp);
+
+#ifndef CLIENT_DLL
+
+BEGIN_DATADESC(CWeaponAWP)
+DEFINE_THINKFUNC(UnzoomThink),
+END_DATADESC()
+
+#endif
+
+CWeaponAWP::CWeaponAWP()
+{
+}
+
+void CWeaponAWP::Spawn()
+{
+    Precache();
+
+    BaseClass::Spawn();
+}
+
+
+void CWeaponAWP::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 40, 0.15f);
+    }
+    else if (pPlayer->GetFOV() == 40)
+    {
+        pPlayer->SetFOV(pPlayer, 10, 0.08f);
+    }
+    else
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.1f);
+    }
+
+    //pPlayer->ResetMaxSpeed();
+
+#endif
+
+#ifndef CLIENT_DLL
+    // If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+    // Let the server play it since if only the client plays it, it's liable to get played twice cause of
+    // a prediction error. joy.
+    EmitSound("Default.Zoom");
+
+    // let the bots hear the rifle zoom
+    IGameEvent * event = gameeventmanager->CreateEvent("weapon_zoom");
+    if (event)
+    {
+        event->SetInt("userid", pPlayer->GetUserID());
+        gameeventmanager->FireEvent(event);
+    }
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+    m_zoomFullyActiveTime = gpGlobals->curtime + 0.15; // The worst zoom time from above.  
+
+}
+
+
+void CWeaponAWP::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        AWPFire(0.85);
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        AWPFire(0.25);
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 10)
+        AWPFire(0.10);
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        AWPFire(0.0);
+
+    else
+        AWPFire(0.001);
+}
+
+void CWeaponAWP::AWPFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    // If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+    {
+        flSpread += 0.08;
+    }
+
+    if (pPlayer->GetFOV() != pPlayer->GetDefaultFOV())
+    {
+        pPlayer->m_iLastZoom = pPlayer->GetFOV();
+
+#ifndef CLIENT_DLL
+#ifdef AWP_UNZOOM
+        SetContextThink(&CWeaponAWP::UnzoomThink, gpGlobals->curtime + sv_awpunzoomdelay.GetFloat(), SNIPER_ZOOM_CONTEXT);
+#else
+        pPlayer->m_bResumeZoom = true;
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.1f);
+#endif
+#endif
+    }
+
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= 2;
+    pPlayer->SetPunchAngle(angle);
+}
+
+#ifndef CLIENT_DLL
+void CWeaponAWP::UnzoomThink(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.1f);
+}
+#endif
+
+
+float CWeaponAWP::GetMaxSpeed() const
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return BaseClass::GetMaxSpeed();
+    }
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        return BaseClass::GetMaxSpeed();
+    }
+    else
+    {
+        // Slower speed when zoomed in.
+        return 150;
+    }
+}
+
+
+bool CWeaponAWP::IsAwp() const
+{
+    return true;
+}
+
+
+
+/*
+FAMAS
+*/
+class CWeaponFamas : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponFamas, CWeaponCSBase);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponFamas();
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+
+    virtual void ItemPostFrame();
+
+    void FamasFire(float flSpread, bool bFireBurst);
+    void FireRemaining(int &shotsFired, float &shootTime);
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_FAMAS; }
+
+private:
+
+    CWeaponFamas(const CWeaponFamas &);
+    CNetworkVar(bool, m_bBurstMode);
+    float	m_flFamasShoot;			// time to shoot the remaining bullets of the famas burst fire
+    int		m_iFamasShotsFired;		// used to keep track of the shots fired during the Famas burst fire mode....
+    float	m_fBurstSpread;			// used to keep track of current spread factor so that all bullets in spread use same spread
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponFamas, DT_WeaponFamas)
+
+BEGIN_NETWORK_TABLE(CWeaponFamas, DT_WeaponFamas)
+#ifdef CLIENT_DLL
+RecvPropBool(RECVINFO(m_bBurstMode))
+#else
+SendPropBool(SENDINFO(m_bBurstMode))
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponFamas)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_famas, CWeaponFamas);
+PRECACHE_WEAPON_REGISTER(weapon_famas);
+
+
+
+CWeaponFamas::CWeaponFamas()
+{
+    m_bBurstMode = false;
+}
+
+// Secondary attack could be three-round burst mode
+void CWeaponFamas::SecondaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (m_bBurstMode)
+    {
+        ClientPrint(pPlayer, HUD_PRINTCENTER, "#Switch_To_FullAuto");
+        m_bBurstMode = false;
+    }
+    else
+    {
+        ClientPrint(pPlayer, HUD_PRINTCENTER, "#Switch_To_BurstFire");
+        m_bBurstMode = true;
+    }
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+void CWeaponFamas::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // don't fire underwater
+    if (pPlayer->GetWaterLevel() == 3)
+    {
+        PlayEmptySound();
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+        return;
+    }
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))	// if player is in air
+        FamasFire(0.03f + 0.3f * m_flAccuracy, m_bBurstMode);
+
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)	// if player is moving
+        FamasFire(0.03f + 0.07f * m_flAccuracy, m_bBurstMode);
+    /* new code */
+    else
+        FamasFire(0.02f * m_flAccuracy, m_bBurstMode);
+}
+
+
+// GOOSEMAN : FireRemaining used by Glock18
+void CWeaponFamas::FireRemaining(int &shotsFired, float &shootTime)
+{
+    float nexttime = 0.1;
+
+    m_iClip1--;
+
+    if (m_iClip1 < 0)
+    {
+        m_iClip1 = 0;
+        shotsFired = 3;
+        shootTime = 0.0f;
+        return;
+    }
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        Error("!pPlayer");
+
+    // Famas burst mode
+    FX_FireBullets(
+        pPlayer->entindex(),
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        GetWeaponID(),
+        Secondary_Mode,
+        CBaseEntity::GetPredictionRandomSeed() & 255,
+        m_fBurstSpread);
+
+
+    SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+
+    pPlayer->DoMuzzleFlash();
+    pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+    shotsFired++;
+
+    if (shotsFired != 3)
+        shootTime = gpGlobals->curtime + nexttime;
+    else
+        shootTime = 0.0;
+}
+
+
+void CWeaponFamas::ItemPostFrame()
+{
+    if (m_flFamasShoot != 0.0 && m_flFamasShoot < gpGlobals->curtime)
+        FireRemaining(m_iFamasShotsFired, m_flFamasShoot);
+
+    BaseClass::ItemPostFrame();
+}
+
+
+void CWeaponFamas::FamasFire(float flSpread, bool bFireBurst)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+    // change a few things if we're in burst mode
+    if (bFireBurst)
+    {
+        m_iFamasShotsFired = 0;
+        flCycleTime = 0.55f;
+    }
+    else
+    {
+        flSpread += 0.01;
+    }
+
+    if (!CSBaseGunFire(flSpread, flCycleTime, true))
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1, 0.45, 0.275, 0.05, 4, 2.5, 7);
+
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.25, 0.45, 0.22, 0.18, 5.5, 4, 5);
+
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.575, 0.325, 0.2, 0.011, 3.25, 2, 8);
+
+    else
+        pPlayer->KickBack(0.625, 0.375, 0.25, 0.0125, 3.5, 2.25, 8);
+
+    if (bFireBurst)
+    {
+        // Fire off the next two rounds
+        m_flFamasShoot = gpGlobals->curtime + 0.05;	// 0.1
+        m_fBurstSpread = flSpread;
+        m_iFamasShotsFired++;
+    }
+}
+
+
+/*
+G3SG1
+*/
+class CWeaponG3SG1 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponG3SG1, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponG3SG1();
+
+    virtual void Spawn();
+    virtual void SecondaryAttack();
+    virtual void PrimaryAttack();
+    virtual bool Reload();
+    virtual bool Deploy();
+
+    virtual float GetMaxSpeed();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_G3SG1; }
+
+private:
+
+    CWeaponG3SG1(const CWeaponG3SG1 &);
+
+    void G3SG1Fire(float flSpread);
+
+
+    float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponG3SG1, DT_WeaponG3SG1)
+
+BEGIN_NETWORK_TABLE(CWeaponG3SG1, DT_WeaponG3SG1)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponG3SG1)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_g3sg1, CWeaponG3SG1);
+PRECACHE_WEAPON_REGISTER(weapon_g3sg1);
+
+
+
+CWeaponG3SG1::CWeaponG3SG1()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+void CWeaponG3SG1::Spawn()
+{
+    BaseClass::Spawn();
+    m_flAccuracy = 0.98;
+}
+
+
+void CWeaponG3SG1::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 40, 0.3f);
+    }
+    else if (pPlayer->GetFOV() == 40)
+    {
+        pPlayer->SetFOV(pPlayer, 15, 0.05);
+    }
+    else if (pPlayer->GetFOV() == 15)
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.1f);
+    }
+
+    //pPlayer->ResetMaxSpeed();
+#endif
+
+#ifndef CLIENT_DLL
+    // If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+    // Let the server play it since if only the client plays it, it's liable to get played twice cause of
+    // a prediction error. joy.
+    EmitSound("Default.Zoom"); // zoom sound
+
+    // let the bots hear the rifle zoom
+    IGameEvent * event = gameeventmanager->CreateEvent("weapon_zoom");
+    if (event)
+    {
+        event->SetInt("userid", pPlayer->GetUserID());
+        gameeventmanager->FireEvent(event);
+    }
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+    m_zoomFullyActiveTime = gpGlobals->curtime + 0.3; // The worst zoom time from above.  
+}
+
+void CWeaponG3SG1::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        G3SG1Fire(0.45 * (1 - m_flAccuracy));
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        G3SG1Fire(0.15);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        G3SG1Fire(0.035 * (1 - m_flAccuracy));
+    else
+        G3SG1Fire(0.055 * (1 - m_flAccuracy));
+}
+
+void CWeaponG3SG1::G3SG1Fire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+        flSpread += 0.025;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy = 0.55 + (0.3) * (gpGlobals->curtime - m_flLastFire);
+
+    if (m_flAccuracy > 0.98)
+        m_flAccuracy = 0.98;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    // Adjust the punch angle.
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= SharedRandomFloat("G3SG1PunchAngleX", 0.75, 1.75) + (angle.x / 4);
+    angle.y += SharedRandomFloat("G3SG1PunchAngleY", -0.75, 0.75);
+    pPlayer->SetPunchAngle(angle);
+}
+
+
+bool CWeaponG3SG1::Reload()
+{
+    bool ret = BaseClass::Reload();
+
+    m_flAccuracy = 0.98;
+
+    return ret;
+}
+
+bool CWeaponG3SG1::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flAccuracy = 0.98;
+
+    return ret;
+}
+
+float CWeaponG3SG1::GetMaxSpeed()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (pPlayer && pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+        return BaseClass::GetMaxSpeed();
+    else
+        return 150; // zoomed in
+}
+
+
+/*
+GALIL
+*/
+class CWeaponGalil : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponGalil, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponGalil();
+
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_GALIL; }
+
+private:
+
+    CWeaponGalil(const CWeaponGalil &);
+
+    void GalilFire(float flSpread);
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponGalil, DT_WeaponGalil)
+
+BEGIN_NETWORK_TABLE(CWeaponGalil, DT_WeaponGalil)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponGalil)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_galil, CWeaponGalil);
+PRECACHE_WEAPON_REGISTER(weapon_galil);
+
+
+
+CWeaponGalil::CWeaponGalil()
+{
+}
+
+
+void CWeaponGalil::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // don't fire underwater
+    if (pPlayer->GetWaterLevel() == 3)
+    {
+        PlayEmptySound();
+        m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+        return;
+    }
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        GalilFire(0.04f + 0.3f * m_flAccuracy);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        GalilFire(0.04f + 0.07f * m_flAccuracy);
+    else
+        GalilFire(0.0375f * m_flAccuracy);
+}
+
+void CWeaponGalil::GalilFire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1.0, 0.45, 0.28, 0.045, 3.75, 3, 7);
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.2, 0.5, 0.23, 0.15, 5.5, 3.5, 6);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.6, 0.3, 0.2, 0.0125, 3.25, 2, 7);
+    else
+        pPlayer->KickBack(0.65, 0.35, 0.25, 0.015, 3.5, 2.25, 7);
+}
+
+
+
+/*
+M4A1
+*/
+class CWeaponM4A1 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponM4A1, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponM4A1();
+
+    virtual void Spawn();
+    virtual void Precache();
+
+    virtual void SecondaryAttack();
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+    virtual bool Reload();
+    virtual void WeaponIdle();
+    virtual bool Holster(CBaseCombatWeapon *pSwitchingTo);
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_M4A1; }
+
+    // return true if this weapon has a silencer equipped
+    virtual bool IsSilenced(void) const { return m_bSilencerOn; }
+
+    virtual Activity GetDeployActivity(void);
+
+#ifdef CLIENT_DLL
+    virtual int GetMuzzleFlashStyle(void);
+#endif
+
+    virtual const char		*GetWorldModel(void) const;
+    virtual int				GetWorldModelIndex(void);
+
+private:
+
+    CWeaponM4A1(const CWeaponM4A1 &);
+
+    void M4A1Fire(float flSpread);
+    void DoFireEffects();
+
+    CNetworkVar(bool, m_bSilencerOn);
+    CNetworkVar(float, m_flDoneSwitchingSilencer);	// soonest time switching the silencer will be complete
+
+    int m_silencedModelIndex;
+    bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponM4A1, DT_WeaponM4A1)
+
+BEGIN_NETWORK_TABLE(CWeaponM4A1, DT_WeaponM4A1)
+#ifdef CLIENT_DLL
+RecvPropBool(RECVINFO(m_bSilencerOn)),
+RecvPropTime(RECVINFO(m_flDoneSwitchingSilencer)),
+#else
+SendPropBool(SENDINFO(m_bSilencerOn)),
+SendPropTime(SENDINFO(m_flDoneSwitchingSilencer)),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponM4A1)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_m4a1, CWeaponM4A1);
+PRECACHE_WEAPON_REGISTER(weapon_m4a1);
+
+
+
+CWeaponM4A1::CWeaponM4A1()
+{
+    m_bSilencerOn = false;
+    m_flDoneSwitchingSilencer = 0.0f;
+    m_inPrecache = false;
+}
+
+
+void CWeaponM4A1::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_bSilencerOn = false;
+    m_flDoneSwitchingSilencer = 0.0f;
+    m_bDelayFire = true;
+}
+
+
+void CWeaponM4A1::Precache()
+{
+    m_inPrecache = true;
+    BaseClass::Precache();
+
+    m_silencedModelIndex = CBaseEntity::PrecacheModel(GetCSWpnData().m_szSilencerModel);
+    m_inPrecache = false;
+}
+
+
+int CWeaponM4A1::GetWorldModelIndex(void)
+{
+    if (!m_bSilencerOn || m_inPrecache)
+    {
+        return m_iWorldModelIndex;
+    }
+    else
+    {
+        return m_silencedModelIndex;
+    }
+}
+
+
+const char * CWeaponM4A1::GetWorldModel(void) const
+{
+    if (!m_bSilencerOn || m_inPrecache)
+    {
+        return BaseClass::GetWorldModel();
+    }
+    else
+    {
+        return GetCSWpnData().m_szSilencerModel;
+    }
+}
+
+
+bool CWeaponM4A1::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flDoneSwitchingSilencer = 0.0f;
+    m_bDelayFire = true;
+
+    return ret;
+}
+
+Activity CWeaponM4A1::GetDeployActivity(void)
+{
+    if (IsSilenced())
+    {
+        return ACT_VM_DRAW_SILENCED;
+    }
+    else
+    {
+        return ACT_VM_DRAW;
+    }
+}
+
+bool CWeaponM4A1::Holster(CBaseCombatWeapon *pSwitchingTo)
+{
+    if (m_flDoneSwitchingSilencer > 0.0f && m_flDoneSwitchingSilencer > gpGlobals->curtime)
+    {
+        // still switching the silencer.  Cancel the switch.
+        m_bSilencerOn = !m_bSilencerOn;
+        SetWeaponModelIndex(GetWorldModel());
+    }
+
+    return BaseClass::Holster(pSwitchingTo);
+}
+
+void CWeaponM4A1::SecondaryAttack()
+{
+    if (m_bSilencerOn)
+    {
+        m_bSilencerOn = false;
+        SendWeaponAnim(ACT_VM_DETACH_SILENCER);
+    }
+    else
+    {
+        m_bSilencerOn = true;
+        SendWeaponAnim(ACT_VM_ATTACH_SILENCER);
+    }
+    m_flDoneSwitchingSilencer = gpGlobals->curtime + 2;
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 2;
+    m_flNextPrimaryAttack = gpGlobals->curtime + 2;
+    SetWeaponIdleTime(gpGlobals->curtime + 2);
+
+    SetWeaponModelIndex(GetWorldModel());
+}
+
+void CWeaponM4A1::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+    {
+        M4A1Fire(0.035f + 0.4f * m_flAccuracy);
+    }
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+    {
+        M4A1Fire(0.035f + 0.07f * m_flAccuracy);
+    }
+    else
+    {
+        if (m_bSilencerOn)
+            M4A1Fire(0.025f * m_flAccuracy);
+        else
+            M4A1Fire(0.02f * m_flAccuracy);
+    }
+}
+
+
+void CWeaponM4A1::M4A1Fire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, !m_bSilencerOn))
+        return;
+
+    if (m_bSilencerOn)
+        SendWeaponAnim(ACT_VM_PRIMARYATTACK_SILENCED);
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1.0, 0.45, 0.28, 0.045, 3.75, 3, 7);
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.2, 0.5, 0.23, 0.15, 5.5, 3.5, 6);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.6, 0.3, 0.2, 0.0125, 3.25, 2, 7);
+    else
+        pPlayer->KickBack(0.65, 0.35, 0.25, 0.015, 3.5, 2.25, 7);
+}
+
+
+void CWeaponM4A1::DoFireEffects()
+{
+    if (!m_bSilencerOn)
+    {
+        CMomentumPlayer *pPlayer = GetPlayerOwner();
+        if (pPlayer)
+        {
+            pPlayer->DoMuzzleFlash();
+        }
+    }
+}
+
+bool CWeaponM4A1::Reload()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0)
+        return false;
+
+    int iResult = 0;
+
+    if (m_bSilencerOn)
+        iResult = DefaultReload(GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD_SILENCED);
+    else
+        iResult = DefaultReload(GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD);
+
+    if (!iResult)
+        return false;
+
+    pPlayer->SetAnimation(PLAYER_RELOAD);
+
+#ifndef CLIENT_DLL
+    if ((iResult) && (pPlayer->GetFOV() != pPlayer->GetDefaultFOV()))
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV());
+    }
+#endif
+
+    m_flAccuracy = 0.2;
+    pPlayer->m_iShotsFired = 0;
+    m_bDelayFire = false;
+    return true;
+}
+
+
+void CWeaponM4A1::WeaponIdle()
+{
+    if (m_flTimeWeaponIdle > gpGlobals->curtime)
+        return;
+
+    // only idle if the slid isn't back
+    if (m_iClip1 != 0)
+    {
+        SetWeaponIdleTime(gpGlobals->curtime + GetCSWpnData().m_flIdleInterval);
+        if (m_bSilencerOn)
+            SendWeaponAnim(ACT_VM_IDLE_SILENCED);
+        else
+            SendWeaponAnim(ACT_VM_IDLE);
+    }
+}
+
+
+#ifdef CLIENT_DLL
+int CWeaponM4A1::GetMuzzleFlashStyle(void)
+{
+    if (m_bSilencerOn)
+    {
+        return CS_MUZZLEFLASH_NONE;
+    }
+    else
+    {
+        return CS_MUZZLEFLASH_X;
+    }
+}
+#endif
+
+
+//SCOUT
+class CWeaponScout : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponScout, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponScout();
+
+    virtual void PrimaryAttack();
+    virtual void SecondaryAttack();
+
+    virtual float GetMaxSpeed() const;
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_SCOUT; }
+
+
+private:
+
+    CWeaponScout(const CWeaponScout &);
+
+    void SCOUTFire(float flSpread);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponScout, DT_WeaponScout)
+
+BEGIN_NETWORK_TABLE(CWeaponScout, DT_WeaponScout)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponScout)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_scout, CWeaponScout);
+PRECACHE_WEAPON_REGISTER(weapon_scout);
+
+
+
+CWeaponScout::CWeaponScout()
+{
+}
+
+void CWeaponScout::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 40, 0.15f);
+    }
+    else if (pPlayer->GetFOV() == 40)
+    {
+        pPlayer->SetFOV(pPlayer, 15, 0.05);
+    }
+    else if (pPlayer->GetFOV() == 15)
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.05f);
+    }
+
+    //pPlayer->ResetMaxSpeed();
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+    m_zoomFullyActiveTime = gpGlobals->curtime + 0.15; // The worst zoom time from above.  
+
+#ifndef CLIENT_DLL
+    // If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+    // Let the server play it since if only the client plays it, it's liable to get played twice cause of
+    // a prediction error. joy.
+    EmitSound("Default.Zoom"); // zoom sound
+
+    // let the bots hear the rifle zoom
+    IGameEvent * event = gameeventmanager->CreateEvent("weapon_zoom");
+    if (event)
+    {
+        event->SetInt("userid", pPlayer->GetUserID());
+        gameeventmanager->FireEvent(event);
+    }
+#endif
+}
+
+void CWeaponScout::PrimaryAttack(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        SCOUTFire(0.2);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 170)
+        SCOUTFire(0.075);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        SCOUTFire(0.0);
+    else
+        SCOUTFire(0.007);
+}
+
+void CWeaponScout::SCOUTFire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return;
+    }
+
+    // If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+    {
+        flSpread += 0.025;
+    }
+
+    if (pPlayer->GetFOV() != pPlayer->GetDefaultFOV())
+    {
+        pPlayer->m_bResumeZoom = true;
+        pPlayer->m_iLastZoom = pPlayer->GetFOV();
+
+#ifndef CLIENT_DLL
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.05f);
+#endif
+    }
+
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= 2;
+    pPlayer->SetPunchAngle(angle);
+}
+
+//MOM_TODO: Consider LJ gametype
+float CWeaponScout::GetMaxSpeed() const
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (pPlayer == NULL)
+    {
+        Assert(pPlayer != NULL);
+        return BaseClass::GetMaxSpeed();
+    }
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+        return BaseClass::GetMaxSpeed();
+    else
+        return 220;	// zoomed in.
+}
+
+
+
+/*
+SG550
+*/
+class CWeaponSG550 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponSG550, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponSG550();
+
+    virtual void Spawn();
+    virtual void SecondaryAttack();
+    virtual void PrimaryAttack();
+    virtual bool Reload();
+    virtual bool Deploy();
+
+    virtual float GetMaxSpeed() const;
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_SG550; }
+
+
+private:
+
+    CWeaponSG550(const CWeaponSG550 &);
+
+    void SG550Fire(float flSpread);
+
+    float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponSG550, DT_WeaponSG550)
+
+BEGIN_NETWORK_TABLE(CWeaponSG550, DT_WeaponSG550)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponSG550)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_sg550, CWeaponSG550);
+PRECACHE_WEAPON_REGISTER(weapon_sg550);
+
+
+
+CWeaponSG550::CWeaponSG550()
+{
+    m_flLastFire = gpGlobals->curtime;
+}
+
+void CWeaponSG550::Spawn()
+{
+    BaseClass::Spawn();
+    m_flAccuracy = 0.98;
+}
+
+
+void CWeaponSG550::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 40, 0.3f);
+    }
+    else if (pPlayer->GetFOV() == 40)
+    {
+        pPlayer->SetFOV(pPlayer, 15, 0.05f);
+    }
+    else if (pPlayer->GetFOV() == 15)
+    {
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV(), 0.1f);
+    }
+
+    //pPlayer->ResetMaxSpeed();
+#endif
+
+#ifndef CLIENT_DLL
+    // If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+    // Let the server play it since if only the client plays it, it's liable to get played twice cause of
+    // a prediction error. joy.
+    EmitSound("Default.Zoom"); // zoom sound.
+
+    // let the bots hear the rifle zoom
+    IGameEvent * event = gameeventmanager->CreateEvent("weapon_zoom");
+    if (event)
+    {
+        event->SetInt("userid", pPlayer->GetUserID());
+        gameeventmanager->FireEvent(event);
+    }
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+    m_zoomFullyActiveTime = gpGlobals->curtime + 0.3; // The worst zoom time from above.  
+}
+
+void CWeaponSG550::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        SG550Fire(0.45f * (1 - m_flAccuracy));
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        SG550Fire(0.15f);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        SG550Fire(0.04f * (1 - m_flAccuracy));
+    else
+        SG550Fire(0.05f * (1 - m_flAccuracy));
+}
+
+void CWeaponSG550::SG550Fire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    // If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+        flSpread += 0.025;
+
+    // Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+    m_flAccuracy = 0.65 + (0.35) * (gpGlobals->curtime - m_flLastFire);
+
+    if (m_flAccuracy > 0.98)
+        m_flAccuracy = 0.98;
+
+    m_flLastFire = gpGlobals->curtime;
+
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    QAngle angle = pPlayer->GetPunchAngle();
+    angle.x -= SharedRandomFloat("SG550PunchAngleX", 0.75, 1.25) + (angle.x / 4);
+    angle.y += SharedRandomFloat("SG550PunchAngleY", -0.75, 0.75);
+    pPlayer->SetPunchAngle(angle);
+}
+
+bool CWeaponSG550::Reload()
+{
+    bool ret = BaseClass::Reload();
+
+    m_flAccuracy = 0.98;
+
+    return ret;
+}
+
+bool CWeaponSG550::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flAccuracy = 0.98;
+
+    return ret;
+}
+
+float CWeaponSG550::GetMaxSpeed() const
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (!pPlayer || pPlayer->GetFOV() == 90)
+        return BaseClass::GetMaxSpeed();
+    else
+        return 150; // zoomed in
+}
+
+
+/*
+SG552
+*/
+class CWeaponSG552 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponSG552, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponSG552();
+
+    virtual void SecondaryAttack();
+    virtual void PrimaryAttack();
+
+    virtual float GetMaxSpeed() const;
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_SG552; }
+
+#ifdef CLIENT_DLL
+    virtual bool	HideViewModelWhenZoomed(void) { return false; }
+#endif
+
+private:
+
+    CWeaponSG552(const CWeaponSG552 &);
+
+    void SG552Fire(float flSpread, bool bZoomed);
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponSG552, DT_WeaponSG552)
+
+BEGIN_NETWORK_TABLE(CWeaponSG552, DT_WeaponSG552)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponSG552)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_sg552, CWeaponSG552);
+PRECACHE_WEAPON_REGISTER(weapon_sg552);
+
+
+
+CWeaponSG552::CWeaponSG552()
+{
+}
+
+
+
+void CWeaponSG552::SecondaryAttack()
+{
+#ifndef CLIENT_DLL
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+    {
+        pPlayer->SetFOV(pPlayer, 55, 0.2f);
+    }
+    else if (pPlayer->GetFOV() == 55)
+    {
+        pPlayer->SetFOV(pPlayer, 0, 0.15f);
+    }
+    else
+    {
+        //FIXME: This seems wrong
+        pPlayer->SetFOV(pPlayer, pPlayer->GetDefaultFOV());
+    }
+#endif
+
+    m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+void CWeaponSG552::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    bool bZoomed = pPlayer->GetFOV() < pPlayer->GetDefaultFOV();
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        SG552Fire(0.035f + 0.45f * m_flAccuracy, bZoomed);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+        SG552Fire(0.035f + 0.075f * m_flAccuracy, bZoomed);
+    else
+        SG552Fire(0.02f * m_flAccuracy, bZoomed);
+}
+
+
+void CWeaponSG552::SG552Fire(float flSpread, bool bZoomed)
+{
+    float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+    if (bZoomed)
+        flCycleTime = 0.135f;
+
+    if (!CSBaseGunFire(flSpread, flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(1, 0.45, 0.28, 0.04, 4.25, 2.5, 7);
+    else if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.25, 0.45, 0.22, 0.18, 6, 4, 5);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.6, 0.35, 0.2, 0.0125, 3.7, 2, 10);
+    else
+        pPlayer->KickBack(0.625, 0.375, 0.25, 0.0125, 4, 2.25, 9);
+}
+
+
+float CWeaponSG552::GetMaxSpeed() const
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (!pPlayer || pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+        return BaseClass::GetMaxSpeed();
+    else
+        return 200; // zoomed in.
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_cs_smgs.cpp b/mp/src/game/shared/momentum/weapon_cs_smgs.cpp
new file mode 100644
index 000000000..2394ddd9c
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_cs_smgs.cpp
@@ -0,0 +1,478 @@
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "mom_player_shared.h"
+#include "tier0/memdbgon.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponMAC10 C_WeaponMAC10
+#define CWeaponMP5Navy C_WeaponMP5Navy
+#define CWeaponP90 C_WeaponP90
+#define CWeaponTMP C_WeaponTMP
+#define CWeaponUMP45 C_WeaponUMP45
+#endif
+
+//MAC10
+class CWeaponMAC10 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponMAC10, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponMAC10();
+
+    virtual void Spawn();
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+    virtual bool Reload();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_MAC10; }
+
+
+private:
+
+    void MAC10Fire(float flSpread);
+
+    CWeaponMAC10(const CWeaponMAC10 &);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponMAC10, DT_WeaponMAC10)
+
+BEGIN_NETWORK_TABLE(CWeaponMAC10, DT_WeaponMAC10)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponMAC10)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_mac10, CWeaponMAC10);
+PRECACHE_WEAPON_REGISTER(weapon_mac10);
+
+
+
+CWeaponMAC10::CWeaponMAC10()
+{
+}
+
+
+void CWeaponMAC10::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_flAccuracy = 0.15;
+}
+
+
+bool CWeaponMAC10::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flAccuracy = 0.15;
+
+    return ret;
+}
+
+bool CWeaponMAC10::Reload()
+{
+    bool ret = BaseClass::Reload();
+
+    m_flAccuracy = 0.15;
+
+    return ret;
+}
+
+
+void CWeaponMAC10::MAC10Fire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))	// jumping
+        pPlayer->KickBack(1.3, 0.55, 0.4, 0.05, 4.75, 3.75, 5);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)				// running
+        pPlayer->KickBack(0.9, 0.45, 0.25, 0.035, 3.5, 2.75, 7);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))	// ducking
+        pPlayer->KickBack(0.75, 0.4, 0.175, 0.03, 2.75, 2.5, 10);
+    else														// standing
+        pPlayer->KickBack(0.775, 0.425, 0.2, 0.03, 3, 2.75, 9);
+}
+
+
+void CWeaponMAC10::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        MAC10Fire(0.375f * m_flAccuracy);
+    else
+        MAC10Fire(0.03f * m_flAccuracy);
+}
+
+//MP5NAVY
+class CWeaponMP5Navy : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponMP5Navy, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponMP5Navy();
+
+    virtual void Spawn();
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+    virtual bool Reload();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_MP5NAVY; }
+
+
+private:
+
+    CWeaponMP5Navy(const CWeaponMP5Navy &);
+
+    void MP5NFire(float flSpread);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponMP5Navy, DT_WeaponMP5Navy)
+
+BEGIN_NETWORK_TABLE(CWeaponMP5Navy, DT_WeaponMP5Navy)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponMP5Navy)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_mp5navy, CWeaponMP5Navy);
+PRECACHE_WEAPON_REGISTER(weapon_mp5navy);
+
+
+
+CWeaponMP5Navy::CWeaponMP5Navy()
+{
+}
+
+void CWeaponMP5Navy::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_flAccuracy = 0.0;
+}
+
+
+bool CWeaponMP5Navy::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flAccuracy = 0.0;
+
+    return ret;
+}
+
+bool CWeaponMP5Navy::Reload()
+{
+    bool ret = BaseClass::Reload();
+
+    m_flAccuracy = 0.0;
+
+    return ret;
+}
+
+void CWeaponMP5Navy::PrimaryAttack(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        MP5NFire(0.2f * m_flAccuracy);
+    else
+        MP5NFire(0.04f * m_flAccuracy);
+}
+
+void CWeaponMP5Navy::MP5NFire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    // Kick the gun based on the state of the player.
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(0.9, 0.475, 0.35, 0.0425, 5, 3, 6);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(0.5, 0.275, 0.2, 0.03, 3, 2, 10);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.225, 0.15, 0.1, 0.015, 2, 1, 10);
+    else
+        pPlayer->KickBack(0.25, 0.175, 0.125, 0.02, 2.25, 1.25, 10);
+}
+
+
+//P90
+class CWeaponP90 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponP90, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponP90();
+
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_P90; }
+
+
+private:
+
+    CWeaponP90(const CWeaponP90 &);
+
+    void P90Fire(float flSpread);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponP90, DT_WeaponP90)
+
+BEGIN_NETWORK_TABLE(CWeaponP90, DT_WeaponP90)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponP90)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_p90, CWeaponP90);
+PRECACHE_WEAPON_REGISTER(weapon_p90);
+
+
+
+CWeaponP90::CWeaponP90()
+{
+
+}
+
+void CWeaponP90::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        P90Fire(0.3f * m_flAccuracy);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 170)
+        P90Fire(0.115f * m_flAccuracy);
+    else
+        P90Fire(0.045f * m_flAccuracy);
+}
+
+
+void CWeaponP90::P90Fire(float flSpread)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    // Kick the gun based on the state of the player.
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(0.9, 0.45, 0.35, 0.04, 5.25, 3.5, 4);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(0.45, 0.3, 0.2, 0.0275, 4, 2.25, 7);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.275, 0.2, 0.125, 0.02, 3, 1, 9);
+    else
+        pPlayer->KickBack(0.3, 0.225, 0.125, 0.02, 3.25, 1.25, 8);
+}
+
+
+//TMP
+class CWeaponTMP : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponTMP, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponTMP();
+
+    virtual void PrimaryAttack();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_TMP; }
+
+    virtual bool IsSilenced(void) const { return true; }
+
+private:
+
+    CWeaponTMP(const CWeaponTMP &);
+
+    void TMPFire(float flSpread);
+    void DoFireEffects(void);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponTMP, DT_WeaponTMP)
+
+BEGIN_NETWORK_TABLE(CWeaponTMP, DT_WeaponTMP)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponTMP)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_tmp, CWeaponTMP);
+PRECACHE_WEAPON_REGISTER(weapon_tmp);
+
+
+
+CWeaponTMP::CWeaponTMP()
+{
+}
+
+
+void CWeaponTMP::PrimaryAttack(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        TMPFire(0.25f * m_flAccuracy);
+    else
+        TMPFire(0.03f * m_flAccuracy);
+}
+
+void CWeaponTMP::TMPFire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(1.1, 0.5, 0.35, 0.045, 4.5, 3.5, 6);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(0.8, 0.4, 0.2, 0.03, 3, 2.5, 7);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.7, 0.35, 0.125, 0.025, 2.5, 2, 10);
+    else
+        pPlayer->KickBack(0.725, 0.375, 0.15, 0.025, 2.75, 2.25, 9);
+}
+
+void CWeaponTMP::DoFireEffects(void)
+{
+    // TMP is silenced, so do nothing
+}
+
+//UMP45
+class CWeaponUMP45 : public CWeaponCSBaseGun
+{
+public:
+    DECLARE_CLASS(CWeaponUMP45, CWeaponCSBaseGun);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponUMP45();
+
+    virtual void Spawn();
+    virtual void PrimaryAttack();
+    virtual bool Deploy();
+    virtual bool Reload();
+
+    virtual CSWeaponID GetWeaponID(void) const { return WEAPON_UMP45; }
+
+
+private:
+
+    CWeaponUMP45(const CWeaponUMP45 &);
+
+    void UMP45Fire(float flSpread);
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponUMP45, DT_WeaponUMP45)
+
+BEGIN_NETWORK_TABLE(CWeaponUMP45, DT_WeaponUMP45)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponUMP45)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_ump45, CWeaponUMP45);
+PRECACHE_WEAPON_REGISTER(weapon_ump45);
+
+
+
+CWeaponUMP45::CWeaponUMP45()
+{
+}
+
+
+void CWeaponUMP45::Spawn()
+{
+    BaseClass::Spawn();
+
+    m_flAccuracy = 0.0;
+}
+
+
+bool CWeaponUMP45::Deploy()
+{
+    bool ret = BaseClass::Deploy();
+
+    m_flAccuracy = 0.0;
+
+    return ret;
+}
+
+bool CWeaponUMP45::Reload()
+{
+    bool ret = BaseClass::Reload();
+
+    m_flAccuracy = 0.0;
+
+    return ret;
+}
+
+void CWeaponUMP45::PrimaryAttack()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return;
+
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        UMP45Fire(0.24f * m_flAccuracy);
+    else
+        UMP45Fire(0.04f * m_flAccuracy);
+}
+
+void CWeaponUMP45::UMP45Fire(float flSpread)
+{
+    if (!CSBaseGunFire(flSpread, GetCSWpnData().m_flCycleTime, true))
+        return;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    // CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+    if (!pPlayer)
+        return;
+
+    // Kick the gun based on the state of the player.
+    if (!FBitSet(pPlayer->GetFlags(), FL_ONGROUND))
+        pPlayer->KickBack(0.125, 0.65, 0.55, 0.0475, 5.5, 4, 10);
+    else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+        pPlayer->KickBack(0.55, 0.3, 0.225, 0.03, 3.5, 2.5, 10);
+    else if (FBitSet(pPlayer->GetFlags(), FL_DUCKING))
+        pPlayer->KickBack(0.25, 0.175, 0.125, 0.02, 2.25, 1.25, 10);
+    else
+        pPlayer->KickBack(0.275, 0.2, 0.15, 0.0225, 2.5, 1.5, 10);
+}
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_csbase.cpp b/mp/src/game/shared/momentum/weapon_csbase.cpp
new file mode 100644
index 000000000..f3c59318a
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_csbase.cpp
@@ -0,0 +1,1519 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Laser Rifle & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "weapon_csbase.h"
+#include "ammodef.h"
+#include "mom_player_shared.h"
+
+#if defined( CLIENT_DLL )
+
+#include "vgui/ISurface.h"
+//#include "vgui_controls/controls.h"
+#include "hud_crosshair.h"
+#include "c_te_effect_dispatch.h"
+#include "c_te_legacytempents.h"
+
+extern IVModelInfoClient* modelinfo;
+
+#else
+
+#include "te_effect_dispatch.h"
+#include "KeyValues.h"
+#include "cs_ammodef.h"
+
+extern IVModelInfo* modelinfo;
+
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// Global functions.
+// ----------------------------------------------------------------------------- //
+
+//--------------------------------------------------------------------------------------------------------
+static const char * s_WeaponAliasInfo[] =
+{
+    "none",		// WEAPON_NONE
+    "p228",		// WEAPON_P228
+    "glock",	// WEAPON_GLOCK				// old glock
+    "scout",	// WEAPON_SCOUT
+    "hegren",	// WEAPON_HEGRENADE
+    "xm1014",	// WEAPON_XM1014			// auto shotgun
+    "c4",		// WEAPON_C4
+    "mac10",	// WEAPON_MAC10				// T only
+    "aug",		// WEAPON_AUG
+    "sgren",	// WEAPON_SMOKEGRENADE
+    "elite",	// WEAPON_ELITE
+    "fiveseven",// WEAPON_FIVESEVEN
+    "ump45",	// WEAPON_UMP45
+    "sg550",	// WEAPON_SG550				// auto-sniper
+    "galil",	// WEAPON_GALIL
+    "famas",	// WEAPON_FAMAS				// CT cheap m4a1
+    "usp",		// WEAPON_USP
+    "awp",		// WEAPON_AWP
+    "mp5navy",	// WEAPON_MP5N 
+    "m249",		// WEAPON_M249				// big machinegun
+    "m3",		// WEAPON_M3 				// cheap shotgun
+    "m4a1",		// WEAPON_M4A1
+    "tmp",		// WEAPON_TMP
+    "g3sg1",	// WEAPON_G3SG1				// T auto-sniper
+    "flash",	// WEAPON_FLASHBANG
+    "deagle",	// WEAPON_DEAGLE
+    "sg552",	// WEAPON_SG552				// T aug equivalent
+    "ak47",		// WEAPON_AK47
+    "knife",	// WEAPON_KNIFE
+    "p90",		// WEAPON_P90
+    "shield",	// WEAPON_SHIELDGUN 
+    "kevlar",
+    "assaultsuit",
+    "nightvision",
+    NULL,		// WEAPON_NONE
+};
+
+struct WeaponAliasTranslationInfoStruct
+{
+    char *m_alias;
+    char *m_translatedAlias;
+};
+
+static const WeaponAliasTranslationInfoStruct s_WeaponAliasTranslationInfo[] =
+{
+    { "cv47", "ak47" },
+    { "defender", "galil" },
+    { "krieg552", "sg552" },
+    { "magnum", "awp" },
+    { "d3au1", "g3sg1" },
+    { "clarion", "famas" },
+    { "bullpup", "aug" },
+    { "krieg550", "sg550" },
+    { "9x19mm", "glock" },
+    { "km45", "usp" },
+    { "228compact", "p228" },
+    { "nighthawk", "deagle" },
+    { "elites", "elite" },
+    { "fn57", "fiveseven" },
+    { "12gauge", "m3" },
+    { "autoshotgun", "xm1014" },
+    { "mp", "tmp" },
+    { "smg", "mp5navy" },
+    { "mp5", "mp5navy" },
+    { "c90", "p90" },
+    { "vest", "kevlar" },
+    { "vesthelm", "assaultsuit" },
+    { "smokegrenade", "sgren" },
+    { "smokegrenade", "sgren" },
+    { "nvgs", "nightvision" },
+
+    { "", "" } // this needs to be last
+};
+
+bool IsAmmoType(int iAmmoType, const char *pAmmoName)
+{
+    return GetAmmoDef()->Index(pAmmoName) == iAmmoType;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given an alias, return the translated alias.
+//
+const char * GetTranslatedWeaponAlias(const char *alias)
+{
+    int i = 0;
+    const WeaponAliasTranslationInfoStruct *info = &(s_WeaponAliasTranslationInfo[i]);
+
+    while (info->m_alias[0] != 0)
+    {
+        if (Q_stricmp(alias, info->m_alias) == 0)
+        {
+            return info->m_translatedAlias;
+        }
+        info = &(s_WeaponAliasTranslationInfo[++i]);
+    }
+
+    return alias;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given an alias, return the associated weapon ID
+//
+int AliasToWeaponID(const char *alias)
+{
+    if (alias)
+    {
+        for (int i = 0; s_WeaponAliasInfo[i] != NULL; ++i)
+            if (!Q_stricmp(s_WeaponAliasInfo[i], alias))
+                return i;
+    }
+
+    return WEAPON_NONE;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given a classname, return the associated weapon ID
+//
+int ClassnameToWeaponID(const char *classname)
+{
+    if (classname)
+    {
+        for (int i = 0; s_WeaponAliasInfo[i] != NULL; ++i)
+            if (Q_stristr(classname, s_WeaponAliasInfo[i]))
+                return i;
+    }
+
+    return WEAPON_NONE;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given a weapon ID, return its alias
+//
+const char *WeaponIDToAlias(int id)
+{
+    if ((id >= WEAPON_MAX) || (id < 0))
+        return NULL;
+
+    return s_WeaponAliasInfo[id];
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Return true if given weapon ID is a primary weapon
+//
+bool IsPrimaryWeapon(int id)
+{
+    switch (id)
+    {
+    case WEAPON_SCOUT:
+    case WEAPON_XM1014:
+    case WEAPON_MAC10:
+    case WEAPON_AUG:
+    case WEAPON_UMP45:
+    case WEAPON_SG550:
+    case WEAPON_GALIL:
+    case WEAPON_FAMAS:
+    case WEAPON_AWP:
+    case WEAPON_MP5NAVY:
+    case WEAPON_M249:
+    case WEAPON_M3:
+    case WEAPON_M4A1:
+    case WEAPON_TMP:
+    case WEAPON_G3SG1:
+    case WEAPON_SG552:
+    case WEAPON_AK47:
+    case WEAPON_P90:
+    case WEAPON_SHIELDGUN:
+        return true;
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Return true if given weapon ID is a secondary weapon
+//
+bool IsSecondaryWeapon(int id)
+{
+    switch (id)
+    {
+    case WEAPON_USP:
+    case WEAPON_GLOCK:
+    case WEAPON_DEAGLE:
+    case WEAPON_ELITE:
+    case WEAPON_P228:
+    case WEAPON_FIVESEVEN:
+        return true;
+    }
+
+    return false;
+}
+
+#ifdef CLIENT_DLL
+int GetShellForAmmoType(const char *ammoname)
+{
+    if (!Q_strcmp(BULLET_PLAYER_762MM, ammoname))
+        return CS_SHELL_762NATO;
+
+    if (!Q_strcmp(BULLET_PLAYER_556MM, ammoname))
+        return CS_SHELL_556;
+
+    if (!Q_strcmp(BULLET_PLAYER_338MAG, ammoname))
+        return CS_SHELL_338MAG;
+
+    if (!Q_strcmp(BULLET_PLAYER_BUCKSHOT, ammoname))
+        return CS_SHELL_12GAUGE;
+
+    if (!Q_strcmp(BULLET_PLAYER_57MM, ammoname))
+        return CS_SHELL_57;
+
+    // default 9 mm
+    return CS_SHELL_9MM;
+}
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CWeaponCSBase tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponCSBase, DT_WeaponCSBase)
+
+BEGIN_NETWORK_TABLE(CWeaponCSBase, DT_WeaponCSBase)
+#ifdef CLIENT_DLL
+
+#else
+// world weapon models have no aminations
+SendPropExclude("DT_AnimTimeMustBeFirst", "m_flAnimTime"),
+SendPropExclude("DT_BaseAnimating", "m_nSequence"),
+//	SendPropExclude( "DT_LocalActiveWeaponData", "m_flTimeWeaponIdle" ),
+#endif
+
+
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA(CWeaponCSBase)
+DEFINE_PRED_FIELD(m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS(weapon_cs_base, CWeaponCSBase);
+
+
+#ifdef GAME_DLL
+
+BEGIN_DATADESC(CWeaponCSBase)
+
+//DEFINE_FUNCTION( DefaultTouch ),
+DEFINE_FUNCTION(FallThink)
+
+END_DATADESC()
+
+#endif
+
+#ifdef CLIENT_DLL
+ConVar cl_crosshaircolor("cl_crosshaircolor", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+ConVar cl_dynamiccrosshair("cl_dynamiccrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+ConVar cl_scalecrosshair("cl_scalecrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+ConVar cl_crosshairscale("cl_crosshairscale", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+ConVar cl_crosshairalpha("cl_crosshairalpha", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+ConVar cl_crosshairusealpha("cl_crosshairusealpha", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CWeaponCSBase implementation. 
+// ----------------------------------------------------------------------------- //
+CWeaponCSBase::CWeaponCSBase()
+{
+    SetPredictionEligible(true);
+    m_bDelayFire = true;
+    m_nextPrevOwnerTouchTime = 0.0;
+    m_prevOwner = NULL;
+    AddSolidFlags(FSOLID_TRIGGER); // Nothing collides with these but it gets touches.
+
+#ifdef CLIENT_DLL
+    m_iCrosshairTextureID = 0;
+
+    m_bInReloadAnimation = false;
+#else
+    m_iDefaultExtraAmmo = 0;
+#endif
+}
+
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::KeyValue(const char *szKeyName, const char *szValue)
+{
+    if (!BaseClass::KeyValue(szKeyName, szValue))
+    {
+        if (FStrEq(szKeyName, "ammo"))
+        {
+            int bullets = atoi(szValue);
+            if (bullets < 0)
+                return false;
+
+            m_iDefaultExtraAmmo = bullets;
+
+            return true;
+        }
+    }
+
+    return false;
+}
+#endif
+
+
+bool CWeaponCSBase::IsPredicted() const
+{
+    return true;
+}
+
+
+bool CWeaponCSBase::IsPistol() const
+{
+    return GetCSWpnData().m_WeaponType == WEAPONTYPE_PISTOL;
+}
+
+
+bool CWeaponCSBase::IsAwp() const
+{
+    return false;
+}
+
+
+bool CWeaponCSBase::PlayEmptySound()
+{
+    //MIKETODO: certain weapons should override this to make it empty:
+    //	C4
+    //	Flashbang
+    //	HE Grenade
+    //	Smoke grenade				
+
+    CPASAttenuationFilter filter(this);
+    filter.UsePredictionRules();
+
+    if (IsPistol())
+    {
+        EmitSound(filter, entindex(), "Default.ClipEmpty_Pistol");
+    }
+    else
+    {
+        EmitSound(filter, entindex(), "Default.ClipEmpty_Rifle");
+    }
+
+    return 0;
+}
+
+CMomentumPlayer* CWeaponCSBase::GetPlayerOwner() const
+{
+    return dynamic_cast<CMomentumPlayer*>(GetOwner());
+}
+
+bool CWeaponCSBase::SendWeaponAnim(int iActivity)
+{
+#ifdef CS_SHIELD_ENABLED
+    CCSPlayer *pPlayer = GetPlayerOwner();
+
+    if ( pPlayer && pPlayer->HasShield() )
+    {
+        CBaseViewModel *vm = pPlayer->GetViewModel( 1 );
+
+        if ( vm == NULL )
+            return false;
+
+        vm->SetWeaponModel( SHIELD_VIEW_MODEL, this );
+
+        int	idealSequence = vm->SelectWeightedSequence( (Activity)iActivity );
+
+        if ( idealSequence >= 0 )
+        {
+            vm->SendViewModelMatchingSequence( idealSequence );
+        }
+    } 
+#endif
+
+    return BaseClass::SendWeaponAnim(iActivity);
+}
+
+
+void CWeaponCSBase::ItemPostFrame()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (!pPlayer)
+        return;
+
+    UpdateShieldState();
+
+    if ((m_bInReload) && (pPlayer->m_flNextAttack <= gpGlobals->curtime))
+    {
+        // complete the reload. 
+        int j = min(GetMaxClip1() - m_iClip1, pPlayer->GetAmmoCount(m_iPrimaryAmmoType));
+
+        // Add them to the clip
+        m_iClip1 += j;
+        pPlayer->RemoveAmmo(j, m_iPrimaryAmmoType);
+
+        m_bInReload = false;
+    }
+
+    if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+    {
+        if (m_iClip2 != -1 && !pPlayer->GetAmmoCount(GetSecondaryAmmoType()))
+        {
+            m_bFireOnEmpty = TRUE;
+        }
+
+        SecondaryAttack();
+
+        pPlayer->m_nButtons &= ~IN_ATTACK2;
+    }
+    else if ((pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime))
+    {
+        if ((m_iClip1 == 0/* && pszAmmo1()*/) || (GetMaxClip1() == -1 && !pPlayer->GetAmmoCount(GetPrimaryAmmoType())))
+        {
+            m_bFireOnEmpty = TRUE;
+        }
+
+        // Can't shoot during the freeze period
+        // Ken: Always allow firing in single player
+        //---
+        /*if ( !CSGameRules()->IsFreezePeriod() &&
+            !pPlayer->m_bIsDefusing &&
+            pPlayer->State_Get() == STATE_ACTIVE && !pPlayer->IsShieldDrawn()
+            )*/
+        {
+#ifndef CLIENT_DLL
+            // allow the bots to react to the gunfire
+            if (GetCSWpnData().m_WeaponType != WEAPONTYPE_GRENADE)
+            {
+                IGameEvent * event = gameeventmanager->CreateEvent((HasAmmo()) ? "weapon_fire" : "weapon_fire_on_empty");
+                if (event)
+                {
+                    const char *weaponName = STRING(m_iClassname);
+                    if (strncmp(weaponName, "weapon_", 7) == 0)
+                    {
+                        weaponName += 7;
+                    }
+
+                    event->SetInt("userid", pPlayer->GetUserID());
+                    event->SetString("weapon", weaponName);
+                    gameeventmanager->FireEvent(event);
+                }
+            }
+#endif
+            PrimaryAttack();
+        }
+        //---
+    }
+    else if (pPlayer->m_nButtons & IN_RELOAD && GetMaxClip1() != WEAPON_NOCLIP && !m_bInReload && m_flNextPrimaryAttack < gpGlobals->curtime)
+    {
+        // reload when reload is pressed, or if no buttons are down and weapon is empty.
+
+        //MIKETODO: add code for shields...
+        //if ( !FBitSet( m_iWeaponState, WPNSTATE_SHIELD_DRAWN ) )
+
+        //if ( !pPlayer->IsShieldDrawn() )
+        {
+#ifndef CLIENT_DLL
+            // allow the bots to react to the reload
+            //IGameEvent * event = gameeventmanager->CreateEvent( "weapon_reload" );
+            //if( event )
+            //{
+            //	event->SetInt( "userid", pPlayer->GetUserID() );
+            //	gameeventmanager->FireEvent( event );
+            //}
+#endif
+
+            Reload();
+        }
+    }
+    else if (!(pPlayer->m_nButtons & (IN_ATTACK | IN_ATTACK2)))
+    {
+        // no fire buttons down
+
+        // The following code prevents the player from tapping the firebutton repeatedly 
+        // to simulate full auto and retaining the single shot accuracy of single fire
+        if (m_bDelayFire)
+        {
+            m_bDelayFire = false;
+
+            if (pPlayer->m_iShotsFired > 15)
+                pPlayer->m_iShotsFired = 15;
+
+            m_flDecreaseShotsFired = gpGlobals->curtime + 0.4;
+        }
+
+        m_bFireOnEmpty = FALSE;
+
+        // if it's a pistol then set the shots fired to 0 after the player releases a button
+        if (IsPistol())
+        {
+            pPlayer->m_iShotsFired = 0;
+        }
+        else
+        {
+            if ((pPlayer->m_iShotsFired > 0) && (m_flDecreaseShotsFired < gpGlobals->curtime))
+            {
+                m_flDecreaseShotsFired = gpGlobals->curtime + 0.0225;
+                pPlayer->m_iShotsFired--;
+            }
+        }
+
+        if ((!IsUseable() && m_flNextPrimaryAttack < gpGlobals->curtime)
+#ifdef CLIENT_DLL
+            || (m_bInReloadAnimation)
+#endif
+            )
+        {
+            // Intentionally blank -- used to switch weapons here
+        }
+        else
+        {
+            // weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
+            if (m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime)
+            {
+                Reload();
+                return;
+            }
+        }
+
+        WeaponIdle();
+        return;
+    }
+}
+
+
+float CWeaponCSBase::GetMaxSpeed() const
+{
+    // The weapon should have set this in its constructor.
+    float flRet = GetCSWpnData().m_flMaxSpeed;
+    Assert(flRet > 1);
+    return flRet;
+}
+
+
+const CCSWeaponInfo &CWeaponCSBase::GetCSWpnData() const
+{
+    const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
+    const CCSWeaponInfo *pCSInfo;
+
+#ifdef _DEBUG
+    pCSInfo = dynamic_cast< const CCSWeaponInfo* >( pWeaponInfo );
+    Assert( pCSInfo );
+#else
+    pCSInfo = static_cast<const CCSWeaponInfo*>(pWeaponInfo);
+#endif
+
+    return *pCSInfo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *CWeaponCSBase::GetViewModel(int /*viewmodelindex = 0 -- this is ignored in the base class here*/) const
+{
+    CMomentumPlayer *pOwner = GetPlayerOwner();
+
+    if (pOwner == NULL)
+    {
+        return BaseClass::GetViewModel();
+    }
+
+    return GetWpnData().szViewModel;
+
+    //return BaseClass::GetViewModel();
+}
+
+void CWeaponCSBase::Precache(void)
+{
+    BaseClass::Precache();
+
+#ifdef CS_SHIELD_ENABLED
+    if ( GetCSWpnData().m_bCanUseWithShield )
+    {
+        PrecacheModel( GetCSWpnData().m_szShieldViewModel );
+    }
+#endif
+
+    PrecacheScriptSound("Default.ClipEmpty_Pistol");
+    PrecacheScriptSound("Default.ClipEmpty_Rifle");
+
+    PrecacheScriptSound("Default.Zoom");
+}
+
+Activity CWeaponCSBase::GetDeployActivity(void)
+{
+    return ACT_VM_DRAW;
+}
+
+bool CWeaponCSBase::DefaultDeploy(char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt)
+{
+    // Msg( "deploy %s at %f\n", GetClassname(), gpGlobals->curtime );
+    CMomentumPlayer *pOwner = GetPlayerOwner();
+    if (!pOwner)
+    {
+        return false;
+    }
+
+    pOwner->SetAnimationExtension(szAnimExt);
+
+    SetViewModel();
+    SendWeaponAnim(GetDeployActivity());
+
+    pOwner->SetNextAttack(gpGlobals->curtime + SequenceDuration());
+    m_flNextPrimaryAttack = gpGlobals->curtime;
+    m_flNextSecondaryAttack = gpGlobals->curtime;
+
+    SetWeaponVisible(true);
+    //pOwner->SetShieldDrawnState( false );
+
+    //if ( pOwner->HasShield() == true )
+    //	 SetWeaponModelIndex( SHIELD_WORLD_MODEL);
+    //else
+    SetWeaponModelIndex(szWeaponModel);
+
+    return true;
+}
+
+void CWeaponCSBase::UpdateShieldState(void)
+{
+    //empty by default.
+    CMomentumPlayer *pOwner = GetPlayerOwner();
+
+    if (pOwner == NULL)
+        return;
+
+    //ADRIANTODO
+    //Make the hitbox set switches here!!!
+    //if ( pOwner->HasShield() == false )
+    //{
+
+    //	pOwner->SetShieldDrawnState( false );
+    //pOwner->SetHitBoxSet( 0 );
+    //	return;
+    //}
+    //else
+    {
+        //pOwner->SetHitBoxSet( 1 );
+    }
+}
+
+void CWeaponCSBase::SetWeaponModelIndex(const char *pName)
+{
+    m_iWorldModelIndex = modelinfo->GetModelIndex(pName);
+}
+
+bool CWeaponCSBase::CanBeSelected(void)
+{
+    if (!VisibleInWeaponSelection())
+        return false;
+
+    return true;
+}
+
+bool CWeaponCSBase::CanDeploy(void)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    //if ( pPlayer->HasShield() && GetCSWpnData().m_bCanUseWithShield == false )
+    //	 return false;
+
+    return BaseClass::CanDeploy();
+}
+
+bool CWeaponCSBase::Holster(CBaseCombatWeapon *pSwitchingTo)
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+#ifndef CLIENT_DLL
+    if (pPlayer)
+        pPlayer->SetFOV(pPlayer, 0); // reset the default FOV.
+#endif
+
+    //if ( pPlayer )
+    //	pPlayer->SetShieldDrawnState( false );
+
+    return BaseClass::Holster(pSwitchingTo);
+}
+
+bool CWeaponCSBase::Deploy()
+{
+#ifdef CLIENT_DLL
+    m_iAlpha = 80;
+#else
+
+    m_flDecreaseShotsFired = gpGlobals->curtime;
+
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+    if (pPlayer)
+    {
+        pPlayer->m_iShotsFired = 0;
+        pPlayer->m_bResumeZoom = false;
+        pPlayer->m_iLastZoom = 0;
+        pPlayer->SetFOV(pPlayer, 0);
+    }
+#endif
+
+    return BaseClass::Deploy();
+}
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::IsRemoveable()
+{
+    if (BaseClass::IsRemoveable() == true)
+    {
+        if (m_nextPrevOwnerTouchTime > gpGlobals->curtime)
+        {
+            return false;
+        }
+    }
+
+    return BaseClass::IsRemoveable();
+}
+#endif
+
+void CWeaponCSBase::Drop(const Vector &vecVelocity)
+{
+
+#ifdef CLIENT_DLL
+    BaseClass::Drop(vecVelocity);
+    return;
+#else
+
+    // Once somebody drops a gun, it's fair game for removal when/if
+    // a game_weapon_manager does a cleanup on surplus weapons in the
+    // world.
+    SetRemoveable(true);
+
+    StopAnimation();
+    StopFollowingEntity();
+    SetMoveType(MOVETYPE_FLYGRAVITY);
+    // clear follow stuff, setup for collision
+    SetGravity(1.0);
+    m_iState = WEAPON_NOT_CARRIED;
+    RemoveEffects(EF_NODRAW);
+    FallInit();
+    SetGroundEntity(NULL);
+
+    m_bInReload = false; // stop reloading 
+
+    SetThink(NULL);
+    m_nextPrevOwnerTouchTime = gpGlobals->curtime + 0.8f;
+    m_prevOwner = GetPlayerOwner();
+
+    SetTouch(&CWeaponCSBase::DefaultTouch);
+
+    IPhysicsObject *pObj = VPhysicsGetObject();
+    if (pObj != NULL)
+    {
+        AngularImpulse	angImp(200, 200, 200);
+        pObj->AddVelocity(&vecVelocity, &angImp);
+    }
+    else
+    {
+        SetAbsVelocity(vecVelocity);
+    }
+
+    SetNextThink(gpGlobals->curtime);
+
+    SetOwnerEntity(NULL);
+    SetOwner(NULL);
+#endif
+}
+
+// whats going on here is that if the player drops this weapon, they shouldn't take it back themselves
+// for a little while.  But if they throw it at someone else, the other player should get it immediately.
+void CWeaponCSBase::DefaultTouch(CBaseEntity *pOther)
+{
+    if ((m_prevOwner != NULL) && (pOther == m_prevOwner) && (gpGlobals->curtime < m_nextPrevOwnerTouchTime))
+    {
+        return;
+    }
+
+    BaseClass::DefaultTouch(pOther);
+}
+
+#ifdef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the weapon's crosshair
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::DrawCrosshair()
+{
+    if (!crosshair.GetInt())
+        return;
+
+    CHudCrosshair *pCrosshair = GET_HUDELEMENT(CHudCrosshair);
+
+    if (!pCrosshair)
+        return;
+
+    // clear crosshair
+    pCrosshair->SetCrosshair(0, Color(255, 255, 255, 255));
+
+    CMomentumPlayer* pPlayer = (CMomentumPlayer*) C_BasePlayer::GetLocalPlayer();
+
+    if (!pPlayer)
+        return;
+
+    // localplayer must be owner if not in Spec mode
+    Assert((pPlayer == GetPlayerOwner()) || (pPlayer->GetObserverMode() == OBS_MODE_IN_EYE));
+
+    // Draw the targeting zone around the pCrosshair
+    if (pPlayer->IsInVGuiInputMode())
+        return;
+
+    //if ( pPlayer->HasShield() && pPlayer->IsShieldDrawn() == true )
+    //	 return;
+
+    // no crosshair for sniper rifles
+    if (GetCSWpnData().m_WeaponType == WEAPONTYPE_SNIPER_RIFLE)
+        return;
+
+    int iDistance = GetCSWpnData().m_iCrosshairMinDistance; // The minimum distance the crosshair can achieve...
+
+    int iDeltaDistance = GetCSWpnData().m_iCrosshairDeltaDistance; // Distance at which the crosshair shrinks at each step
+
+    if (cl_dynamiccrosshair.GetBool())
+    {
+        if (!(pPlayer->GetFlags() & FL_ONGROUND))
+            iDistance *= 2.0f;
+        else if (pPlayer->GetFlags() & FL_DUCKING)
+            iDistance *= 0.5f;
+        else if (pPlayer->GetAbsVelocity().Length() > 100)
+            iDistance *= 1.5f;
+    }
+
+    if (pPlayer->m_iShotsFired > m_iAmmoLastCheck)
+    {
+        m_flCrosshairDistance = min(15, m_flCrosshairDistance + iDeltaDistance);
+    }
+    else if (m_flCrosshairDistance > iDistance)
+    {
+        m_flCrosshairDistance -= 0.1f + m_flCrosshairDistance * 0.013;
+    }
+
+    m_iAmmoLastCheck = pPlayer->m_iShotsFired;
+
+    if (m_flCrosshairDistance < iDistance)
+        m_flCrosshairDistance = iDistance;
+
+    //scale bar size to the resolution
+    int crosshairScale = cl_crosshairscale.GetInt();
+    if (crosshairScale < 1)
+    {
+        if (ScreenHeight() <= 600)
+        {
+            crosshairScale = 600;
+        }
+        else if (ScreenHeight() <= 768)
+        {
+            crosshairScale = 768;
+        }
+        else
+        {
+            crosshairScale = 1200;
+        }
+    }
+
+    float scale;
+    if (cl_scalecrosshair.GetBool() == false)
+    {
+        scale = 1.0f;
+    }
+    else
+    {
+        scale = (float) ScreenHeight() / (float) crosshairScale;
+    }
+
+    int iCrosshairDistance = (int) ceil(m_flCrosshairDistance * scale);
+
+    int iBarSize = XRES(5) + (iCrosshairDistance - iDistance) / 2;
+
+    iBarSize = max(1, (int) ((float) iBarSize * scale));
+
+    int iBarThickness = max(1, (int) floor(scale + 0.5f));
+
+    int	r, g, b;
+
+    switch (cl_crosshaircolor.GetInt())
+    {
+    case 0:	r = 50;		g = 250;	b = 50;		break;
+    case 1:	r = 250;	g = 50;		b = 50;		break;
+    case 2:	r = 50;		g = 50;		b = 250;	break;
+    case 3:	r = 250;	g = 250;	b = 50;		break;
+    case 4:	r = 50;		g = 250;	b = 250;	break;
+    default:	r = 50;		g = 250;	b = 50;		break;
+    }
+
+    // if user is using nightvision, make the crosshair red.
+    //if (pPlayer->m_bNightVisionOn)
+    //{
+    //	r = 250;
+    //	g = 50;
+    //	b = 50;
+    //}
+
+    int alpha = clamp(cl_crosshairalpha.GetInt(), 0, 255);
+    vgui::surface()->DrawSetColor(r, g, b, alpha);
+
+    if (!m_iCrosshairTextureID)
+    {
+        CHudTexture *pTexture = gHUD.GetIcon("whiteAdditive");
+        if (pTexture)
+        {
+            m_iCrosshairTextureID = pTexture->textureId;
+        }
+    }
+
+    if (!cl_crosshairusealpha.GetBool())
+    {
+        vgui::surface()->DrawSetColor(r, g, b, 200);
+        vgui::surface()->DrawSetTexture(m_iCrosshairTextureID);
+    }
+
+    int iHalfScreenWidth = ScreenWidth() / 2;
+    int iHalfScreenHeight = ScreenHeight() / 2;
+
+    int iLeft = iHalfScreenWidth - (iCrosshairDistance + iBarSize);
+    int iRight = iHalfScreenWidth + iCrosshairDistance + iBarThickness;
+    int iFarLeft = iLeft + iBarSize;
+    int iFarRight = iRight + iBarSize;
+
+    if (!cl_crosshairusealpha.GetBool())
+    {
+        // Additive crosshair
+        vgui::surface()->DrawTexturedRect(iLeft, iHalfScreenHeight, iFarLeft, iHalfScreenHeight + iBarThickness);
+        vgui::surface()->DrawTexturedRect(iRight, iHalfScreenHeight, iFarRight, iHalfScreenHeight + iBarThickness);
+    }
+    else
+    {
+        // Alpha-blended crosshair
+        vgui::surface()->DrawFilledRect(iLeft, iHalfScreenHeight, iFarLeft, iHalfScreenHeight + iBarThickness);
+        vgui::surface()->DrawFilledRect(iRight, iHalfScreenHeight, iFarRight, iHalfScreenHeight + iBarThickness);
+    }
+
+    int iTop = iHalfScreenHeight - (iCrosshairDistance + iBarSize);
+    int iBottom = iHalfScreenHeight + iCrosshairDistance + iBarThickness;
+    int iFarTop = iTop + iBarSize;
+    int iFarBottom = iBottom + iBarSize;
+
+    if (!cl_crosshairusealpha.GetBool())
+    {
+        // Additive crosshair
+        vgui::surface()->DrawTexturedRect(iHalfScreenWidth, iTop, iHalfScreenWidth + iBarThickness, iFarTop);
+        vgui::surface()->DrawTexturedRect(iHalfScreenWidth, iBottom, iHalfScreenWidth + iBarThickness, iFarBottom);
+    }
+    else
+    {
+        // Alpha-blended crosshair
+        vgui::surface()->DrawFilledRect(iHalfScreenWidth, iTop, iHalfScreenWidth + iBarThickness, iFarTop);
+        vgui::surface()->DrawFilledRect(iHalfScreenWidth, iBottom, iHalfScreenWidth + iBarThickness, iFarBottom);
+    }
+}
+
+
+void CWeaponCSBase::OnDataChanged(DataUpdateType_t type)
+{
+    BaseClass::OnDataChanged(type);
+
+    if (GetPredictable() && !ShouldPredict())
+        ShutdownPredictable();
+}
+
+
+bool CWeaponCSBase::ShouldPredict()
+{
+    if (GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer())
+        return true;
+
+    return BaseClass::ShouldPredict();
+}
+
+void CWeaponCSBase::ProcessMuzzleFlashEvent()
+{
+    // This is handled from the player's animstate, so it can match up to the beginning of the fire animation
+}
+
+bool CWeaponCSBase::OnFireEvent(C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options)
+{
+    if (event == 5001)
+    {
+        CMomentumPlayer *pPlayer = GetPlayerOwner();
+        if (pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed())
+            return true;
+
+        CEffectData data;
+        data.m_fFlags = 0;
+        data.m_hEntity = pViewModel->GetRefEHandle();
+        data.m_nAttachmentIndex = 1;
+        data.m_flScale = GetCSWpnData().m_flMuzzleScale;
+
+        switch (GetMuzzleFlashStyle())
+        {
+        case CS_MUZZLEFLASH_NONE:
+            break;
+
+        case CS_MUZZLEFLASH_X:
+            DispatchEffect("CS_MuzzleFlash_X", data);
+            break;
+
+        case CS_MUZZLEFLASH_NORM:
+        default:
+            DispatchEffect("CS_MuzzleFlash", data);
+            break;
+        }
+
+        return true;
+    }
+
+    return BaseClass::OnFireEvent(pViewModel, origin, angles, event, options);
+}
+
+int CWeaponCSBase::GetMuzzleFlashStyle(void)
+{
+    return GetCSWpnData().m_iMuzzleFlashStyle;
+}
+
+int CWeaponCSBase::GetMuzzleAttachment(void)
+{
+    return LookupAttachment("muzzle_flash");
+}
+
+#else		
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponCSBase::GetBulletSpread()
+{
+    static Vector cone = VECTOR_CONE_8DEGREES;
+    return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponCSBase::GetDefaultAnimSpeed()
+{
+    return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the laser rifle effect
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::BulletWasFired(const Vector &vecStart, const Vector &vecEnd)
+{
+}
+
+
+bool CWeaponCSBase::ShouldRemoveOnRoundRestart()
+{
+    if (GetPlayerOwner())
+        return false;
+    else
+        return true;
+}
+
+
+//=========================================================
+// Materialize - make a CWeaponCSBase visible and tangible
+//=========================================================
+void CWeaponCSBase::Materialize()
+{
+    if (IsEffectActive(EF_NODRAW))
+    {
+        // changing from invisible state to visible.
+        RemoveEffects(EF_NODRAW);
+        DoMuzzleFlash();
+    }
+
+    AddSolidFlags(FSOLID_TRIGGER);
+
+    //SetTouch( &CWeaponCSBase::DefaultTouch );
+
+    SetThink(NULL);
+
+}
+
+//=========================================================
+// AttemptToMaterialize - the item is trying to rematerialize,
+// should it do so now or wait longer?
+//=========================================================
+void CWeaponCSBase::AttemptToMaterialize()
+{
+    float time = g_pGameRules->FlWeaponTryRespawn(this);
+
+    if (time == 0)
+    {
+        Materialize();
+        return;
+    }
+
+    SetNextThink(gpGlobals->curtime + time);
+}
+
+//=========================================================
+// CheckRespawn - a player is taking this weapon, should 
+// it respawn?
+//=========================================================
+void CWeaponCSBase::CheckRespawn()
+{
+    //GOOSEMAN : Do not respawn weapons!
+    return;
+}
+
+
+//=========================================================
+// Respawn- this item is already in the world, but it is
+// invisible and intangible. Make it visible and tangible.
+//=========================================================
+CBaseEntity* CWeaponCSBase::Respawn()
+{
+    // make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
+    // will decide when to make the weapon visible and touchable.
+    CBaseEntity *pNewWeapon = CBaseEntity::Create(GetClassname(), g_pGameRules->VecWeaponRespawnSpot(this), GetAbsAngles(), GetOwner());
+
+    if (pNewWeapon)
+    {
+        pNewWeapon->AddEffects(EF_NODRAW);// invisible for now
+        pNewWeapon->SetTouch(NULL);// no touch
+        pNewWeapon->SetThink(&CWeaponCSBase::AttemptToMaterialize);
+
+        UTIL_DropToFloor(this, MASK_SOLID);
+
+        // not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
+        // but when it should respawn is based on conditions belonging to the weapon that was taken.
+        pNewWeapon->SetNextThink(gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime(this));
+    }
+    else
+    {
+        Msg("Respawn failed to create %s!\n", GetClassname());
+    }
+
+    return pNewWeapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+{
+    CBasePlayer *pPlayer = ToBasePlayer(pActivator);
+
+    if (pPlayer)
+    {
+        pPlayer->Weapon_Equip(this);
+    }
+}
+
+bool CWeaponCSBase::Reload()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    pPlayer->m_iShotsFired = 0;
+
+    bool retval = BaseClass::Reload();
+
+#ifdef CLIENT_DLL
+    if (retval)
+    {
+        m_bInReloadAnimation = true;
+    }
+#endif
+
+    return retval;
+}
+
+void CWeaponCSBase::Spawn()
+{
+    BaseClass::Spawn();
+
+    // Override the bloat that our base class sets as it's a little bit bigger than we want.
+    // If it's too big, you drop a weapon and its box is so big that you're still touching it
+    // when it falls and you pick it up again right away.
+    CollisionProp()->UseTriggerBounds(true, 30);
+
+    // Set this here to allow players to shoot dropped weapons
+    SetCollisionGroup(COLLISION_GROUP_WEAPON);
+
+    SetExtraAmmoCount(m_iDefaultExtraAmmo);	//Start with no additional ammo
+
+    m_nextPrevOwnerTouchTime = 0.0;
+    m_prevOwner = NULL;
+
+#ifdef CLIENT_DLL
+    m_bInReloadAnimation = false;
+#endif
+}
+
+bool CWeaponCSBase::DefaultReload(int iClipSize1, int iClipSize2, int iActivity)
+{
+    if (BaseClass::DefaultReload(iClipSize1, iClipSize2, iActivity))
+    {
+        //SendReloadEvents(); MOM_TODO: will this be needed? (it sends it to other players)
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void CWeaponCSBase::SendReloadEvents()
+{
+    //CMomentumPlayer *pPlayer = GetPlayerOwner();
+    //if ( !pPlayer )
+    //    return;
+
+    // Make the player play his reload animation.
+    //pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
+}
+
+#endif
+
+
+bool CWeaponCSBase::DefaultPistolReload()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0)
+        return true;
+
+    if (!DefaultReload(GetCSWpnData().iDefaultClip1, 0, ACT_VM_RELOAD))
+        return false;
+
+    pPlayer->m_iShotsFired = 0;
+
+#ifdef CLIENT_DLL
+    m_bInReloadAnimation = true;
+#endif
+
+    return true;
+}
+
+bool CWeaponCSBase::IsUseable()
+{
+    CMomentumPlayer *pPlayer = GetPlayerOwner();
+    if (!pPlayer)
+        return false;
+
+    if (Clip1() <= 0)
+    {
+        if (pPlayer->GetAmmoCount(GetPrimaryAmmoType()) <= 0 && GetMaxClip1() != -1)
+        {
+            // clip is empty (or nonexistant) and the player has no more ammo of this type. 
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+#if defined( CLIENT_DLL )
+
+float	g_lateralBob = 0;
+float	g_verticalBob = 0;
+
+static ConVar	cl_bobcycle("cl_bobcycle", "0.8", FCVAR_CHEAT);
+static ConVar	cl_bob("cl_bob", "0.002", FCVAR_CHEAT);
+static ConVar	cl_bobup("cl_bobup", "0.5", FCVAR_CHEAT);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CWeaponCSBase::CalcViewmodelBob(void)
+{
+    static	float bobtime;
+    static	float lastbobtime;
+    static  float lastspeed;
+    float	cycle;
+
+    CBasePlayer *player = ToBasePlayer(GetOwner());
+    //Assert( player );
+
+    //NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
+
+    if ((!gpGlobals->frametime) ||
+        (player == NULL) ||
+        (cl_bobcycle.GetFloat() <= 0.0f) ||
+        (cl_bobup.GetFloat() <= 0.0f) ||
+        (cl_bobup.GetFloat() >= 1.0f))
+    {
+        //NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+        return 0.0f;// just use old value
+    }
+
+    //Find the speed of the player
+    float speed = player->GetLocalVelocity().Length2D();
+    float flmaxSpeedDelta = max(0, (gpGlobals->curtime - lastbobtime) * 320.0f);
+
+    // don't allow too big speed changes
+    speed = clamp(speed, lastspeed - flmaxSpeedDelta, lastspeed + flmaxSpeedDelta);
+    speed = clamp(speed, -320, 320);
+
+    lastspeed = speed;
+
+    //FIXME: This maximum speed value must come from the server.
+    //		 MaxSpeed() is not sufficient for dealing with sprinting - jdw
+
+
+
+    float bob_offset = RemapVal(speed, 0, 320, 0.0f, 1.0f);
+
+    bobtime += (gpGlobals->curtime - lastbobtime) * bob_offset;
+    lastbobtime = gpGlobals->curtime;
+
+    //Calculate the vertical bob
+    cycle = bobtime - (int) (bobtime / cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
+    cycle /= cl_bobcycle.GetFloat();
+
+    if (cycle < cl_bobup.GetFloat())
+    {
+        cycle = M_PI * cycle / cl_bobup.GetFloat();
+    }
+    else
+    {
+        cycle = M_PI + M_PI*(cycle - cl_bobup.GetFloat()) / (1.0 - cl_bobup.GetFloat());
+    }
+
+    g_verticalBob = speed*0.005f;
+    g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
+
+    g_verticalBob = clamp(g_verticalBob, -7.0f, 4.0f);
+
+    //Calculate the lateral bob
+    cycle = bobtime - (int) (bobtime / cl_bobcycle.GetFloat() * 2)*cl_bobcycle.GetFloat() * 2;
+    cycle /= cl_bobcycle.GetFloat() * 2;
+
+    if (cycle < cl_bobup.GetFloat())
+    {
+        cycle = M_PI * cycle / cl_bobup.GetFloat();
+    }
+    else
+    {
+        cycle = M_PI + M_PI*(cycle - cl_bobup.GetFloat()) / (1.0 - cl_bobup.GetFloat());
+    }
+
+    g_lateralBob = speed*0.005f;
+    g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
+    g_lateralBob = clamp(g_lateralBob, -7.0f, 4.0f);
+
+    //NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+    return 0.0f;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &origin - 
+//			&angles - 
+//			viewmodelindex - 
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::AddViewmodelBob(CBaseViewModel *viewmodel, Vector &origin, QAngle &angles)
+{
+    Vector	forward, right;
+    AngleVectors(angles, &forward, &right, NULL);
+
+    CalcViewmodelBob();
+
+    // Apply bob, but scaled down to 40%
+    VectorMA(origin, g_verticalBob * 0.4f, forward, origin);
+
+    // Z bob a bit more
+    origin[2] += g_verticalBob * 0.1f;
+
+    // bob the angles
+    angles[ROLL] += g_verticalBob * 0.5f;
+    angles[PITCH] -= g_verticalBob * 0.4f;
+
+    angles[YAW] -= g_lateralBob  * 0.3f;
+
+    //	VectorMA( origin, g_lateralBob * 0.2f, right, origin );
+}
+
+#else
+
+void CWeaponCSBase::AddViewmodelBob(CBaseViewModel *viewmodel, Vector &origin, QAngle &angles)
+{
+
+}
+
+float CWeaponCSBase::CalcViewmodelBob(void)
+{
+    return 0.0f;
+}
+
+#endif
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::PhysicsSplash(const Vector &centerPoint, const Vector &normal, float rawSpeed, float scaledSpeed)
+{
+    if (rawSpeed > 20)
+    {
+
+        float size = 4.0f;
+        if (!IsPistol())
+            size += 2.0f;
+
+        // adjust splash size based on speed
+        size += RemapValClamped(rawSpeed, 0, 400, 0, 3);
+
+        CEffectData	data;
+        data.m_vOrigin = centerPoint;
+        data.m_vNormal = normal;
+        data.m_flScale = random->RandomFloat(size, size + 1.0f);
+
+        if (GetWaterType() & CONTENTS_SLIME)
+        {
+            data.m_fFlags |= FX_WATER_IN_SLIME;
+        }
+
+        DispatchEffect("gunshotsplash", data);
+
+        return true;
+    }
+
+    return false;
+}
+#endif // !CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPicker - 
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::OnPickedUp(CBaseCombatCharacter *pNewOwner)
+{
+#if !defined( CLIENT_DLL )
+    RemoveEffects(EF_ITEM_BLINK);
+
+    if (pNewOwner->IsPlayer() && pNewOwner->IsAlive())
+    {
+        // Play the pickup sound for 1st-person observers
+        CRecipientFilter filter;
+        for (int i = 0; i < gpGlobals->maxClients; ++i)
+        {
+            CBasePlayer *player = UTIL_PlayerByIndex(i);
+            if (player && !player->IsAlive() && player->GetObserverMode() == OBS_MODE_IN_EYE)
+            {
+                filter.AddRecipient(player);
+            }
+        }
+        if (filter.GetRecipientCount())
+        {
+            CBaseEntity::EmitSound(filter, pNewOwner->entindex(), "Player.PickupWeapon");
+        }
+
+        // Robin: We don't want to delete weapons the player has picked up, so 
+        // clear the name of the weapon. This prevents wildcards that are meant 
+        // to find NPCs finding weapons dropped by the NPCs as well.
+        SetName(NULL_STRING);
+    }
+
+    // Someone picked me up, so make it so that I can't be removed.
+    SetRemoveable(false);
+#endif
+}
diff --git a/mp/src/game/shared/momentum/weapon_csbase.h b/mp/src/game/shared/momentum/weapon_csbase.h
new file mode 100644
index 000000000..462300e48
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_csbase.h
@@ -0,0 +1,217 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_CSBASE_H
+#define WEAPON_CSBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "cs_playeranimstate.h"
+#include "cs_weapon_parse.h"
+#include "mom_player_shared.h"
+
+
+#if defined( CLIENT_DLL )
+	#define CWeaponCSBase C_WeaponCSBase
+#endif
+
+extern int  ClassnameToWeaponID( const char *classname );
+extern int	AliasToWeaponID( const char *alias );
+extern const char *WeaponIDToAlias( int id );
+extern const char *GetTranslatedWeaponAlias( const char *alias);
+extern bool	IsPrimaryWeapon( int id );
+extern bool IsSecondaryWeapon( int id );
+extern int GetShellForAmmoType( const char *ammoname );
+
+#define SHIELD_VIEW_MODEL "models/weapons/v_shield.mdl"
+#define SHIELD_WORLD_MODEL "models/weapons/w_shield.mdl"
+
+#define CS_MUZZLEFLASH_NONE -1
+#define CS_MUZZLEFLASH_NORM	0
+#define CS_MUZZLEFLASH_X	1
+
+// These are the names of the ammo types that go in the CAmmoDefs and that the 
+// weapon script files reference.
+#define BULLET_PLAYER_50AE		"BULLET_PLAYER_50AE"
+#define BULLET_PLAYER_762MM		"BULLET_PLAYER_762MM"
+#define BULLET_PLAYER_556MM		"BULLET_PLAYER_556MM"
+#define BULLET_PLAYER_556MM_BOX	"BULLET_PLAYER_556MM_BOX"
+#define BULLET_PLAYER_338MAG	"BULLET_PLAYER_338MAG"
+#define BULLET_PLAYER_9MM		"BULLET_PLAYER_9MM"
+#define BULLET_PLAYER_BUCKSHOT	"BULLET_PLAYER_BUCKSHOT"
+#define BULLET_PLAYER_45ACP		"BULLET_PLAYER_45ACP"
+#define BULLET_PLAYER_357SIG	"BULLET_PLAYER_357SIG"
+#define BULLET_PLAYER_57MM		"BULLET_PLAYER_57MM"
+#define AMMO_TYPE_HEGRENADE		"AMMO_TYPE_HEGRENADE"
+#define AMMO_TYPE_FLASHBANG		"AMMO_TYPE_FLASHBANG"
+#define AMMO_TYPE_SMOKEGRENADE	"AMMO_TYPE_SMOKEGRENADE"
+
+#define CROSSHAIR_CONTRACT_PIXELS_PER_SECOND	7.0f
+
+// Given an ammo type (like from a weapon's GetPrimaryAmmoType()), this compares it
+// against the ammo name you specify.
+// MIKETODO: this should use indexing instead of searching and strcmp()'ing all the time.
+bool IsAmmoType( int iAmmoType, const char *pAmmoName );
+
+typedef enum
+{
+	Primary_Mode = 0,
+	Secondary_Mode,
+} CSWeaponMode;
+
+#if defined( CLIENT_DLL )
+
+	//--------------------------------------------------------------------------------------------------------------
+	/**
+	*  Returns the client's ID_* value for the currently owned weapon, or ID_NONE if no weapon is owned
+	*/
+	CSWeaponID GetClientWeaponID( bool primary );
+
+#endif
+
+	//--------------------------------------------------------------------------------------------------------------
+	CCSWeaponInfo * GetWeaponInfo( CSWeaponID weaponID );
+
+
+class CWeaponCSBase : public CBaseCombatWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponCSBase, CBaseCombatWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponCSBase();
+
+	#ifdef GAME_DLL
+		DECLARE_DATADESC();
+
+		virtual void CheckRespawn();
+		virtual CBaseEntity* Respawn();
+		
+		virtual const Vector& GetBulletSpread();
+		virtual float	GetDefaultAnimSpeed();
+
+		virtual void	BulletWasFired( const Vector &vecStart, const Vector &vecEnd );
+		virtual bool	ShouldRemoveOnRoundRestart();
+		virtual bool	DefaultReload( int iClipSize1, int iClipSize2, int iActivity );
+
+		void SendReloadEvents();
+
+		void Materialize();
+		void AttemptToMaterialize();
+		virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+		virtual bool IsRemoveable();
+		
+	#endif
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual	float	CalcViewmodelBob( void );
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted() const;
+
+	// Pistols reset m_iShotsFired to 0 when the attack button is released.
+	bool			IsPistol() const;
+
+	// Is this an awp?
+	virtual bool	IsAwp() const;
+
+	CMomentumPlayer *GetPlayerOwner() const;
+
+	virtual float GetMaxSpeed() const;	// What's the player's max speed while holding this weapon.
+
+	// Get CS-specific weapon data.
+	CCSWeaponInfo const	&GetCSWpnData() const;
+
+	// Get specific CS weapon ID (ie: WEAPON_AK47, etc)
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_NONE; }
+
+	// return true if this weapon is an instance of the given weapon type (ie: "IsA" WEAPON_GLOCK)
+	bool IsA( CSWeaponID id ) const						{ return GetWeaponID() == id; }
+
+	// return true if this weapon is a kinf of the given weapon type (ie: "IsKindOf" WEAPONTYPE_RIFLE )
+	bool IsKindOf( CSWeaponType type ) const			{ return GetCSWpnData().m_WeaponType == type; }
+
+	// return true if this weapon has a silencer equipped
+	virtual bool IsSilenced( void ) const				{ return false; }
+
+	virtual void SetWeaponModelIndex( const char *pName );
+	virtual void OnPickedUp( CBaseCombatCharacter *pNewOwner );
+
+public:
+	#if defined( CLIENT_DLL )
+
+		virtual void	ProcessMuzzleFlashEvent();
+		virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+		virtual bool	ShouldPredict();
+		virtual void	DrawCrosshair();
+		virtual void	OnDataChanged( DataUpdateType_t type );
+
+		virtual int		GetMuzzleAttachment( void );
+		virtual bool	HideViewModelWhenZoomed( void ) { return true; }
+
+		float			m_flCrosshairDistance;
+		int				m_iAmmoLastCheck;
+		int				m_iAlpha;
+		int				m_iScopeTextureID;
+		int				m_iCrosshairTextureID; // for white additive texture
+
+		virtual int GetMuzzleFlashStyle( void );
+        bool m_bInReloadAnimation;
+	#else
+
+		virtual bool	Reload();
+		virtual void	Spawn();
+		virtual bool	KeyValue( const char *szKeyName, const char *szValue );
+
+		virtual bool PhysicsSplash( const Vector &centerPoint, const Vector &normal, float rawSpeed, float scaledSpeed );
+
+	#endif
+
+	bool IsUseable();
+	virtual bool	CanDeploy( void );
+	virtual void	UpdateShieldState( void );
+	virtual bool	SendWeaponAnim( int iActivity );
+	virtual void	Precache( void );
+	virtual bool	CanBeSelected( void );
+	virtual Activity GetDeployActivity( void );
+	virtual bool	DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt );
+	virtual void 	DefaultTouch( CBaseEntity *pOther );	// default weapon touch
+	virtual bool	DefaultPistolReload();
+
+	virtual bool	Deploy();
+	virtual void	Drop( const Vector &vecVelocity );
+	bool PlayEmptySound();
+	virtual void	ItemPostFrame();
+
+	virtual const char		*GetViewModel( int viewmodelindex = 0 ) const;
+
+
+	bool	m_bDelayFire;			// This variable is used to delay the time between subsequent button pressing.
+	float	m_flAccuracy;
+	
+	void SetExtraAmmoCount( int count ) { m_iExtraPrimaryAmmo = count; }
+	int GetExtraAmmoCount( void ) { return m_iExtraPrimaryAmmo; }
+
+private:
+
+	float	m_flDecreaseShotsFired;
+
+	CWeaponCSBase( const CWeaponCSBase & );
+
+	int		m_iExtraPrimaryAmmo;
+
+	float	m_nextPrevOwnerTouchTime;
+	CMomentumPlayer *m_prevOwner;
+
+	int m_iDefaultExtraAmmo;
+};
+
+
+#endif // WEAPON_CSBASE_H
diff --git a/mp/src/game/shared/momentum/weapon_csbasegun.cpp b/mp/src/game/shared/momentum/weapon_csbasegun.cpp
new file mode 100644
index 000000000..517615cd1
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_csbasegun.cpp
@@ -0,0 +1,207 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "fx_cs_shared.h"
+#include "mom_player_shared.h"
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCSBaseGun, DT_WeaponCSBaseGun )
+
+BEGIN_NETWORK_TABLE( CWeaponCSBaseGun, DT_WeaponCSBaseGun )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCSBaseGun )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_csbase_gun, CWeaponCSBaseGun );
+
+
+
+CWeaponCSBaseGun::CWeaponCSBaseGun()
+{
+
+}
+
+void CWeaponCSBaseGun::Spawn()
+{
+	m_flAccuracy = 0.2;
+	m_bDelayFire = false;
+	m_zoomFullyActiveTime = -1.0f;
+
+	BaseClass::Spawn();
+}
+
+
+bool CWeaponCSBaseGun::Deploy()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	m_flAccuracy = 0.2;
+	pPlayer->m_iShotsFired = 0;
+	m_bDelayFire = false;
+	m_zoomFullyActiveTime = -1.0f;
+
+	return BaseClass::Deploy();
+}
+
+void CWeaponCSBaseGun::ItemPostFrame()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	//GOOSEMAN : Return zoom level back to previous zoom level before we fired a shot. This is used only for the AWP.
+	// And Scout.
+	if ( (m_flNextPrimaryAttack <= gpGlobals->curtime) && (pPlayer->m_bResumeZoom == TRUE) )
+	{
+#ifndef CLIENT_DLL
+		pPlayer->SetFOV( pPlayer, pPlayer->m_iLastZoom, 0.05f );
+		m_zoomFullyActiveTime = gpGlobals->curtime + 0.05f;// Make sure we think that we are zooming on the server so we don't get instant acc bonus
+
+		if ( pPlayer->GetFOV() == pPlayer->m_iLastZoom )
+		{
+			// return the fade level in zoom.
+			pPlayer->m_bResumeZoom = false;
+		}
+#endif
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+
+void CWeaponCSBaseGun::PrimaryAttack()
+{
+	// Derived classes should implement this and call CSBaseGunFire.
+	Assert( false );
+}
+
+bool CWeaponCSBaseGun::CSBaseGunFire( float flSpread, float flCycleTime, bool bPrimaryMode )
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	const CCSWeaponInfo &pCSInfo = GetCSWpnData();
+
+	m_bDelayFire = true;
+	pPlayer->m_iShotsFired++;
+	
+	// These modifications feed back into flSpread eventually.
+	if ( pCSInfo.m_flAccuracyDivisor != -1 )
+	{
+		int iShotsFired = pPlayer->m_iShotsFired;
+
+		if ( pCSInfo.m_bAccuracyQuadratic )
+			iShotsFired = iShotsFired * iShotsFired;
+		else
+			iShotsFired = iShotsFired * iShotsFired * iShotsFired;
+
+		m_flAccuracy = ( iShotsFired / pCSInfo.m_flAccuracyDivisor) + pCSInfo.m_flAccuracyOffset;
+		
+		if (m_flAccuracy > pCSInfo.m_flMaxInaccuracy)
+			m_flAccuracy = pCSInfo.m_flMaxInaccuracy;
+	}
+
+	// Out of ammo?
+	if ( m_iClip1 <= 0 )
+	{
+		if (m_bFireOnEmpty)
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return false;
+	}
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	m_iClip1--;
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		bPrimaryMode?Primary_Mode:Secondary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		flSpread );
+
+	DoFireEffects();
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + pCSInfo.m_flTimeToIdleAfterFire );
+	return true;
+}
+
+
+void CWeaponCSBaseGun::DoFireEffects()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	
+	if ( pPlayer )
+		 pPlayer->DoMuzzleFlash();
+}
+
+
+bool CWeaponCSBaseGun::Reload()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+		return false;
+
+	int iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+	if ( !iResult )
+		return false;
+
+	pPlayer->SetAnimation( PLAYER_RELOAD );
+
+#ifndef CLIENT_DLL
+	if ((iResult) && (pPlayer->GetFOV() != pPlayer->GetDefaultFOV()))
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV() );
+	}
+#endif
+
+	m_flAccuracy = 0.2;
+	pPlayer->m_iShotsFired = 0;
+	m_bDelayFire = false;
+
+	//pPlayer->SetShieldDrawnState( false );
+	return true;
+}
+
+void CWeaponCSBaseGun::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if ( m_iClip1 != 0 )
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + GetCSWpnData().m_flIdleInterval );
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
diff --git a/mp/src/game/shared/momentum/weapon_csbasegun.h b/mp/src/game/shared/momentum/weapon_csbasegun.h
new file mode 100644
index 000000000..a44c63600
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_csbasegun.h
@@ -0,0 +1,59 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_CSBASE_GUN_H
+#define WEAPON_CSBASE_GUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+// This is the base class for pistols and rifles.
+#if defined( CLIENT_DLL )
+
+	#define CWeaponCSBaseGun C_WeaponCSBaseGun
+
+#else
+#endif
+
+
+class CWeaponCSBaseGun : public CWeaponCSBase
+{
+public:
+	
+	DECLARE_CLASS( CWeaponCSBaseGun, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponCSBaseGun();
+
+	virtual void PrimaryAttack();
+	virtual void Spawn();
+	virtual bool Deploy();
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+
+	// Derived classes call this to fire a bullet.
+	bool CSBaseGunFire( float flSpread, float flCycleTime, bool bPrimaryMode );
+
+	// Usually plays the shot sound. Guns with silencers can play different sounds.
+	virtual void DoFireEffects();
+	virtual void ItemPostFrame();
+
+protected: 
+	float m_zoomFullyActiveTime;
+
+private:
+
+	CWeaponCSBaseGun( const CWeaponCSBaseGun & );
+};
+
+
+#endif // WEAPON_CSBASE_GUN_H
diff --git a/mp/src/game/shared/momentum/weapon_flashbang.cpp b/mp/src/game/shared/momentum/weapon_flashbang.cpp
new file mode 100644
index 000000000..a42a8d41e
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_flashbang.cpp
@@ -0,0 +1,57 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_flashbang.h"
+
+
+#ifndef CLIENT_DLL
+
+	//#include "cs_player.h"
+	#include "items.h"
+	#include "momentum/flashbang_projectile.h"
+
+#endif
+
+
+#define GRENADE_TIMER	3.0f //Seconds
+
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Flashbang, DT_Flashbang )
+
+BEGIN_NETWORK_TABLE(CFlashbang, DT_Flashbang)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CFlashbang )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_flashbang, CFlashbang );
+PRECACHE_WEAPON_REGISTER( weapon_flashbang );
+
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CFlashbang )
+	END_DATADESC()
+
+	void CFlashbang::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		CFlashbangProjectile::Create( 
+			vecSrc,
+			vecAngles,
+			vecVel,
+			angImpulse,
+			pPlayer );
+	}
+
+#endif
+
+
diff --git a/mp/src/game/shared/momentum/weapon_flashbang.h b/mp/src/game/shared/momentum/weapon_flashbang.h
new file mode 100644
index 000000000..047fe12a0
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_flashbang.h
@@ -0,0 +1,49 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_FLASHBANG_H
+#define WEAPON_FLASHBANG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	#define CFlashbang C_Flashbang
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Fragmentation grenades
+//-----------------------------------------------------------------------------
+class CFlashbang : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CFlashbang, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CFlashbang() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_FLASHBANG; }
+
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+		virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+#endif
+
+	CFlashbang( const CFlashbang & ) {}
+};
+
+
+#endif // WEAPON_FLASHBANG_H
diff --git a/mp/src/game/shared/momentum/weapon_hegrenade.cpp b/mp/src/game/shared/momentum/weapon_hegrenade.cpp
new file mode 100644
index 000000000..ff38fe79f
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_hegrenade.cpp
@@ -0,0 +1,50 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_hegrenade.h"
+#include "basegrenade_shared.h"
+
+
+#ifndef CLIENT_DLL
+
+#include "hierarchy.h"
+#include "items.h"
+#include "momentum/hegrenade_projectile.h"
+
+#endif
+
+#define GRENADE_TIMER	3.0f //Seconds
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED(HEGrenade, DT_HEGrenade)
+
+BEGIN_NETWORK_TABLE(CHEGrenade, DT_HEGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CHEGrenade)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_hegrenade, CHEGrenade);
+PRECACHE_WEAPON_REGISTER(weapon_hegrenade);
+
+
+#ifndef CLIENT_DLL
+
+BEGIN_DATADESC(CHEGrenade)
+END_DATADESC()
+
+void CHEGrenade::EmitGrenade(Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer)
+{
+    CHEGrenadeProjectile::Create(vecSrc, vecAngles, vecVel, angImpulse, pPlayer, GRENADE_TIMER);
+}
+
+#endif
+
diff --git a/mp/src/game/shared/momentum/weapon_hegrenade.h b/mp/src/game/shared/momentum/weapon_hegrenade.h
new file mode 100644
index 000000000..5bc385939
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_hegrenade.h
@@ -0,0 +1,50 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_HEGRENADE_H
+#define WEAPON_HEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CHEGrenade C_HEGrenade
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Fragmentation grenades
+//-----------------------------------------------------------------------------
+class CHEGrenade : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CHEGrenade, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CHEGrenade() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_HEGRENADE; }
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+	
+#endif
+
+	CHEGrenade( const CHEGrenade & ) {}
+};
+
+
+#endif // WEAPON_HEGRENADE_H
diff --git a/mp/src/game/shared/momentum/weapon_knife.cpp b/mp/src/game/shared/momentum/weapon_knife.cpp
new file mode 100644
index 000000000..ac30d69ab
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_knife.cpp
@@ -0,0 +1,489 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_knife.h"
+#include "mom_player_shared.h"
+
+#ifndef CLIENT_DLL 
+	#include "ilagcompensationmanager.h"
+#endif
+
+
+#define	KNIFE_BODYHIT_VOLUME 128
+#define	KNIFE_WALLHIT_VOLUME 512
+
+
+Vector head_hull_mins( -16, -16, -18 );
+Vector head_hull_maxs( 16, 16, 18 );
+
+#ifndef CLIENT_DLL
+	//-----------------------------------------------------------------------------
+	// Purpose: Only send to local player if this weapon is the active weapon
+	// Input  : *pStruct - 
+	//			*pVarData - 
+	//			*pRecipients - 
+	//			objectID - 
+	// Output : void*
+	//-----------------------------------------------------------------------------
+	void* SendProxy_SendActiveLocalKnifeDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+	{
+		// Get the weapon entity
+		CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData;
+		if ( pWeapon )
+		{
+			// Only send this chunk of data to the player carrying this weapon
+			CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() );
+			if ( pPlayer /*&& pPlayer->GetActiveWeapon() == pWeapon*/ )
+			{
+				pRecipients->SetOnly( pPlayer->GetClientIndex() );
+				return (void*)pVarData;
+			}
+		}
+		
+		return NULL;
+	}
+	REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendActiveLocalKnifeDataTable );
+#endif
+
+// ----------------------------------------------------------------------------- //
+// CKnife tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Knife, DT_WeaponKnife )
+
+BEGIN_NETWORK_TABLE_NOBASE( CKnife, DT_LocalActiveWeaponKnifeData )
+	#if !defined( CLIENT_DLL )
+		SendPropTime( SENDINFO( m_flSmackTime ) ),
+	#else
+		RecvPropTime( RECVINFO( m_flSmackTime ) ),
+	#endif
+END_NETWORK_TABLE()
+
+
+BEGIN_NETWORK_TABLE( CKnife, DT_WeaponKnife )
+	#if !defined( CLIENT_DLL )
+		SendPropDataTable("LocalActiveWeaponKnifeData", 0, &REFERENCE_SEND_TABLE(DT_LocalActiveWeaponKnifeData), SendProxy_SendActiveLocalKnifeDataTable ),
+	#else
+		RecvPropDataTable("LocalActiveWeaponKnifeData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalActiveWeaponKnifeData)),
+	#endif
+END_NETWORK_TABLE()
+
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CKnife )
+	DEFINE_PRED_FIELD( m_flSmackTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+
+LINK_ENTITY_TO_CLASS( weapon_knife, CKnife );
+PRECACHE_WEAPON_REGISTER( weapon_knife );
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CKnife )
+		DEFINE_FUNCTION( Smack )
+	END_DATADESC()
+
+#endif
+
+// ----------------------------------------------------------------------------- //
+// CKnife implementation.
+// ----------------------------------------------------------------------------- //
+
+CKnife::CKnife()
+{
+}
+
+
+bool CKnife::HasPrimaryAmmo()
+{
+	return true;
+}
+
+
+bool CKnife::CanBeSelected()
+{
+	return true;
+}
+
+void CKnife::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "Weapon_Knife.Deploy" );
+	PrecacheScriptSound( "Weapon_Knife.Slash" );
+	PrecacheScriptSound( "Weapon_Knife.Stab" );
+	PrecacheScriptSound( "Weapon_Knife.Hit" );
+}
+
+void CKnife::Spawn()
+{
+	Precache();
+
+	m_iClip1 = -1;
+	BaseClass::Spawn();
+}
+
+
+bool CKnife::Deploy()
+{
+	CPASAttenuationFilter filter( this );
+	filter.UsePredictionRules();
+	EmitSound( filter, entindex(), "Weapon_Knife.Deploy" );
+
+	return BaseClass::Deploy();
+}
+
+void CKnife::Holster( int skiplocal )
+{
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->m_flNextAttack = gpGlobals->curtime + 0.5;
+	}
+}
+
+void CKnife::WeaponAnimation ( int iAnimation )
+{
+	/*
+	int flag;
+	#if defined( CLIENT_WEAPONS )
+		flag = FEV_NOTHOST;
+	#else
+		flag = 0;
+	#endif
+
+	PLAYBACK_EVENT_FULL( flag, pPlayer->edict(), m_usKnife,
+		0.0, (float *)&g_vecZero, (float *)&g_vecZero, 
+		0.0,
+		0.0,
+		iAnimation, 2, 3, 4 );
+	*/
+}
+
+void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity )
+{
+	int			i, j, k;
+	float		distance;
+	Vector minmaxs[2] = {mins, maxs};
+	trace_t tmpTrace;
+	Vector		vecHullEnd = tr.endpos;
+	Vector		vecEnd;
+
+	distance = 1e6f;
+
+	vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
+	UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
+	if ( tmpTrace.fraction < 1.0 )
+	{
+		tr = tmpTrace;
+		return;
+	}
+
+	for ( i = 0; i < 2; i++ )
+	{
+		for ( j = 0; j < 2; j++ )
+		{
+			for ( k = 0; k < 2; k++ )
+			{
+				vecEnd.x = vecHullEnd.x + minmaxs[i][0];
+				vecEnd.y = vecHullEnd.y + minmaxs[j][1];
+				vecEnd.z = vecHullEnd.z + minmaxs[k][2];
+
+				UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
+				if ( tmpTrace.fraction < 1.0 )
+				{
+					float thisDistance = (tmpTrace.endpos - vecSrc).Length();
+					if ( thisDistance < distance )
+					{
+						tr = tmpTrace;
+						distance = thisDistance;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+void CKnife::PrimaryAttack()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( pPlayer )
+	{
+#if !defined (CLIENT_DLL)
+		// Move other players back to history positions based on local player's lag
+		lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+		SwingOrStab( false );
+#if !defined (CLIENT_DLL)
+		lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+	}
+}
+
+void CKnife::SecondaryAttack()
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( pPlayer /*&& !pPlayer->m_bIsDefusing && !CSGameRules()->IsFreezePeriod()*/ )
+	{
+#if !defined (CLIENT_DLL)
+		// Move other players back to history positions based on local player's lag
+		lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+		SwingOrStab( true );
+#if !defined (CLIENT_DLL)
+		lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+	}
+}
+
+#include "effect_dispatch_data.h"
+
+void CKnife::Smack( void )
+{
+	if ( !GetPlayerOwner() )
+		return;
+
+	m_trHit.m_pEnt = m_pTraceHitEnt;
+
+	if ( !m_trHit.m_pEnt || (m_trHit.surface.flags & SURF_SKY) )
+		return;
+
+	if ( m_trHit.fraction == 1.0 )
+		return;
+
+	if ( m_trHit.m_pEnt )
+	{
+		CPASAttenuationFilter filter( this );
+		filter.UsePredictionRules();
+
+		if( m_trHit.m_pEnt->IsPlayer()  )
+		{
+			EmitSound( filter, entindex(), m_bStab?"Weapon_Knife.Stab":"Weapon_Knife.Hit" );
+		}
+		else
+		{
+			EmitSound( filter, entindex(), "Weapon_Knife.HitWall" );
+		}
+	}
+
+	CEffectData data;
+	data.m_vOrigin = m_trHit.endpos;
+	data.m_vStart = m_trHit.startpos;
+	data.m_nSurfaceProp = m_trHit.surface.surfaceProps;
+	data.m_nDamageType = DMG_SLASH;
+	data.m_nHitBox = m_trHit.hitbox;
+#ifdef CLIENT_DLL
+	data.m_hEntity = m_trHit.m_pEnt->GetRefEHandle();
+#else
+	data.m_nEntIndex = m_trHit.m_pEnt->entindex();
+#endif
+
+	CPASFilter filter( data.m_vOrigin );
+	
+#ifndef CLIENT_DLL
+	filter.RemoveRecipient( GetPlayerOwner() );
+#endif
+
+	data.m_vAngles = GetPlayerOwner()->GetAbsAngles();
+	data.m_fFlags = 0x1;	//IMPACT_NODECAL;
+	te->DispatchEffect( filter, 0.0, data.m_vOrigin, "KnifeSlash", data );
+}
+
+void CKnife::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	//if ( pPlayer->IsShieldDrawn() )
+	//	 return;
+
+	SetWeaponIdleTime( gpGlobals->curtime + 20 );
+
+	// only idle if the slid isn't back
+	SendWeaponAnim( ACT_VM_IDLE );
+}
+
+
+
+
+bool CKnife::SwingOrStab( bool bStab )
+{
+	CMomentumPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	float fRange = bStab ? 32 : 48; // knife range
+	
+	Vector vForward; AngleVectors( pPlayer->EyeAngles(), &vForward );
+	Vector vecSrc	= pPlayer->Weapon_ShootPosition();
+	Vector vecEnd	= vecSrc + vForward * fRange;
+
+	trace_t tr;
+	UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+
+	//check for hitting glass - TODO - fix this hackiness, doesn't always line up with what FindHullIntersection returns
+#ifndef CLIENT_DLL
+	CTakeDamageInfo glassDamage( pPlayer, pPlayer, 42.0f, DMG_BULLET | DMG_NEVERGIB );
+	TraceAttackToTriggers( glassDamage, tr.startpos, tr.endpos, vForward );
+#endif
+
+	if ( tr.fraction >= 1.0 )
+	{
+		UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+		if ( tr.fraction < 1.0 )
+		{
+			// Calculate the point of intersection of the line (or hull) and the object we hit
+			// This is and approximation of the "best" intersection
+			CBaseEntity *pHit = tr.m_pEnt;
+			if ( !pHit || pHit->IsBSPModel() )
+				FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, pPlayer );
+			vecEnd = tr.endpos;	// This is the point on the actual surface (the hull could have hit space)
+		}
+	}
+
+	bool bDidHit = tr.fraction < 1.0f;
+
+#ifndef CLIENT_DLL
+	bool bFirstSwing = (m_flNextPrimaryAttack + 0.4) < gpGlobals->curtime;
+#endif
+
+	float fPrimDelay, fSecDelay;
+
+	if ( bStab )
+	{
+		SendWeaponAnim( bDidHit ? ACT_VM_HITCENTER : ACT_VM_MISSCENTER );
+
+		fPrimDelay = fSecDelay = bDidHit ? 1.1f : 1.0f;
+
+		//pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_PRIMARY );
+	}
+	else // swing
+	{
+		SendWeaponAnim( bDidHit ? ACT_VM_HITCENTER : ACT_VM_MISSCENTER );
+
+		fPrimDelay = bDidHit ? 0.5f : 0.4f;
+		fSecDelay = bDidHit ? 0.5f : 0.5f;
+
+		//pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_SECONDARY );
+	}
+
+	//if ( pPlayer->HasShield() )
+	//{
+	//	fPrimDelay += 0.7f; // 0.7 seconds slower if we carry a shield
+	//	fSecDelay += 0.7f;
+	//}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + fPrimDelay;
+	m_flNextSecondaryAttack = gpGlobals->curtime + fSecDelay;
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+	
+	if ( !bDidHit )
+	{
+		// play wiff or swish sound
+		CPASAttenuationFilter filter( this );
+		filter.UsePredictionRules();
+		EmitSound( filter, entindex(), "Weapon_Knife.Slash" );
+	}
+
+	
+#ifndef CLIENT_DLL
+
+	if ( bDidHit )
+	{
+		// play thwack, smack, or dong sound
+
+		CBaseEntity *pEntity = tr.m_pEnt;
+				
+		// player "shoot" animation
+		pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+		ClearMultiDamage();
+		
+		float flDamage = 42.0f;
+
+		if ( bStab )
+		{
+			flDamage = 65.0f;
+
+			if ( pEntity && pEntity->IsPlayer() )
+			{
+				Vector vTragetForward;
+
+				AngleVectors( pEntity->GetAbsAngles(), &vTragetForward );
+				
+				Vector2D vecLOS = (pEntity->GetAbsOrigin() - pPlayer->GetAbsOrigin()).AsVector2D();
+				Vector2DNormalize( vecLOS );
+
+				float flDot = vecLOS.Dot( vTragetForward.AsVector2D() );
+
+				//Triple the damage if we are stabbing them in the back.
+				if ( flDot > 0.80f )
+					 flDamage *= 3;
+			}
+		}
+		else
+		{
+			if ( bFirstSwing )
+			{
+				// first swing does full damage
+				flDamage = 20;
+			}
+			else
+			{
+				// subsequent swings do less	
+				flDamage = 15;
+			}
+		}
+
+		CTakeDamageInfo info( pPlayer, pPlayer, flDamage, DMG_BULLET | DMG_NEVERGIB );
+
+		CalculateMeleeDamageForce( &info, vForward, tr.endpos, 1.0f/flDamage );
+		pEntity->DispatchTraceAttack( info, vForward, &tr ); 
+		ApplyMultiDamage();
+	}
+
+#endif
+
+	if ( bDidHit )
+	{
+		// delay the decal a bit
+		m_trHit = tr;
+		
+		// Store the ent in an EHANDLE, just in case it goes away by the time we get into our think function.
+		m_pTraceHitEnt = tr.m_pEnt; 
+
+		m_bStab = bStab;	//store this so we know what hit sound to play
+
+		m_flSmackTime = gpGlobals->curtime + (bStab?0.2f:0.1f);
+	}
+
+	return bDidHit;
+}
+
+void CKnife::ItemPostFrame( void )
+{
+	if( m_flSmackTime > 0 && gpGlobals->curtime > m_flSmackTime )
+	{
+		Smack();
+		m_flSmackTime = -1;
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+bool CKnife::CanDrop()
+{
+	return false;
+}
+
+
diff --git a/mp/src/game/shared/momentum/weapon_knife.h b/mp/src/game/shared/momentum/weapon_knife.h
new file mode 100644
index 000000000..2795e629a
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_knife.h
@@ -0,0 +1,80 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_KNIFE_H
+#define WEAPON_KNIFE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CKnife C_Knife
+
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CKnife class definition.
+// ----------------------------------------------------------------------------- //
+
+class CKnife : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CKnife, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	#ifndef CLIENT_DLL
+		DECLARE_DATADESC();
+	#endif
+
+	
+	CKnife();
+
+	// We say yes to this so the weapon system lets us switch to it.
+	virtual bool HasPrimaryAmmo();
+	virtual bool CanBeSelected();
+	
+	virtual void Precache();
+
+	void Spawn();
+	void Smack();
+	//void Smack( trace_t *pTr, float delay );
+	bool SwingOrStab( bool bStab );
+	void PrimaryAttack();
+	void SecondaryAttack();
+	void WeaponAnimation( int iAnimation );
+
+	virtual void ItemPostFrame( void );
+
+
+	bool Deploy();
+	void Holster( int skiplocal = 0 );
+	bool CanDrop();
+
+	void WeaponIdle();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_KNIFE; }
+
+public:
+	
+	trace_t m_trHit;
+	EHANDLE m_pTraceHitEnt;
+
+	CNetworkVar( float, m_flSmackTime );
+	bool	m_bStab;
+
+private:
+	CKnife( const CKnife & ) {}
+};
+
+
+#endif // WEAPON_KNIFE_H
diff --git a/mp/src/game/shared/momentum/weapon_momentum_gun.cpp b/mp/src/game/shared/momentum/weapon_momentum_gun.cpp
new file mode 100644
index 000000000..a00fa0e4a
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_momentum_gun.cpp
@@ -0,0 +1,437 @@
+#include "cbase.h"
+#include "npcevent.h"
+#include "in_buttons.h"
+#include "basecombatweapon_shared.h"
+#include "beam_shared.h"
+#include "mom_gamerules.h"
+#include "fx_cs_shared.h"
+
+#include "mom_player_shared.h"
+
+#include "tier0/memdbgon.h"
+
+//modify this to alter the rate of fire
+#define ROF 0.075f //RPS, 60 Sec / 800 Rounds = 0.075f
+
+//The gun will fire up to this number of bullets while you hold the fire button. 
+//If you set it to 1 the gun will be semi auto. If you set it to 3 the gun will fire three round bursts
+#define BURST 500
+
+#ifdef CLIENT_DLL
+#define CWeaponMomentumGun C_WeaponMomentumGun
+#endif
+
+//-----------------------------------------------------------------------------
+// CWeaponMomentumGun
+//-----------------------------------------------------------------------------
+class CWeaponMomentumGun : public CBaseCombatWeapon
+{
+public:
+
+    DECLARE_CLASS(CWeaponMomentumGun, CBaseCombatWeapon);
+    DECLARE_NETWORKCLASS();
+    DECLARE_PREDICTABLE();
+
+    CWeaponMomentumGun(void);
+
+    CNetworkVar(int, m_iBurst);
+    CNetworkVar(bool, m_bInZoom);
+    CNetworkVar(float, m_flAttackEnds);
+    CNetworkVar(int, m_iStance);
+
+    void Precache(void);
+    void ItemPostFrame(void);
+    //void ItemPreFrame(void);
+    void ItemBusyFrame(void);
+    void PrimaryAttack(void);
+    //void SecondaryAttack();
+    void AddViewKick(void);
+    void DryFire(void);
+    void DrawBeam(const Vector&, const Vector&, float);
+    bool Holster(CBaseCombatWeapon *pSwitchingTo = NULL); // Required so that you un-zoom when switching weapons
+    Activity GetPrimaryAttackActivity(void);
+    void DoImpactEffect(trace_t &tr, int nDamageType);
+
+    virtual bool Reload(void);
+
+    int GetMinBurst() { return 2; }
+    int GetMaxBurst() { return 5; }
+    float GetFireRate(void) { return ROF; }
+
+    //modify this part to control the general accuracy of the gun
+
+    virtual const Vector& GetBulletSpread(void);
+
+    void ToggleZoom(void);
+    void CheckZoomToggle(void);
+
+    DECLARE_ACTTABLE();
+
+private:
+    CWeaponMomentumGun(const CWeaponMomentumGun &);
+};
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED(WeaponMomentumGun, DT_WeaponMomentumGun)
+
+BEGIN_NETWORK_TABLE(CWeaponMomentumGun, DT_WeaponMomentumGun)
+#ifdef CLIENT_DLL
+RecvPropInt(RECVINFO(m_iBurst)),
+RecvPropBool(RECVINFO(m_bInZoom)),
+RecvPropTime(RECVINFO(m_flAttackEnds)),
+RecvPropInt(RECVINFO(m_iStance)),
+#else
+SendPropInt(SENDINFO(m_iBurst)),
+SendPropBool(SENDINFO(m_bInZoom)),
+SendPropTime(SENDINFO(m_flAttackEnds)),
+SendPropInt(SENDINFO(m_iStance)),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA(CWeaponMomentumGun)
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(weapon_momentum_gun, CWeaponMomentumGun);
+PRECACHE_WEAPON_REGISTER(weapon_momentum_gun);
+
+acttable_t CWeaponMomentumGun::m_acttable[] =
+{
+    { ACT_MP_STAND_IDLE, ACT_HL2MP_IDLE_AR2, false },
+    { ACT_MP_CROUCH_IDLE, ACT_HL2MP_IDLE_CROUCH_AR2, false },
+    { ACT_MP_RUN, ACT_HL2MP_RUN_AR2, false },
+    { ACT_MP_CROUCHWALK, ACT_HL2MP_WALK_CROUCH_AR2, false },
+    { ACT_MP_ATTACK_STAND_PRIMARYFIRE, ACT_HL2MP_GESTURE_RANGE_ATTACK_AR2, false },
+    { ACT_MP_ATTACK_CROUCH_PRIMARYFIRE, ACT_HL2MP_GESTURE_RANGE_ATTACK_AR2, false },
+    { ACT_MP_RELOAD_STAND, ACT_HL2MP_GESTURE_RELOAD_AR2, false },
+    { ACT_MP_RELOAD_CROUCH, ACT_HL2MP_GESTURE_RELOAD_AR2, false },
+    { ACT_MP_JUMP, ACT_HL2MP_JUMP_AR2, false },
+};
+
+IMPLEMENT_ACTTABLE(CWeaponMomentumGun);
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponMomentumGun::CWeaponMomentumGun(void)
+{
+    m_iBurst = BURST;
+    m_iStance = 10;
+    m_fMinRange1 = 1;
+    m_fMaxRange1 = 1500;
+    m_fMinRange2 = 1;
+    m_fMaxRange2 = 200;
+    m_bFiresUnderwater = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Required for caching the entity during loading
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::Precache(void)
+{
+    BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The gun is empty, plays a clicking noise with a dryfire anim
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::DryFire(void)
+{
+    WeaponSound(EMPTY);
+    SendWeaponAnim(ACT_VM_DRYFIRE);
+    m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This happens if you click and hold the primary fire button
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::PrimaryAttack(void)
+{
+    //do we have any bullets left from the current burst cycle? 
+    if (m_iBurst != 0)
+    {
+        CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+        if (!pPlayer)
+        {
+            return;
+        }
+
+        WeaponSound(SINGLE);
+        pPlayer->DoMuzzleFlash();
+        SendWeaponAnim(ACT_VM_PRIMARYATTACK);
+        pPlayer->SetAnimation(PLAYER_ATTACK1);
+
+        // Each time the player fires the gun, reset the view punch.  
+        pPlayer->ViewPunchReset();
+
+        BaseClass::PrimaryAttack();
+
+        // We fired one shot, decrease the number of bullets available for this burst cycle 
+        m_iBurst--;
+        m_flNextPrimaryAttack = gpGlobals->curtime + ROF;
+        m_flAttackEnds = gpGlobals->curtime + SequenceDuration();
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::ItemBusyFrame(void)
+{
+    // Allow zoom toggling even when we're reloading
+    CheckZoomToggle();
+    BaseClass::ItemBusyFrame();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allows firing as fast as button is pressed
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::ItemPostFrame(void)
+{
+    BaseClass::ItemPostFrame();
+    if (m_bInReload)
+    {
+        return;
+    }
+
+    CBasePlayer *pOwner = ToBasePlayer(GetOwner());
+
+    if (pOwner == NULL)
+    {
+        return;
+    }
+
+    if (pOwner->m_nButtons & IN_ATTACK)
+    {
+        if (m_flAttackEnds < gpGlobals->curtime)
+        {
+            SendWeaponAnim(ACT_VM_IDLE);
+        }
+    }
+    else
+    {
+        //The firing cycle ended. Reset the burst counter to the max value
+        m_iBurst = BURST;
+        if ((pOwner->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack < gpGlobals->curtime) && (m_iClip1 <= 0))
+        {
+            DryFire();
+        }
+    }
+    CheckZoomToggle();
+    //check the character's current stance for the accuracy calculation
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: If we have bullets left then play the attack anim otherwise idle
+// Output : int
+//-----------------------------------------------------------------------------
+Activity CWeaponMomentumGun::GetPrimaryAttackActivity(void)
+{
+    if (m_iBurst != 0)
+    {
+        return ACT_VM_PRIMARYATTACK;
+    }
+    else
+    {
+        return ACT_VM_IDLE;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The gun is being reloaded 
+//-----------------------------------------------------------------------------
+bool CWeaponMomentumGun::Reload(void)
+{
+    bool fRet = DefaultReload(GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD);
+    if (fRet)
+    {
+        WeaponSound(RELOAD);
+        //ToBaseCombatCharacter(GetOwner())->DoAnimationEvent(PLAYERANIMEVENT_RELOAD);
+        //reset the burst counter to the default
+        m_iBurst = BURST;
+    }
+    return fRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Put away the gun and disable zoom if needed
+//----------------------------------------------------------------------------- 
+bool CWeaponMomentumGun::Holster(CBaseCombatWeapon *pSwitchingTo /* = NULL */)
+{
+    if (m_bInZoom)
+    {
+        ToggleZoom();
+    }
+    return BaseClass::Holster(pSwitchingTo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate the viewkick
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::AddViewKick(void)
+{
+    CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+    if (pPlayer == NULL)
+    {
+        return;
+    }
+
+    int iSeed = CBaseEntity::GetPredictionRandomSeed() & 255;
+    RandomSeed(iSeed);
+
+    QAngle viewPunch;
+
+    viewPunch.x = random->RandomFloat(0.25f, 0.5f);
+    viewPunch.y = random->RandomFloat(-.6f, .6f);
+    viewPunch.z = 0.0f;
+
+    //Add it to the view punch
+    pPlayer->ViewPunch(viewPunch);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Toggle the zoom by changing the client's FOV
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::ToggleZoom(void)
+{
+    CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+
+    if (pPlayer == NULL)
+    {
+        return;
+    }
+
+#ifndef CLIENT_DLL
+    if (m_bInZoom)
+    {
+        // Narrowing the Field Of View here is what gives us the zoomed effect
+        if (pPlayer->SetFOV(this, 0, 0.2f))
+        {
+            m_bInZoom = false;
+
+            // Send a message to hide the scope
+            /* CSingleUserRecipientFilter filter(pPlayer);
+            UserMessageBegin(filter, "ShowScope");
+            WRITE_BYTE(0);
+            MessageEnd();*/
+        }
+    }
+    else
+    {
+        if (pPlayer->SetFOV(this, 45, 0.1f))
+        {
+            m_bInZoom = true;
+
+            // Send a message to Show the scope
+            /* CSingleUserRecipientFilter filter(pPlayer);
+            UserMessageBegin(filter, "ShowScope");
+            WRITE_BYTE(1);
+            MessageEnd();*/
+        }
+    }
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Toggle the zoom if the Sec attack button was pressed
+//-----------------------------------------------------------------------------
+void CWeaponMomentumGun::CheckZoomToggle(void)
+{
+    CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
+    if (pPlayer && (pPlayer->m_afButtonPressed & IN_ATTACK2))
+    {
+        ToggleZoom();
+    }
+}
+
+const Vector& CWeaponMomentumGun::GetBulletSpread(void)
+{
+    static Vector cone;
+    cone = VECTOR_CONE_1DEGREES;
+    //TODO override this with CSS weapon pickups ingame
+
+
+    //This part simlates recoil. Each successive shot will have increased spread.
+    if (m_iBurst != BURST)
+    {
+        for (int i = m_iBurst; i < BURST; i++)
+        {
+            cone += VECTOR_CONE_1DEGREES;
+        }
+    }
+
+    //This part is the zoom modifier. If in zoom, lower the bullet spread.
+    if (m_bInZoom)
+    {
+        cone -= VECTOR_CONE_1DEGREES;
+    }
+
+    return cone;
+}
+
+void CWeaponMomentumGun::DrawBeam(const Vector &startPos, const Vector &endPos, float width)
+{
+    //Tracer down the middle
+    UTIL_Tracer(startPos, endPos, 0, TRACER_DONT_USE_ATTACHMENT, 6500, false, "GaussTracer");
+
+    //Draw the main beam shaft
+    CBeam *pBeam = CBeam::BeamCreate("sprites/orangelight1.vmt", 15.5);
+
+    // It starts at startPos
+    pBeam->SetStartPos(startPos);
+
+    // This sets up some things that the beam uses to figure out where
+    // it should start and end
+    pBeam->PointEntInit(endPos, this);
+
+    // This makes it so that the laser appears to come from the muzzle of the pistol
+    pBeam->SetEndAttachment(LookupAttachment("1"));
+    pBeam->SetWidth(width);
+    //	pBeam->SetEndWidth( 0.05f );
+
+    // Higher brightness means less transparent
+    pBeam->SetBrightness(255);
+    pBeam->SetColor(255, 185 + random->RandomInt(-16, 16), 40);
+    pBeam->RelinkBeam();
+
+    // The beam should only exist for a very short time
+    pBeam->LiveForTime(0.1f);
+}
+
+void CWeaponMomentumGun::DoImpactEffect(trace_t &tr, int nDamageType)
+{
+    CMomentumPlayer *pPlayer = static_cast<CMomentumPlayer *>(GetOwner());
+
+    FX_FireBullets(
+        1,
+        pPlayer->Weapon_ShootPosition(),
+        pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+        27,//GetWeaponID(),//WEAPON_AK47
+        0,
+        CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+        0.05);
+
+    //Draw our beam
+    DrawBeam(tr.startpos, tr.endpos, 15.5);
+    if ((tr.surface.flags & SURF_SKY) == false)
+    {
+        CPVSFilter filter(tr.endpos);
+        te->GaussExplosion(filter, 0.0f, tr.endpos, tr.plane.normal, 0);
+        //UTIL_ImpactTrace(&tr, DMG_BULLET);
+        //m_nBulletType = GetAmmoDef()->Index("GaussEnergy");
+        //UTIL_ImpactTrace(&tr, m_nBulletType);
+    }
+}
+
+#ifdef GAME_DLL
+CON_COMMAND(holster_weapon, "Holster test.")
+{
+    CBasePlayer* pPlayer = UTIL_GetLocalPlayer();
+    if (pPlayer)
+    {
+        CBaseCombatWeapon* active = pPlayer->GetActiveWeapon();
+        if (active)
+            active->SetWeaponVisible(!active->IsWeaponVisible());
+    }
+}
+#endif // GAME_DLL
\ No newline at end of file
diff --git a/mp/src/game/shared/momentum/weapon_smokegrenade.cpp b/mp/src/game/shared/momentum/weapon_smokegrenade.cpp
new file mode 100644
index 000000000..652c68d27
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_smokegrenade.cpp
@@ -0,0 +1,46 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_smokegrenade.h"
+#include "mom_player_shared.h"
+
+#ifndef CLIENT_DLL
+	//#include "cs_player.h"
+	#include "items.h"
+	#include "momentum/smokegrenade_projectile.h"
+
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( SmokeGrenade, DT_SmokeGrenade )
+
+BEGIN_NETWORK_TABLE(CSmokeGrenade, DT_SmokeGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CSmokeGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_smokegrenade, CSmokeGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_smokegrenade );
+
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CSmokeGrenade )
+	END_DATADESC()
+
+	void CSmokeGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		CSmokeGrenadeProjectile::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer );
+	}
+
+#endif
+
diff --git a/mp/src/game/shared/momentum/weapon_smokegrenade.h b/mp/src/game/shared/momentum/weapon_smokegrenade.h
new file mode 100644
index 000000000..d12c68fbb
--- /dev/null
+++ b/mp/src/game/shared/momentum/weapon_smokegrenade.h
@@ -0,0 +1,52 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_SMOKEGRENADE_H
+#define WEAPON_SMOKEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CSmokeGrenade C_SmokeGrenade
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Smoke grenades
+//-----------------------------------------------------------------------------
+class CSmokeGrenade : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CSmokeGrenade, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CSmokeGrenade() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const { return WEAPON_SMOKEGRENADE; }
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+	void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+
+#endif
+
+	CSmokeGrenade( const CSmokeGrenade & ) {}
+};
+
+
+#endif // WEAPON_SMOKEGRENADE_H