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 #include "../model/CompositeModel.hpp"
   9
  10 #include <iostream>
  11 #include <glm/gtx/io.hpp>
  12
  13 using namespace std;
  14
  15
  16 namespace blank {
  17 namespace client {
  18
  19 InitialState::InitialState(MasterState &master)
  20 : master(master)
  21 , message() {
  22         message.Position(glm::vec3(0.0f), Gravity::CENTER);
  23         message.Set(master.GetEnv().assets.large_ui_font, "logging in");
  24 }
  25
  26 void InitialState::OnEnter() {
  27
  28 }
  29
  30 void InitialState::Handle(const SDL_Event &evt) {
  31         if (evt.type == SDL_QUIT) {
  32                 master.Quit();
  33         }
  34 }
  35
  36 void InitialState::Update(int dt) {
  37         master.Update(dt);
  38 }
  39
  40 void InitialState::Render(Viewport &viewport) {
  41         message.Render(viewport);
  42 }
  43
  44
  45 // TODO: this clutter is a giant mess
  46 InteractiveState::InteractiveState(MasterState &master, uint32_t player_id)
  47 : master(master)
  48 , block_types()
  49 , save(master.GetEnv().config.GetWorldPath(master.GetWorldConf().name, master.GetClientConf().host))
  50 , world(block_types, master.GetWorldConf())
  51 , interface(
  52         master.GetInterfaceConf(),
  53         master.GetEnv(),
  54         world,
  55         world.AddPlayer(master.GetInterfaceConf().player_name, player_id)
  56 )
  57 , chunk_renderer(*interface.GetPlayer().chunks)
  58 , skeletons() {
  59         TextureIndex tex_index;
  60         master.GetEnv().loader.LoadBlockTypes("default", block_types, tex_index);
  61         chunk_renderer.LoadTextures(master.GetEnv().loader, tex_index);
  62         chunk_renderer.FogDensity(master.GetWorldConf().fog_density);
  63         skeletons.Load();
  64         // TODO: better solution for initializing HUD
  65         interface.SelectNext();
  66 }
  67
  68 void InteractiveState::OnEnter() {
  69         master.GetEnv().window.GrabMouse();
  70 }
  71
  72 void InteractiveState::Handle(const SDL_Event &event) {
  73         switch (event.type) {
  74                 case SDL_KEYDOWN:
  75                         interface.HandlePress(event.key);
  76                         break;
  77                 case SDL_KEYUP:
  78                         interface.HandleRelease(event.key);
  79                         break;
  80                 case SDL_MOUSEBUTTONDOWN:
  81                         interface.HandlePress(event.button);
  82                         break;
  83                 case SDL_MOUSEBUTTONUP:
  84                         interface.HandleRelease(event.button);
  85                         break;
  86                 case SDL_MOUSEMOTION:
  87                         interface.Handle(event.motion);
  88                         break;
  89                 case SDL_MOUSEWHEEL:
  90                         interface.Handle(event.wheel);
  91                         break;
  92                 case SDL_QUIT:
  93                         master.Quit();
  94                         break;
  95                 default:
  96                         break;
  97         }
  98 }
  99
 100 void InteractiveState::Update(int dt) {
 101         master.Update(dt);
 102
 103         interface.Update(dt);
 104         world.Update(dt);
 105         chunk_renderer.Update(dt);
 106
 107         Entity &player = *interface.GetPlayer().entity;
 108
 109         master.GetClient().SendPlayerUpdate(player);
 110
 111         glm::mat4 trans = player.Transform(player.ChunkCoords());
 112         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
 113         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
 114         master.GetEnv().audio.Position(player.Position());
 115         master.GetEnv().audio.Velocity(player.Velocity());
 116         master.GetEnv().audio.Orientation(dir, up);
 117 }
 118
 119 void InteractiveState::Render(Viewport &viewport) {
 120         Entity &player = *interface.GetPlayer().entity;
 121         viewport.WorldPosition(player.Transform(player.ChunkCoords()));
 122         chunk_renderer.Render(viewport);
 123         world.Render(viewport);
 124         interface.Render(viewport);
 125 }
 126
 127
 128 MasterState::MasterState(
 129         Environment &env,
 130         const World::Config &wc,
 131         const Interface::Config &ic,
 132         const Client::Config &cc)
 133 : env(env)
 134 , world_conf(wc)
 135 , intf_conf(ic)
 136 , client_conf(cc)
 137 , state()
 138 , client(cc)
 139 , init_state(*this)
 140 , login_packet(-1)
 141 , update_status()
 142 , update_timer(16) {
 143         client.GetConnection().SetHandler(this);
 144         update_timer.Start();
 145 }
 146
 147 void MasterState::Quit() {
 148         if (!client.GetConnection().Closed()) {
 149                 client.SendPart();
 150         }
 151         env.state.PopUntil(this);
 152 }
 153
 154
 155 void MasterState::OnEnter() {
 156         login_packet = client.SendLogin(intf_conf.player_name);
 157         env.state.Push(&init_state);
 158 }
 159
 160
 161 void MasterState::Handle(const SDL_Event &event) {
 162
 163 }
 164
 165
 166 void MasterState::Update(int dt) {
 167         update_timer.Update(dt);
 168         client.Handle();
 169         client.Update(dt);
 170 }
 171
 172
 173 void MasterState::Render(Viewport &) {
 174
 175 }
 176
 177
 178 void MasterState::OnPacketLost(uint16_t id) {
 179         if (id == login_packet) {
 180                 login_packet = client.SendLogin(intf_conf.player_name);
 181         }
 182 }
 183
 184 void MasterState::OnTimeout() {
 185         if (client.GetConnection().Closed()) {
 186                 // TODO: push disconnected message
 187                 cout << "connection timed out" << endl;
 188                 Quit();
 189         }
 190 }
 191
 192 void MasterState::On(const Packet::Join &pack) {
 193         pack.ReadWorldName(world_conf.name);
 194
 195         if (state) {
 196                 // changing worlds
 197                 cout << "server changing worlds to \"" << world_conf.name << '"' << endl;
 198         } else {
 199                 // joining game
 200                 cout << "joined game \"" << world_conf.name << '"' << endl;
 201                 // server received our login
 202                 login_packet = -1;
 203         }
 204
 205         uint32_t player_id;
 206         pack.ReadPlayerID(player_id);
 207         state.reset(new InteractiveState(*this, player_id));
 208
 209         pack.ReadPlayer(*state->GetInterface().GetPlayer().entity);
 210
 211         env.state.PopAfter(this);
 212         env.state.Push(state.get());
 213 }
 214
 215 void MasterState::On(const Packet::Part &pack) {
 216         if (state) {
 217                 // kicked
 218                 cout << "kicked by server" << endl;
 219         } else {
 220                 // join refused
 221                 cout << "login refused by server" << endl;
 222         }
 223         Quit();
 224 }
 225
 226 void MasterState::On(const Packet::SpawnEntity &pack) {
 227         if (!state) {
 228                 cout << "got entity spawn before world was created" << endl;
 229                 Quit();
 230                 return;
 231         }
 232         uint32_t entity_id;
 233         pack.ReadEntityID(entity_id);
 234         Entity &entity = state->GetWorld().ForceAddEntity(entity_id);
 235         UpdateEntity(entity_id, pack.Seq());
 236         pack.ReadEntity(entity);
 237         uint32_t skel_id;
 238         pack.ReadSkeletonID(skel_id);
 239         CompositeModel *skel = state->GetSkeletons().ByID(skel_id);
 240         if (skel) {
 241                 skel->Instantiate(entity.GetModel());
 242         }
 243         cout << "spawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 244 }
 245
 246 void MasterState::On(const Packet::DespawnEntity &pack) {
 247         if (!state) {
 248                 cout << "got entity despawn before world was created" << endl;
 249                 Quit();
 250                 return;
 251         }
 252         uint32_t entity_id;
 253         pack.ReadEntityID(entity_id);
 254         ClearEntity(entity_id);
 255         for (Entity &entity : state->GetWorld().Entities()) {
 256                 if (entity.ID() == entity_id) {
 257                         entity.Kill();
 258                         cout << "despawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 259                         return;
 260                 }
 261         }
 262 }
 263
 264 void MasterState::On(const Packet::EntityUpdate &pack) {
 265         if (!state) {
 266                 cout << "got entity update before world was created" << endl;
 267                 Quit();
 268                 return;
 269         }
 270
 271         auto world_iter = state->GetWorld().Entities().begin();
 272         auto world_end = state->GetWorld().Entities().end();
 273
 274         uint32_t count = 0;
 275         pack.ReadEntityCount(count);
 276
 277         for (uint32_t i = 0; i < count; ++i) {
 278                 uint32_t entity_id = 0;
 279                 pack.ReadEntityID(entity_id, i);
 280
 281                 while (world_iter != world_end && world_iter->ID() < entity_id) {
 282                         ++world_iter;
 283                 }
 284                 if (world_iter == world_end) {
 285                         // nothing can be done from here
 286                         return;
 287                 }
 288                 if (world_iter->ID() == entity_id) {
 289                         if (UpdateEntity(entity_id, pack.Seq())) {
 290                                 pack.ReadEntity(*world_iter, i);
 291                         }
 292                 }
 293         }
 294 }
 295
 296 bool MasterState::UpdateEntity(uint32_t entity_id, uint16_t seq) {
 297         auto entry = update_status.find(entity_id);
 298         if (entry == update_status.end()) {
 299                 update_status.emplace(entity_id, UpdateStatus{ seq, update_timer.Elapsed() });
 300                 return true;
 301         }
 302
 303         int pack_diff = int16_t(seq) - int16_t(entry->second.last_packet);
 304         int time_diff = update_timer.Elapsed() - entry->second.last_update;
 305         entry->second.last_update = update_timer.Elapsed();
 306
 307         if (pack_diff > 0 || time_diff > 1500) {
 308                 entry->second.last_packet = seq;
 309                 return true;
 310         } else {
 311                 return false;
 312         }
 313 }
 314
 315 void MasterState::ClearEntity(uint32_t entity_id) {
 316         update_status.erase(entity_id);
 317 }
 318
 319 }
 320 }