valve/source-sdk-2013
0
0
Fork 0
mirror of https://github.com/ValveSoftware/source-sdk-2013.git synced 2025-04-06 18:12:14 +00:00
Code Issues Projects Releases Packages Wiki Activity

momentum added source files

Browse source
This commit is contained in:
tuxxi 2016-02-09 17:51:39 -08:00
parent 6d64b8f4a7
commit a8f8656b3e
94 changed files with 23593 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
mp/game/momentum/gameinfo.txt
View file

@ -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:

661
mp/src/game/client/momentum/ClientTimesDisplay.cpp Normal file
View file

@ -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);
//}

128
mp/src/game/client/momentum/ClientTimesDisplay.h Normal file
View file

@ -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

54
mp/src/game/client/momentum/c_mom_player.cpp Normal file
View file

@ -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;
}

68
mp/src/game/client/momentum/c_mom_player.h Normal file
View file

@ -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

56
mp/src/game/client/momentum/c_te_shotgun_shot.cpp Normal file
View file

@ -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()

59
mp/src/game/client/momentum/client_events.cpp Normal file
View file

@ -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

13
mp/src/game/client/momentum/client_events.h Normal file
View file

@ -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

37
mp/src/game/client/momentum/fx_cs_impacts.cpp Normal file
View file

@ -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);

133
mp/src/game/client/momentum/fx_cs_muzzleflash.cpp Normal file
View file

@ -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);

56
mp/src/game/client/momentum/fx_cs_weaponfx.cpp Normal file
View file

@ -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);

1250
mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.cpp Normal file
View file

File diff suppressed because it is too large Load diff

200
mp/src/game/client/momentum/ui/MapSelection/BaseMapsPage.h Normal file
View file

@ -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

75
mp/src/game/client/momentum/ui/MapSelection/IMapList.h Normal file
View file

@ -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

20
mp/src/game/client/momentum/ui/MapSelection/IMapSelector.h Normal file
View file

@ -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

241
mp/src/game/client/momentum/ui/MapSelection/LocalMaps.cpp Normal file
View file

@ -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);
}

61
mp/src/game/client/momentum/ui/MapSelection/LocalMaps.h Normal file
View file

@ -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

47
mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.cpp Normal file
View file

@ -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);
}

24
mp/src/game/client/momentum/ui/MapSelection/MapContextMenu.h Normal file
View file

@ -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

804
mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.cpp Normal file
View file

@ -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;
}

119
mp/src/game/client/momentum/ui/MapSelection/MapInfoDialog.h Normal file
View file

@ -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

224
mp/src/game/client/momentum/ui/MapSelection/MapSelector.cpp Normal file
View file

@ -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();
}
}

30
mp/src/game/client/momentum/ui/MapSelection/MapSelector.h Normal file
View file

@ -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

489
mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.cpp Normal file
View file

@ -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;
}

132
mp/src/game/client/momentum/ui/MapSelection/MapSelectorDialog.h Normal file
View file

@ -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

304
mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.cpp Normal file
View file

@ -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;
}

75
mp/src/game/client/momentum/ui/MapSelection/OnlineMaps.h Normal file
View file

@ -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

56
mp/src/game/client/momentum/ui/MapSelection/pch_mapselection.h Normal file
View file

@ -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"

367
mp/src/game/client/momentum/ui/hud_cp_menu.cpp Normal file
View file

@ -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;
}

91
mp/src/game/client/momentum/ui/hud_cp_menu.h Normal file
View file

@ -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");
};

114
mp/src/game/client/momentum/ui/speedometer.cpp Normal file
View file

@ -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));
}
}

333
mp/src/game/client/momentum/ui/timer.cpp Normal file
View file

@ -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));
}

490
mp/src/game/server/momentum/Timer.cpp Normal file
View file

@ -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;

189
mp/src/game/server/momentum/Timer.h Normal file
View file

@ -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

314
mp/src/game/server/momentum/flashbang_projectile.cpp Normal file
View file

@ -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");
}

39
mp/src/game/server/momentum/flashbang_projectile.h Normal file
View file

@ -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

93
mp/src/game/server/momentum/hegrenade_projectile.cpp Normal file
View file

@ -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

46
mp/src/game/server/momentum/hegrenade_projectile.h Normal file
View file

@ -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

461
mp/src/game/server/momentum/mapzones.cpp Normal file
View file

@ -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;
}

77
mp/src/game/server/momentum/mapzones.h Normal file
View file

@ -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

558
mp/src/game/server/momentum/mapzones_edit.cpp Normal file
View file

@ -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;

58
mp/src/game/server/momentum/mapzones_edit.h Normal file
View file

@ -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

136
mp/src/game/server/momentum/mom_client.cpp Normal file
View file

@ -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");
}

110
mp/src/game/server/momentum/mom_player.cpp Normal file
View file

@ -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;
}

95
mp/src/game/server/momentum/mom_player.h Normal file
View file

@ -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

547
mp/src/game/server/momentum/mom_triggers.cpp Normal file
View file

@ -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);
}
}
//-----------------------------------------------------------------------------------------------

