367 lines
10 KiB
C++
367 lines
10 KiB
C++
/*
|
|
Copyright (c) 2013 yvt
|
|
based on code of pysnip (c) Mathias Kaerlev 2011-2012.
|
|
|
|
This file is part of OpenSpades.
|
|
|
|
OpenSpades is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OpenSpades is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <string>
|
|
#include "Player.h"
|
|
#include "IWorldListener.h"
|
|
#include "ILocalEntity.h"
|
|
#include <Core/Math.h>
|
|
#include <Core/ServerAddress.h>
|
|
#include "IRenderer.h"
|
|
#include <list>
|
|
#include <Gui/View.h>
|
|
#include <memory>
|
|
|
|
namespace spades {
|
|
class IStream;
|
|
namespace client {
|
|
class IRenderer;
|
|
struct SceneDefinition;
|
|
class GameMap;
|
|
class GameMapWrapper;
|
|
class World;
|
|
struct PlayerInput;
|
|
struct WeaponInput;
|
|
class IAudioDevice;
|
|
class IAudioChunk;
|
|
class NetClient;
|
|
class IFont;
|
|
class ChatWindow;
|
|
class CenterMessageView;
|
|
class Corpse;
|
|
class HurtRingView;
|
|
class MapView;
|
|
class ScoreboardView;
|
|
class LimboView;
|
|
class Player;
|
|
class PaletteView;
|
|
class TCProgressView;
|
|
class ClientPlayer;
|
|
|
|
class ClientUI;
|
|
|
|
class Client: public IWorldListener, public gui::View {
|
|
friend class ScoreboardView;
|
|
friend class LimboView;
|
|
friend class MapView;
|
|
friend class FallingBlock;
|
|
friend class PaletteView;
|
|
friend class TCProgressView;
|
|
friend class ClientPlayer;
|
|
friend class ClientUI;
|
|
|
|
/** used to keep the input state of keypad so that
|
|
* after user pressed left and right, and then
|
|
* released right, left is internally pressed. */
|
|
struct KeypadInput {
|
|
bool left, right, forward, backward;
|
|
KeypadInput():
|
|
left(false),right(false),
|
|
forward(false),backward(false){
|
|
}
|
|
};
|
|
|
|
std::unique_ptr<NetClient> net;
|
|
std::string playerName;
|
|
std::unique_ptr<IStream> logStream;
|
|
|
|
Handle<ClientUI> scriptedUI;
|
|
|
|
ServerAddress hostname;
|
|
|
|
std::unique_ptr<World> world;
|
|
Handle<GameMap> map;
|
|
std::unique_ptr<GameMapWrapper> mapWrapper;
|
|
Handle<IRenderer> renderer;
|
|
Handle<IAudioDevice> audioDevice;
|
|
float time;
|
|
bool readyToClose;
|
|
float worldSubFrame;
|
|
|
|
int frameToRendererInit;
|
|
float timeSinceInit;
|
|
|
|
// view/drawing state for some world objects
|
|
std::vector<Handle<ClientPlayer>> clientPlayers;
|
|
|
|
// other windows
|
|
std::unique_ptr<CenterMessageView> centerMessageView;
|
|
std::unique_ptr<HurtRingView> hurtRingView;
|
|
std::unique_ptr<MapView> mapView;
|
|
std::unique_ptr<MapView> largeMapView;
|
|
std::unique_ptr<ScoreboardView> scoreboard;
|
|
std::unique_ptr<LimboView> limbo;
|
|
std::unique_ptr<PaletteView> paletteView;
|
|
std::unique_ptr<TCProgressView> tcView;
|
|
|
|
// chat
|
|
std::unique_ptr<ChatWindow> chatWindow;
|
|
std::unique_ptr<ChatWindow> killfeedWindow;
|
|
|
|
// player state
|
|
PlayerInput playerInput;
|
|
WeaponInput weapInput;
|
|
KeypadInput keypadInput;
|
|
Vector3 lastFront;
|
|
float lastPosSentTime;
|
|
int lastHealth;
|
|
float lastHurtTime;
|
|
float lastAliveTime;
|
|
int lastKills;
|
|
float worldSetTime;
|
|
bool hasDelayedReload;
|
|
struct HurtSprite {
|
|
float angle;
|
|
float horzShift;
|
|
float scale;
|
|
float strength;
|
|
};
|
|
std::vector<HurtSprite> hurtSprites;
|
|
float GetAimDownState();
|
|
float GetSprintState();
|
|
|
|
float toolRaiseState;
|
|
void SetSelectedTool(Player::ToolType, bool quiet = false);
|
|
|
|
// view
|
|
SceneDefinition lastSceneDef;
|
|
float localFireVibrationTime;
|
|
float grenadeVibration;
|
|
bool scoreboardVisible;
|
|
bool flashlightOn;
|
|
float flashlightOnTime;
|
|
|
|
float hitFeedbackIconState;
|
|
bool hitFeedbackFriendly;
|
|
|
|
// when dead...
|
|
/** Following player ID, which may be local player itself */
|
|
int followingPlayerId;
|
|
float followYaw, followPitch;
|
|
/** only for when spectating */
|
|
Vector3 followPos;
|
|
/** only for when spectating */
|
|
Vector3 followVel;
|
|
void FollowNextPlayer(bool reverse);
|
|
/** @return true following is activated (and followingPlayerId should be used) */
|
|
bool IsFollowing();
|
|
|
|
bool inGameLimbo;
|
|
|
|
float GetLocalFireVibration();
|
|
void CaptureColor();
|
|
bool IsLimboViewActive();
|
|
void SpawnPressed();
|
|
|
|
Player *HotTrackedPlayer( hitTag_t* hitFlag );
|
|
|
|
// effects (local entity, etc)
|
|
std::vector<DynamicLightParam> flashDlights;
|
|
std::vector<DynamicLightParam> flashDlightsOld;
|
|
void Bleed(Vector3);
|
|
void EmitBlockFragments(Vector3, IntVector3 color);
|
|
void EmitBlockDestroyFragments(IntVector3, IntVector3 color);
|
|
void GrenadeExplosion(Vector3);
|
|
void GrenadeExplosionUnderwater(Vector3);
|
|
void MuzzleFire(Vector3, Vector3 dir, bool local);
|
|
void BulletHitWaterSurface(Vector3);
|
|
|
|
// drawings
|
|
Handle<IFont> designFont;
|
|
Handle<IFont> textFont;
|
|
Handle<IFont> bigTextFont;
|
|
|
|
enum class AlertType {
|
|
Notice,
|
|
Warning,
|
|
Error
|
|
};
|
|
AlertType alertType;
|
|
std::string alertContents;
|
|
float alertDisappearTime;
|
|
float alertAppearTime;
|
|
|
|
std::list<std::unique_ptr<ILocalEntity>> localEntities;
|
|
std::list<std::unique_ptr<Corpse>> corpses;
|
|
Corpse *lastMyCorpse;
|
|
float corpseSoftTimeLimit;
|
|
unsigned int corpseSoftLimit;
|
|
unsigned int corpseHardLimit;
|
|
void RemoveAllCorpses();
|
|
void RemoveInvisibleCorpses();
|
|
void RemoveAllLocalEntities();
|
|
|
|
int nextScreenShotIndex;
|
|
int nextMapShotIndex;
|
|
|
|
Vector3 Project(Vector3);
|
|
|
|
void DrawSplash();
|
|
void DrawStartupScreen();
|
|
void DoInit();
|
|
|
|
void ShowAlert(const std::string& contents,
|
|
AlertType type);
|
|
void ShowAlert(const std::string& contents,
|
|
AlertType type,
|
|
float timeout,
|
|
bool quiet = false);
|
|
void PlayAlertSound();
|
|
|
|
void UpdateWorld(float dt);
|
|
void UpdateLocalSpectator(float dt);
|
|
void UpdateLocalPlayer(float dt);
|
|
|
|
void Draw2D();
|
|
|
|
void Draw2DWithoutWorld();
|
|
void Draw2DWithWorld();
|
|
|
|
void DrawJoinedAlivePlayerHUD();
|
|
void DrawDeadPlayerHUD();
|
|
void DrawSpectateHUD();
|
|
|
|
void DrawHottrackedPlayerName();
|
|
void DrawHurtScreenEffect();
|
|
void DrawHurtSprites();
|
|
void DrawHealth();
|
|
void DrawAlert();
|
|
void DrawDebugAim();
|
|
|
|
void DrawScene();
|
|
void AddGrenadeToScene(Grenade *);
|
|
void AddDebugObjectToScene(const OBB3&,
|
|
const Vector4& col = MakeVector4(1,1,1,1));
|
|
void DrawCTFObjects();
|
|
void DrawTCObjects();
|
|
|
|
float GetAimDownZoomScale();
|
|
bool ShouldRenderInThirdPersonView();
|
|
SceneDefinition CreateSceneDefinition();
|
|
|
|
std::string ScreenShotPath();
|
|
void TakeScreenShot(bool sceneOnly);
|
|
|
|
std::string MapShotPath();
|
|
void TakeMapShot();
|
|
|
|
void NetLog(const char *format, ...);
|
|
protected:
|
|
virtual ~Client();
|
|
|
|
public:
|
|
Client(IRenderer *, IAudioDevice *,
|
|
const ServerAddress& host, std::string playerName);
|
|
|
|
virtual void RunFrame(float dt);
|
|
|
|
virtual void Closing();
|
|
virtual void MouseEvent(float x, float y);
|
|
virtual void WheelEvent(float x, float y);
|
|
virtual void KeyEvent(const std::string&,
|
|
bool down);
|
|
virtual void TextInputEvent(const std::string&);
|
|
virtual void TextEditingEvent(const std::string&,
|
|
int start, int len);
|
|
virtual bool AcceptsTextInput();
|
|
virtual AABB2 GetTextInputRect();
|
|
virtual bool NeedsAbsoluteMouseCoordinate();
|
|
|
|
void SetWorld(World *);
|
|
World *GetWorld() const { return world.get(); }
|
|
void AddLocalEntity(ILocalEntity *ent){
|
|
localEntities.emplace_back(ent);
|
|
}
|
|
|
|
IRenderer *GetRenderer() {return renderer;}
|
|
SceneDefinition GetLastSceneDef() { return lastSceneDef; }
|
|
IAudioDevice *GetAudioDevice() {return audioDevice; }
|
|
|
|
virtual bool WantsToBeClosed();
|
|
bool IsMuted();
|
|
|
|
void PlayerSentChatMessage(Player *, bool global,
|
|
const std::string&);
|
|
void ServerSentMessage(const std::string&);
|
|
|
|
void PlayerCapturedIntel(Player *);
|
|
void PlayerCreatedBlock(Player *);
|
|
void PlayerPickedIntel(Player *);
|
|
void PlayerDropIntel(Player *);
|
|
void TeamCapturedTerritory(int teamId, int territoryId);
|
|
void TeamWon(int);
|
|
void JoinedGame();
|
|
void LocalPlayerCreated();
|
|
void PlayerDestroyedBlockWithWeaponOrTool(IntVector3);
|
|
void PlayerDiggedBlock(IntVector3);
|
|
void GrenadeDestroyedBlock(IntVector3);
|
|
void PlayerLeaving(Player *);
|
|
void PlayerJoinedTeam(Player *);
|
|
|
|
virtual void PlayerObjectSet(int);
|
|
virtual void PlayerMadeFootstep(Player *);
|
|
virtual void PlayerJumped(Player *);
|
|
virtual void PlayerLanded(Player *, bool hurt);
|
|
virtual void PlayerFiredWeapon(Player *);
|
|
virtual void PlayerDryFiredWeapon(Player *);
|
|
virtual void PlayerReloadingWeapon(Player *);
|
|
virtual void PlayerReloadedWeapon(Player *);
|
|
virtual void PlayerChangedTool(Player *);
|
|
virtual void PlayerThrownGrenade(Player *, Grenade *);
|
|
virtual void PlayerMissedSpade(Player *);
|
|
virtual void PlayerRestocked(Player *);
|
|
|
|
/** @deprecated use BulletHitPlayer */
|
|
virtual void PlayerHitBlockWithSpade(Player *,
|
|
Vector3 hitPos,
|
|
IntVector3 blockPos,
|
|
IntVector3 normal);
|
|
virtual void PlayerKilledPlayer(Player *killer,
|
|
Player *victim,
|
|
KillType);
|
|
|
|
virtual void BulletHitPlayer(Player *hurtPlayer, HitType,
|
|
Vector3 hitPos,
|
|
Player *by);
|
|
virtual void BulletHitBlock(Vector3,
|
|
IntVector3 blockPos,
|
|
IntVector3 normal);
|
|
virtual void AddBulletTracer(Player *player,
|
|
Vector3 muzzlePos,
|
|
Vector3 hitPos);
|
|
virtual void GrenadeExploded(Grenade *);
|
|
virtual void GrenadeBounced(Grenade *);
|
|
virtual void GrenadeDroppedIntoWater(Grenade *);
|
|
|
|
virtual void BlocksFell(std::vector<IntVector3>);
|
|
|
|
virtual void LocalPlayerPulledGrenadePin();
|
|
virtual void LocalPlayerBlockAction(IntVector3, BlockActionType type);
|
|
virtual void LocalPlayerCreatedLineBlock(IntVector3, IntVector3);
|
|
virtual void LocalPlayerHurt(HurtType type, bool sourceGiven,
|
|
Vector3 source);
|
|
virtual void LocalPlayerBuildError(BuildFailureReason reason);
|
|
};
|
|
}
|
|
}
|