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 , loop_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         loop_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         loop_timer.Update(dt);
 105         master.Update(dt);
 106
 107         interface.Update(dt);
 108         int world_dt = 0;
 109         while (loop_timer.HitOnce()) {
 110                 world.Update(loop_timer.Interval());
 111                 world_dt += loop_timer.Interval();
 112                 loop_timer.PopIteration();
 113         }
 114         chunk_renderer.Update(dt);
 115
 116         Entity &player = *interface.GetPlayer().entity;
 117
 118         if (world_dt > 0) {
 119                 PushPlayerUpdate(player, world_dt);
 120         }
 121
 122         glm::mat4 trans = player.Transform(player.ChunkCoords());
 123         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
 124         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
 125         master.GetEnv().audio.Position(player.Position());
 126         master.GetEnv().audio.Velocity(player.Velocity());
 127         master.GetEnv().audio.Orientation(dir, up);
 128 }
 129
 130 void InteractiveState::PushPlayerUpdate(const Entity &player, int dt) {
 131         std::uint16_t packet = master.GetClient().SendPlayerUpdate(player);
 132         if (player_hist.size() < 16) {
 133                 player_hist.emplace_back(player.GetState(), dt, packet);
 134         } else {
 135                 auto entry = player_hist.begin();
 136                 entry->state = player.GetState();
 137                 entry->delta_t = dt;
 138                 entry->packet = packet;
 139                 player_hist.splice(player_hist.end(), player_hist, entry);
 140         }
 141 }
 142
 143 void InteractiveState::MergePlayerCorrection(uint16_t seq, const EntityState &corrected_state) {
 144         if (player_hist.empty()) return;
 145
 146         auto entry = player_hist.begin();
 147         auto end = player_hist.end();
 148
 149         // we may have received an older packet
 150         int pack_diff = int16_t(seq) - int16_t(entry->packet);
 151         if (pack_diff < 0) {
 152                 // indeed we have, just ignore it
 153                 return;
 154         }
 155
 156         // drop anything older than the fix
 157         while (entry != end) {
 158                 pack_diff = int16_t(seq) - int16_t(entry->packet);
 159                 if (pack_diff > 0) {
 160                         entry = player_hist.erase(entry);
 161                 } else {
 162                         break;
 163                 }
 164         }
 165
 166         EntityState replay_state(corrected_state);
 167         EntityState &player_state = interface.GetPlayer().entity->GetState();
 168
 169         if (entry != end) {
 170                 entry->state.chunk_pos = replay_state.chunk_pos;
 171                 entry->state.block_pos = replay_state.block_pos;
 172                 ++entry;
 173         }
 174
 175         while (entry != end) {
 176                 replay_state.velocity = entry->state.velocity;
 177                 replay_state.Update(entry->delta_t);
 178                 entry->state.chunk_pos = replay_state.chunk_pos;
 179                 entry->state.block_pos = replay_state.block_pos;
 180                 ++entry;
 181         }
 182
 183         glm::vec3 displacement(replay_state.Diff(player_state));
 184         const float disp_squared = dot(displacement, displacement);
 185
 186         if (disp_squared < 16.0f * numeric_limits<float>::epsilon()) {
 187                 return;
 188         }
 189
 190         // if offset > 10cm, warp the player
 191         // otherwise, move at most 1cm per frame towards
 192         // the fixed position (160ms, so shouldn't be too noticeable)
 193         constexpr float warp_thresh = 0.01f; // (1/10)^2
 194         constexpr float max_disp = 0.0001f; // (1/100)^2
 195
 196         if (disp_squared > warp_thresh) {
 197                 player_state.chunk_pos = replay_state.chunk_pos;
 198                 player_state.block_pos = replay_state.block_pos;
 199         } else if (disp_squared < max_disp) {
 200                 player_state.block_pos += displacement;
 201         } else {
 202                 displacement *= 0.01f / sqrt(disp_squared);
 203                 player_state.block_pos += displacement;
 204         }
 205 }
 206
 207 void InteractiveState::Render(Viewport &viewport) {
 208         Entity &player = *interface.GetPlayer().entity;
 209         viewport.WorldPosition(player.Transform(player.ChunkCoords()));
 210         chunk_renderer.Render(viewport);
 211         world.Render(viewport);
 212         interface.Render(viewport);
 213 }
 214
 215
 216 MasterState::MasterState(
 217         Environment &env,
 218         const World::Config &wc,
 219         const Interface::Config &ic,
 220         const Client::Config &cc)
 221 : env(env)
 222 , world_conf(wc)
 223 , intf_conf(ic)
 224 , client_conf(cc)
 225 , state()
 226 , client(cc)
 227 , init_state(*this)
 228 , login_packet(-1)
 229 , update_status()
 230 , update_timer(16) {
 231         client.GetConnection().SetHandler(this);
 232         update_timer.Start();
 233 }
 234
 235 void MasterState::Quit() {
 236         if (!client.GetConnection().Closed()) {
 237                 client.SendPart();
 238         }
 239         env.state.PopUntil(this);
 240 }
 241
 242
 243 void MasterState::OnEnter() {
 244         login_packet = client.SendLogin(intf_conf.player_name);
 245         env.state.Push(&init_state);
 246 }
 247
 248
 249 void MasterState::Handle(const SDL_Event &event) {
 250
 251 }
 252
 253
 254 void MasterState::Update(int dt) {
 255         update_timer.Update(dt);
 256         client.Handle();
 257         client.Update(dt);
 258 }
 259
 260
 261 void MasterState::Render(Viewport &) {
 262
 263 }
 264
 265
 266 void MasterState::OnPacketLost(uint16_t id) {
 267         if (id == login_packet) {
 268                 login_packet = client.SendLogin(intf_conf.player_name);
 269         }
 270 }
 271
 272 void MasterState::OnTimeout() {
 273         if (client.GetConnection().Closed()) {
 274                 // TODO: push disconnected message
 275                 cout << "connection timed out" << endl;
 276                 Quit();
 277         }
 278 }
 279
 280 void MasterState::On(const Packet::Join &pack) {
 281         pack.ReadWorldName(world_conf.name);
 282
 283         if (state) {
 284                 // changing worlds
 285                 cout << "server changing worlds to \"" << world_conf.name << '"' << endl;
 286         } else {
 287                 // joining game
 288                 cout << "joined game \"" << world_conf.name << '"' << endl;
 289                 // server received our login
 290                 login_packet = -1;
 291         }
 292
 293         uint32_t player_id;
 294         pack.ReadPlayerID(player_id);
 295         state.reset(new InteractiveState(*this, player_id));
 296
 297         pack.ReadPlayerState(state->GetInterface().GetPlayer().entity->GetState());
 298
 299         env.state.PopAfter(this);
 300         env.state.Push(state.get());
 301 }
 302
 303 void MasterState::On(const Packet::Part &pack) {
 304         if (state) {
 305                 // kicked
 306                 cout << "kicked by server" << endl;
 307         } else {
 308                 // join refused
 309                 cout << "login refused by server" << endl;
 310         }
 311         Quit();
 312 }
 313
 314 void MasterState::On(const Packet::SpawnEntity &pack) {
 315         if (!state) {
 316                 cout << "got entity spawn before world was created" << endl;
 317                 Quit();
 318                 return;
 319         }
 320         uint32_t entity_id;
 321         pack.ReadEntityID(entity_id);
 322         Entity &entity = state->GetWorld().ForceAddEntity(entity_id);
 323         UpdateEntity(entity_id, pack.Seq());
 324         pack.ReadEntity(entity);
 325         uint32_t skel_id;
 326         pack.ReadSkeletonID(skel_id);
 327         CompositeModel *skel = state->GetSkeletons().ByID(skel_id);
 328         if (skel) {
 329                 skel->Instantiate(entity.GetModel());
 330         }
 331         cout << "spawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 332 }
 333
 334 void MasterState::On(const Packet::DespawnEntity &pack) {
 335         if (!state) {
 336                 cout << "got entity despawn before world was created" << endl;
 337                 Quit();
 338                 return;
 339         }
 340         uint32_t entity_id;
 341         pack.ReadEntityID(entity_id);
 342         ClearEntity(entity_id);
 343         for (Entity &entity : state->GetWorld().Entities()) {
 344                 if (entity.ID() == entity_id) {
 345                         entity.Kill();
 346                         cout << "despawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 347                         return;
 348                 }
 349         }
 350 }
 351
 352 void MasterState::On(const Packet::EntityUpdate &pack) {
 353         if (!state) {
 354                 cout << "got entity update before world was created" << endl;
 355                 Quit();
 356                 return;
 357         }
 358
 359         auto world_iter = state->GetWorld().Entities().begin();
 360         auto world_end = state->GetWorld().Entities().end();
 361
 362         uint32_t count = 0;
 363         pack.ReadEntityCount(count);
 364
 365         for (uint32_t i = 0; i < count; ++i) {
 366                 uint32_t entity_id = 0;
 367                 pack.ReadEntityID(entity_id, i);
 368
 369                 while (world_iter != world_end && world_iter->ID() < entity_id) {
 370                         ++world_iter;
 371                 }
 372                 if (world_iter == world_end) {
 373                         // nothing can be done from here
 374                         return;
 375                 }
 376                 if (world_iter->ID() == entity_id) {
 377                         if (UpdateEntity(entity_id, pack.Seq())) {
 378                                 pack.ReadEntityState(world_iter->GetState(), i);
 379                         }
 380                 }
 381         }
 382 }
 383
 384 bool MasterState::UpdateEntity(uint32_t entity_id, uint16_t seq) {
 385         auto entry = update_status.find(entity_id);
 386         if (entry == update_status.end()) {
 387                 update_status.emplace(entity_id, UpdateStatus{ seq, update_timer.Elapsed() });
 388                 return true;
 389         }
 390
 391         int pack_diff = int16_t(seq) - int16_t(entry->second.last_packet);
 392         int time_diff = update_timer.Elapsed() - entry->second.last_update;
 393         entry->second.last_update = update_timer.Elapsed();
 394
 395         if (pack_diff > 0 || time_diff > 1500) {
 396                 entry->second.last_packet = seq;
 397                 return true;
 398         } else {
 399                 return false;
 400         }
 401 }
 402
 403 void MasterState::ClearEntity(uint32_t entity_id) {
 404         update_status.erase(entity_id);
 405 }
 406
 407 void MasterState::On(const Packet::PlayerCorrection &pack) {
 408         if (!state) {
 409                 cout << "got player correction without a player :S" << endl;
 410                 Quit();
 411                 return;
 412         }
 413         uint16_t pack_seq;
 414         EntityState corrected_state;
 415         pack.ReadPacketSeq(pack_seq);
 416         pack.ReadPlayerState(corrected_state);
 417         state->MergePlayerCorrection(pack_seq, corrected_state);
 418 }
 419
 420 }
 421 }