293
mp/src/game/server/momentum/mom_triggers.h Normal file
View file

@ -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

117
mp/src/game/server/momentum/server_events.cpp Normal file
View file

@ -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

18
mp/src/game/server/momentum/server_events.h Normal file
View file

@ -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

186
mp/src/game/server/momentum/smokegrenade_projectile.cpp Normal file
View file

@ -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" );
}
}

53
mp/src/game/server/momentum/smokegrenade_projectile.h Normal file
View file

@ -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

86
mp/src/game/server/momentum/te_shotgun_shot.cpp Normal file
View file

@ -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);
}

22
mp/src/game/server/momentum/te_shotgun_shot.h Normal file
View file

@ -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

141
mp/src/game/server/momentum/tickset.cpp Normal file
View file

@ -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;
}

89
mp/src/game/server/momentum/tickset.h Normal file
View file

@ -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

343
mp/src/game/shared/momentum/basecsgrenade_projectile.cpp Normal file
View file

@ -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

82
mp/src/game/shared/momentum/basecsgrenade_projectile.h Normal file
View file

@ -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

57
mp/src/game/shared/momentum/cs_ammodef.cpp Normal file
View file

@ -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 )
{
}
//-----------------------------------------------------------------------------

55
mp/src/game/shared/momentum/cs_ammodef.h Normal file
View file

@ -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

1035
mp/src/game/shared/momentum/cs_playeranimstate.cpp Normal file
View file

File diff suppressed because it is too large Load diff

78
mp/src/game/shared/momentum/cs_playeranimstate.h Normal file
View file

@ -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

434
mp/src/game/shared/momentum/cs_weapon_parse.cpp Normal file
View file

@ -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
}

189
mp/src/game/shared/momentum/cs_weapon_parse.h Normal file
View file

@ -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

264
mp/src/game/shared/momentum/fx_cs_shared.cpp Normal file
View file

@ -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();
}

30
mp/src/game/shared/momentum/fx_cs_shared.h Normal file
View file

@ -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

1204
mp/src/game/shared/momentum/mom_gamemovement.cpp Normal file
View file

File diff suppressed because it is too large Load diff

84
mp/src/game/shared/momentum/mom_gamemovement.h Normal file
View file

@ -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);
}

294
mp/src/game/shared/momentum/mom_gamerules.cpp Normal file
View file

@ -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

68
mp/src/game/shared/momentum/mom_gamerules.h Normal file
View file

@ -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

424
mp/src/game/shared/momentum/mom_player_shared.cpp Normal file
View file

@ -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);
}

24
mp/src/game/shared/momentum/mom_player_shared.h Normal file
View file

@ -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

21
mp/src/game/shared/momentum/mom_shareddefs.h Normal file
View file

@ -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

53
mp/src/game/shared/momentum/mom_usermessages.cpp Normal file
View file

@ -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();
}

143
mp/src/game/shared/momentum/util/mom_util.cpp Normal file
View file

@ -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;

36
mp/src/game/shared/momentum/util/mom_util.h Normal file
View file

@ -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

410
mp/src/game/shared/momentum/weapon_basecsgrenade.cpp Normal file
View file

@ -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

80
mp/src/game/shared/momentum/weapon_basecsgrenade.h Normal file
View file

@ -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

594
mp/src/game/shared/momentum/weapon_cs_heavy.cpp Normal file
View file

@ -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);
}
}
}

1596
mp/src/game/shared/momentum/weapon_cs_pistols.cpp Normal file
View file

File diff suppressed because it is too large Load diff

1665
mp/src/game/shared/momentum/weapon_cs_rifles.cpp Normal file
View file

File diff suppressed because it is too large Load diff

478
mp/src/game/shared/momentum/weapon_cs_smgs.cpp Normal file
View file

@ -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);
}

1519
mp/src/game/shared/momentum/weapon_csbase.cpp Normal file
View file

File diff suppressed because it is too large Load diff

217
mp/src/game/shared/momentum/weapon_csbase.h Normal file
View file

@ -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

207
mp/src/game/shared/momentum/weapon_csbasegun.cpp Normal file
View file

@ -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 );
}
}

59
mp/src/game/shared/momentum/weapon_csbasegun.h Normal file
View file

@ -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

57
mp/src/game/shared/momentum/weapon_flashbang.cpp Normal file
View file

@ -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

49
mp/src/game/shared/momentum/weapon_flashbang.h Normal file
View file

@ -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

50
mp/src/game/shared/momentum/weapon_hegrenade.cpp Normal file
View file

@ -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

50
mp/src/game/shared/momentum/weapon_hegrenade.h Normal file
View file

@ -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

489
mp/src/game/shared/momentum/weapon_knife.cpp Normal file
View file

@ -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;
}

80
mp/src/game/shared/momentum/weapon_knife.h Normal file
View file

@ -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

437
mp/src/game/shared/momentum/weapon_momentum_gun.cpp Normal file
View file

@ -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

46
mp/src/game/shared/momentum/weapon_smokegrenade.cpp Normal file
View file

@ -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

52
mp/src/game/shared/momentum/weapon_smokegrenade.h Normal file
View file

@ -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