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