src/client/client.cpp

   1 #include "InitialState.hpp"
   2 #include "InteractiveState.hpp"
   3 #include "MasterState.hpp"
   4
   5 #include "../app/Environment.hpp"
   6 #include "../app/init.hpp"
   7 #include "../app/TextureIndex.hpp"
   8
   9 #include <iostream>
  10
  11
  12 namespace blank {
  13 namespace client {
  14
  15 InitialState::InitialState(MasterState &master)
  16 : master(master)
  17 , message() {
  18         message.Position(glm::vec3(0.0f), Gravity::CENTER);
  19         message.Set(master.GetEnv().assets.large_ui_font, "logging in");
  20 }
  21
  22 void InitialState::OnEnter() {
  23
  24 }
  25
  26 void InitialState::Handle(const SDL_Event &evt) {
  27         if (evt.type == SDL_QUIT) {
  28                 master.Quit();
  29         }
  30 }
  31
  32 void InitialState::Update(int dt) {
  33         master.Update(dt);
  34 }
  35
  36 void InitialState::Render(Viewport &viewport) {
  37         message.Render(viewport);
  38 }
  39
  40
  41 InteractiveState::InteractiveState(MasterState &master)
  42 : master(master)
  43 , block_types()
  44 , save(master.GetEnv().config.GetWorldPath(master.GetWorldConf().name, master.GetClientConf().host))
  45 , world(block_types, master.GetWorldConf(), save)
  46 , chunk_renderer(world, master.GetWorldConf().load.load_dist)
  47 , interface(master.GetInterfaceConf(), master.GetEnv(), world) {
  48         TextureIndex tex_index;
  49         master.GetEnv().loader.LoadBlockTypes("default", block_types, tex_index);
  50         chunk_renderer.LoadTextures(master.GetEnv().loader, tex_index);
  51         chunk_renderer.FogDensity(master.GetWorldConf().fog_density);
  52         // TODO: better solution for initializing HUD
  53         interface.SelectNext();
  54 }
  55
  56 void InteractiveState::OnEnter() {
  57         master.GetEnv().window.GrabMouse();
  58 }
  59
  60 void InteractiveState::Handle(const SDL_Event &event) {
  61         switch (event.type) {
  62                 case SDL_KEYDOWN:
  63                         interface.HandlePress(event.key);
  64                         break;
  65                 case SDL_KEYUP:
  66                         interface.HandleRelease(event.key);
  67                         break;
  68                 case SDL_MOUSEBUTTONDOWN:
  69                         interface.HandlePress(event.button);
  70                         break;
  71                 case SDL_MOUSEBUTTONUP:
  72                         interface.HandleRelease(event.button);
  73                         break;
  74                 case SDL_MOUSEMOTION:
  75                         interface.Handle(event.motion);
  76                         break;
  77                 case SDL_MOUSEWHEEL:
  78                         interface.Handle(event.wheel);
  79                         break;
  80                 case SDL_QUIT:
  81                         master.Quit();
  82                         break;
  83                 default:
  84                         break;
  85         }
  86 }
  87
  88 void InteractiveState::Update(int dt) {
  89         master.Update(dt);
  90
  91         interface.Update(dt);
  92         world.Update(dt);
  93         chunk_renderer.Rebase(interface.Player().ChunkCoords());
  94         chunk_renderer.Update(dt);
  95
  96         glm::mat4 trans = interface.Player().Transform(interface.Player().ChunkCoords());
  97         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
  98         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
  99         master.GetEnv().audio.Position(interface.Player().Position());
 100         master.GetEnv().audio.Velocity(interface.Player().Velocity());
 101         master.GetEnv().audio.Orientation(dir, up);
 102 }
 103
 104 void InteractiveState::Render(Viewport &viewport) {
 105         viewport.WorldPosition(interface.Player().Transform(interface.Player().ChunkCoords()));
 106         chunk_renderer.Render(viewport);
 107         world.Render(viewport);
 108         interface.Render(viewport);
 109 }
 110
 111
 112 MasterState::MasterState(
 113         Environment &env,
 114         const World::Config &wc,
 115         const Interface::Config &ic,
 116         const Client::Config &cc)
 117 : env(env)
 118 , world_conf(wc)
 119 , intf_conf(ic)
 120 , client_conf(cc)
 121 , state()
 122 , client(cc)
 123 , init_state(*this)
 124 , login_packet(-1) {
 125         client.GetConnection().SetHandler(this);
 126 }
 127
 128 void MasterState::Quit() {
 129         env.state.PopUntil(this);
 130 }
 131
 132
 133 void MasterState::OnEnter() {
 134         login_packet = client.SendLogin(intf_conf.player_name);
 135         env.state.Push(&init_state);
 136 }
 137
 138
 139 void MasterState::Handle(const SDL_Event &event) {
 140
 141 }
 142
 143
 144 void MasterState::Update(int dt) {
 145         client.Handle();
 146         client.Update(dt);
 147 }
 148
 149
 150 void MasterState::Render(Viewport &) {
 151
 152 }
 153
 154
 155 void MasterState::OnPacketLost(std::uint16_t id) {
 156         if (id == login_packet) {
 157                 login_packet = client.SendLogin(intf_conf.player_name);
 158         }
 159 }
 160
 161 void MasterState::OnTimeout() {
 162         if (client.GetConnection().Closed()) {
 163                 Quit();
 164                 // TODO: push disconnected message
 165         }
 166 }
 167
 168 void MasterState::On(const Packet::Join &pack) {
 169         pack.ReadWorldName(world_conf.name);
 170
 171         if (state) {
 172                 // changing worlds
 173                 std::cout << "server changing worlds" << std::endl;
 174         } else {
 175                 // joining game
 176                 std::cout << "joined game" << std::endl;
 177         }
 178         state.reset(new InteractiveState(*this));
 179
 180         pack.ReadPlayer(state->GetInterface().Player());
 181
 182         env.state.PopAfter(this);
 183         env.state.Push(state.get());
 184 }
 185
 186 void MasterState::On(const Packet::Part &pack) {
 187         if (state) {
 188                 // kicked
 189                 std::cout << "kicked by server" << std::endl;
 190         } else {
 191                 // join refused
 192                 std::cout << "login refused by server" << std::endl;
 193         }
 194         Quit();
 195 }
 196
 197 }
 198 }