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 , update_timer(16)
  60 , player_hist() {
  61         TextureIndex tex_index;
  62         master.GetEnv().loader.LoadBlockTypes("default", block_types, tex_index);
  63         chunk_renderer.LoadTextures(master.GetEnv().loader, tex_index);
  64         chunk_renderer.FogDensity(master.GetWorldConf().fog_density);
  65         skeletons.Load();
  66         // TODO: better solution for initializing HUD
  67         interface.SelectNext();
  68         update_timer.Start();
  69 }
  70
  71 void InteractiveState::OnEnter() {
  72         master.GetEnv().window.GrabMouse();
  73 }
  74
  75 void InteractiveState::Handle(const SDL_Event &event) {
  76         switch (event.type) {
  77                 case SDL_KEYDOWN:
  78                         interface.HandlePress(event.key);
  79                         break;
  80                 case SDL_KEYUP:
  81                         interface.HandleRelease(event.key);
  82                         break;
  83                 case SDL_MOUSEBUTTONDOWN:
  84                         interface.HandlePress(event.button);
  85                         break;
  86                 case SDL_MOUSEBUTTONUP:
  87                         interface.HandleRelease(event.button);
  88                         break;
  89                 case SDL_MOUSEMOTION:
  90                         interface.Handle(event.motion);
  91                         break;
  92                 case SDL_MOUSEWHEEL:
  93                         interface.Handle(event.wheel);
  94                         break;
  95                 case SDL_QUIT:
  96                         master.Quit();
  97                         break;
  98                 default:
  99                         break;
 100         }
 101 }
 102
 103 void InteractiveState::Update(int dt) {
 104         master.Update(dt);
 105
 106         interface.Update(dt);
 107         world.Update(dt);
 108         chunk_renderer.Update(dt);
 109
 110         update_timer.Update(dt);
 111
 112         Entity &player = *interface.GetPlayer().entity;
 113
 114         if (update_timer.Hit()) {
 115                 PushPlayerUpdate(player);
 116         }
 117
 118         glm::mat4 trans = player.Transform(player.ChunkCoords());
 119         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
 120         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
 121         master.GetEnv().audio.Position(player.Position());
 122         master.GetEnv().audio.Velocity(player.Velocity());
 123         master.GetEnv().audio.Orientation(dir, up);
 124 }
 125
 126 void InteractiveState::PushPlayerUpdate(const Entity &player) {
 127         std::uint16_t packet = master.GetClient().SendPlayerUpdate(player);
 128         if (player_hist.size() < 16) {
 129                 player_hist.emplace_back(player.GetState(), update_timer.Elapsed(), packet);
 130         } else {
 131                 auto entry = player_hist.begin();
 132                 entry->state = player.GetState();
 133                 entry->timestamp = update_timer.Elapsed();
 134                 entry->packet = packet;
 135                 player_hist.splice(player_hist.end(), player_hist, entry);
 136         }
 137 }
 138
 139 void InteractiveState::MergePlayerCorrection(uint16_t seq, const EntityState &corrected_state) {
 140         if (player_hist.empty()) return;
 141
 142         auto entry = player_hist.begin();
 143         auto end = player_hist.end();
 144
 145         // drop anything older than the fix
 146         while (entry != end) {
 147                 int pack_diff = int16_t(seq) - int16_t(entry->packet);
 148                 if (pack_diff < 0) {
 149                         entry = player_hist.erase(entry);
 150                 } else {
 151                         break;
 152                 }
 153         }
 154         if (entry == end) return;
 155 }
 156
 157 void InteractiveState::Render(Viewport &viewport) {
 158         Entity &player = *interface.GetPlayer().entity;
 159         viewport.WorldPosition(player.Transform(player.ChunkCoords()));
 160         chunk_renderer.Render(viewport);
 161         world.Render(viewport);
 162         interface.Render(viewport);
 163 }
 164
 165
 166 MasterState::MasterState(
 167         Environment &env,
 168         const World::Config &wc,
 169         const Interface::Config &ic,
 170         const Client::Config &cc)
 171 : env(env)
 172 , world_conf(wc)
 173 , intf_conf(ic)
 174 , client_conf(cc)
 175 , state()
 176 , client(cc)
 177 , init_state(*this)
 178 , login_packet(-1)
 179 , update_status()
 180 , update_timer(16) {
 181         client.GetConnection().SetHandler(this);
 182         update_timer.Start();
 183 }
 184
 185 void MasterState::Quit() {
 186         if (!client.GetConnection().Closed()) {
 187                 client.SendPart();
 188         }
 189         env.state.PopUntil(this);
 190 }
 191
 192
 193 void MasterState::OnEnter() {
 194         login_packet = client.SendLogin(intf_conf.player_name);
 195         env.state.Push(&init_state);
 196 }
 197
 198
 199 void MasterState::Handle(const SDL_Event &event) {
 200
 201 }
 202
 203
 204 void MasterState::Update(int dt) {
 205         update_timer.Update(dt);
 206         client.Handle();
 207         client.Update(dt);
 208 }
 209
 210
 211 void MasterState::Render(Viewport &) {
 212
 213 }
 214
 215
 216 void MasterState::OnPacketLost(uint16_t id) {
 217         if (id == login_packet) {
 218                 login_packet = client.SendLogin(intf_conf.player_name);
 219         }
 220 }
 221
 222 void MasterState::OnTimeout() {
 223         if (client.GetConnection().Closed()) {
 224                 // TODO: push disconnected message
 225                 cout << "connection timed out" << endl;
 226                 Quit();
 227         }
 228 }
 229
 230 void MasterState::On(const Packet::Join &pack) {
 231         pack.ReadWorldName(world_conf.name);
 232
 233         if (state) {
 234                 // changing worlds
 235                 cout << "server changing worlds to \"" << world_conf.name << '"' << endl;
 236         } else {
 237                 // joining game
 238                 cout << "joined game \"" << world_conf.name << '"' << endl;
 239                 // server received our login
 240                 login_packet = -1;
 241         }
 242
 243         uint32_t player_id;
 244         pack.ReadPlayerID(player_id);
 245         state.reset(new InteractiveState(*this, player_id));
 246
 247         pack.ReadPlayerState(state->GetInterface().GetPlayer().entity->GetState());
 248
 249         env.state.PopAfter(this);
 250         env.state.Push(state.get());
 251 }
 252
 253 void MasterState::On(const Packet::Part &pack) {
 254         if (state) {
 255                 // kicked
 256                 cout << "kicked by server" << endl;
 257         } else {
 258                 // join refused
 259                 cout << "login refused by server" << endl;
 260         }
 261         Quit();
 262 }
 263
 264 void MasterState::On(const Packet::SpawnEntity &pack) {
 265         if (!state) {
 266                 cout << "got entity spawn before world was created" << endl;
 267                 Quit();
 268                 return;
 269         }
 270         uint32_t entity_id;
 271         pack.ReadEntityID(entity_id);
 272         Entity &entity = state->GetWorld().ForceAddEntity(entity_id);
 273         UpdateEntity(entity_id, pack.Seq());
 274         pack.ReadEntity(entity);
 275         uint32_t skel_id;
 276         pack.ReadSkeletonID(skel_id);
 277         CompositeModel *skel = state->GetSkeletons().ByID(skel_id);
 278         if (skel) {
 279                 skel->Instantiate(entity.GetModel());
 280         }
 281         cout << "spawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 282 }
 283
 284 void MasterState::On(const Packet::DespawnEntity &pack) {
 285         if (!state) {
 286                 cout << "got entity despawn before world was created" << endl;
 287                 Quit();
 288                 return;
 289         }
 290         uint32_t entity_id;
 291         pack.ReadEntityID(entity_id);
 292         ClearEntity(entity_id);
 293         for (Entity &entity : state->GetWorld().Entities()) {
 294                 if (entity.ID() == entity_id) {
 295                         entity.Kill();
 296                         cout << "despawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 297                         return;
 298                 }
 299         }
 300 }
 301
 302 void MasterState::On(const Packet::EntityUpdate &pack) {
 303         if (!state) {
 304                 cout << "got entity update before world was created" << endl;
 305                 Quit();
 306                 return;
 307         }
 308
 309         auto world_iter = state->GetWorld().Entities().begin();
 310         auto world_end = state->GetWorld().Entities().end();
 311
 312         uint32_t count = 0;
 313         pack.ReadEntityCount(count);
 314
 315         for (uint32_t i = 0; i < count; ++i) {
 316                 uint32_t entity_id = 0;
 317                 pack.ReadEntityID(entity_id, i);
 318
 319                 while (world_iter != world_end && world_iter->ID() < entity_id) {
 320                         ++world_iter;
 321                 }
 322                 if (world_iter == world_end) {
 323                         // nothing can be done from here
 324                         return;
 325                 }
 326                 if (world_iter->ID() == entity_id) {
 327                         if (UpdateEntity(entity_id, pack.Seq())) {
 328                                 pack.ReadEntityState(world_iter->GetState(), i);
 329                         }
 330                 }
 331         }
 332 }
 333
 334 bool MasterState::UpdateEntity(uint32_t entity_id, uint16_t seq) {
 335         auto entry = update_status.find(entity_id);
 336         if (entry == update_status.end()) {
 337                 update_status.emplace(entity_id, UpdateStatus{ seq, update_timer.Elapsed() });
 338                 return true;
 339         }
 340
 341         int pack_diff = int16_t(seq) - int16_t(entry->second.last_packet);
 342         int time_diff = update_timer.Elapsed() - entry->second.last_update;
 343         entry->second.last_update = update_timer.Elapsed();
 344
 345         if (pack_diff > 0 || time_diff > 1500) {
 346                 entry->second.last_packet = seq;
 347                 return true;
 348         } else {
 349                 return false;
 350         }
 351 }
 352
 353 void MasterState::ClearEntity(uint32_t entity_id) {
 354         update_status.erase(entity_id);
 355 }
 356
 357 void MasterState::On(const Packet::PlayerCorrection &pack) {
 358         if (!state) {
 359                 cout << "got player correction without a player :S" << endl;
 360                 Quit();
 361                 return;
 362         }
 363         uint16_t pack_seq;
 364         EntityState corrected_state;
 365         pack.ReadPacketSeq(pack_seq);
 366         pack.ReadPlayerState(corrected_state);
 367         state->MergePlayerCorrection(pack_seq, corrected_state);
 368 }
 369
 370 }
 371 }