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         client.GetConnection().SetHandler(this);
 142 }
 143
 144 void MasterState::Quit() {
 145         if (!client.GetConnection().Closed()) {
 146                 client.SendPart();
 147         }
 148         env.state.PopUntil(this);
 149 }
 150
 151
 152 void MasterState::OnEnter() {
 153         login_packet = client.SendLogin(intf_conf.player_name);
 154         env.state.Push(&init_state);
 155 }
 156
 157
 158 void MasterState::Handle(const SDL_Event &event) {
 159
 160 }
 161
 162
 163 void MasterState::Update(int dt) {
 164         client.Handle();
 165         client.Update(dt);
 166 }
 167
 168
 169 void MasterState::Render(Viewport &) {
 170
 171 }
 172
 173
 174 void MasterState::OnPacketLost(uint16_t id) {
 175         if (id == login_packet) {
 176                 login_packet = client.SendLogin(intf_conf.player_name);
 177         }
 178 }
 179
 180 void MasterState::OnTimeout() {
 181         if (client.GetConnection().Closed()) {
 182                 // TODO: push disconnected message
 183                 cout << "connection timed out" << endl;
 184                 Quit();
 185         }
 186 }
 187
 188 void MasterState::On(const Packet::Join &pack) {
 189         pack.ReadWorldName(world_conf.name);
 190
 191         if (state) {
 192                 // changing worlds
 193                 cout << "server changing worlds to \"" << world_conf.name << '"' << endl;
 194         } else {
 195                 // joining game
 196                 cout << "joined game \"" << world_conf.name << '"' << endl;
 197         }
 198
 199         uint32_t player_id;
 200         pack.ReadPlayerID(player_id);
 201         state.reset(new InteractiveState(*this, player_id));
 202
 203         pack.ReadPlayer(*state->GetInterface().GetPlayer().entity);
 204
 205         env.state.PopAfter(this);
 206         env.state.Push(state.get());
 207 }
 208
 209 void MasterState::On(const Packet::Part &pack) {
 210         if (state) {
 211                 // kicked
 212                 cout << "kicked by server" << endl;
 213         } else {
 214                 // join refused
 215                 cout << "login refused by server" << endl;
 216         }
 217         Quit();
 218 }
 219
 220 void MasterState::On(const Packet::SpawnEntity &pack) {
 221         if (!state) {
 222                 cout << "got entity spawn before world was created" << endl;
 223                 Quit();
 224                 return;
 225         }
 226         uint32_t entity_id;
 227         pack.ReadEntityID(entity_id);
 228         Entity *entity = state->GetWorld().AddEntity(entity_id);
 229         if (!entity) {
 230                 cout << "entity ID inconsistency" << endl;
 231                 Quit();
 232                 return;
 233         }
 234         pack.ReadEntity(*entity);
 235         uint32_t skel_id;
 236         pack.ReadSkeletonID(skel_id);
 237         CompositeModel *skel = state->GetSkeletons().ByID(skel_id);
 238         if (skel) {
 239                 skel->Instantiate(entity->GetModel());
 240         }
 241         cout << "spawned entity " << entity->Name() << " at " << entity->AbsolutePosition() << endl;
 242 }
 243
 244 void MasterState::On(const Packet::DespawnEntity &pack) {
 245         if (!state) {
 246                 cout << "got entity despawn before world was created" << endl;
 247                 Quit();
 248                 return;
 249         }
 250         uint32_t entity_id;
 251         pack.ReadEntityID(entity_id);
 252         for (Entity &entity : state->GetWorld().Entities()) {
 253                 if (entity.ID() == entity_id) {
 254                         entity.Kill();
 255                         cout << "despawned entity " << entity.Name() << " at " << entity.AbsolutePosition() << endl;
 256                         return;
 257                 }
 258         }
 259 }
 260
 261 void MasterState::On(const Packet::EntityUpdate &pack) {
 262         if (!state) {
 263                 cout << "got entity update before world was created" << endl;
 264                 Quit();
 265                 return;
 266         }
 267
 268         auto world_iter = state->GetWorld().Entities().begin();
 269         auto world_end = state->GetWorld().Entities().end();
 270
 271         uint32_t count = 0;
 272         pack.ReadEntityCount(count);
 273
 274         for (uint32_t i = 0; i < count; ++i) {
 275                 uint32_t entity_id = 0;
 276                 pack.ReadEntityID(entity_id, i);
 277
 278                 while (world_iter != world_end && world_iter->ID() < entity_id) {
 279                         ++world_iter;
 280                 }
 281                 if (world_iter == world_end) {
 282                         // nothing can be done from here
 283                         return;
 284                 }
 285                 if (world_iter->ID() == entity_id) {
 286                         pack.ReadEntity(*world_iter, i);
 287                 }
 288         }
 289 }
 290
 291 }
 292 }