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
   9 #include <iostream>
  10
  11
  12 namespace blank {
  13 namespace client {
  14
  15 InitialState::InitialState(MasterState &master)
  16 : master(master)
  17 , message() {
  18         message.Position(glm::vec3(0.0f), Gravity::CENTER);
  19         message.Set(master.GetEnv().assets.large_ui_font, "logging in");
  20 }
  21
  22 void InitialState::OnEnter() {
  23
  24 }
  25
  26 void InitialState::Handle(const SDL_Event &evt) {
  27         if (evt.type == SDL_QUIT) {
  28                 master.Quit();
  29         }
  30 }
  31
  32 void InitialState::Update(int dt) {
  33         master.Update(dt);
  34 }
  35
  36 void InitialState::Render(Viewport &viewport) {
  37         message.Render(viewport);
  38 }
  39
  40
  41 InteractiveState::InteractiveState(MasterState &master)
  42 : master(master)
  43 , block_types()
  44 , save(master.GetEnv().config.GetWorldPath(master.GetWorldConf().name, master.GetClientConf().host))
  45 , world(block_types, master.GetWorldConf(), save)
  46 , chunk_renderer(world, master.GetWorldConf().load.load_dist)
  47 , interface(master.GetInterfaceConf(), master.GetEnv(), world) {
  48         TextureIndex tex_index;
  49         master.GetEnv().loader.LoadBlockTypes("default", block_types, tex_index);
  50         chunk_renderer.LoadTextures(master.GetEnv().loader, tex_index);
  51         chunk_renderer.FogDensity(master.GetWorldConf().fog_density);
  52         // TODO: better solution for initializing HUD
  53         interface.SelectNext();
  54 }
  55
  56 void InteractiveState::OnEnter() {
  57         master.GetEnv().window.GrabMouse();
  58 }
  59
  60 void InteractiveState::Handle(const SDL_Event &event) {
  61         switch (event.type) {
  62                 case SDL_KEYDOWN:
  63                         interface.HandlePress(event.key);
  64                         break;
  65                 case SDL_KEYUP:
  66                         interface.HandleRelease(event.key);
  67                         break;
  68                 case SDL_MOUSEBUTTONDOWN:
  69                         interface.HandlePress(event.button);
  70                         break;
  71                 case SDL_MOUSEBUTTONUP:
  72                         interface.HandleRelease(event.button);
  73                         break;
  74                 case SDL_MOUSEMOTION:
  75                         interface.Handle(event.motion);
  76                         break;
  77                 case SDL_MOUSEWHEEL:
  78                         interface.Handle(event.wheel);
  79                         break;
  80                 case SDL_QUIT:
  81                         master.Quit();
  82                         break;
  83                 default:
  84                         break;
  85         }
  86 }
  87
  88 void InteractiveState::Update(int dt) {
  89         master.Update(dt);
  90
  91         interface.Update(dt);
  92         world.Update(dt);
  93         chunk_renderer.Rebase(interface.Player().ChunkCoords());
  94         chunk_renderer.Update(dt);
  95
  96         glm::mat4 trans = interface.Player().Transform(interface.Player().ChunkCoords());
  97         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
  98         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
  99         master.GetEnv().audio.Position(interface.Player().Position());
 100         master.GetEnv().audio.Velocity(interface.Player().Velocity());
 101         master.GetEnv().audio.Orientation(dir, up);
 102 }
 103
 104 void InteractiveState::Render(Viewport &viewport) {
 105         viewport.WorldPosition(interface.Player().Transform(interface.Player().ChunkCoords()));
 106         chunk_renderer.Render(viewport);
 107         world.Render(viewport);
 108         interface.Render(viewport);
 109 }
 110
 111
 112 MasterState::MasterState(
 113         Environment &env,
 114         const World::Config &wc,
 115         const Interface::Config &ic,
 116         const Client::Config &cc)
 117 : env(env)
 118 , world_conf(wc)
 119 , intf_conf(ic)
 120 , client_conf(cc)
 121 , state()
 122 , client(cc)
 123 , init_state(*this) {
 124         client.GetConnection().SetHandler(this);
 125 }
 126
 127 void MasterState::Quit() {
 128         env.state.PopUntil(this);
 129 }
 130
 131
 132 void MasterState::OnEnter() {
 133         client.SendLogin(intf_conf.player_name);
 134         env.state.Push(&init_state);
 135 }
 136
 137
 138 void MasterState::Handle(const SDL_Event &event) {
 139
 140 }
 141
 142
 143 void MasterState::Update(int dt) {
 144         client.Handle();
 145         client.Update(dt);
 146         if (client.GetConnection().Closed()) {
 147                 Quit();
 148                 // TODO: push disconnected message
 149         }
 150 }
 151
 152
 153 void MasterState::Render(Viewport &) {
 154
 155 }
 156
 157
 158 void MasterState::On(const Packet::Join &pack) {
 159         pack.ReadWorldName(world_conf.name);
 160
 161         if (state) {
 162                 // changing worlds
 163                 std::cout << "server changing worlds" << std::endl;
 164         } else {
 165                 // joining game
 166                 std::cout << "joined game" << std::endl;
 167         }
 168         state.reset(new InteractiveState(*this));
 169
 170         pack.ReadPlayer(state->GetInterface().Player());
 171
 172         env.state.PopAfter(this);
 173         env.state.Push(state.get());
 174 }
 175
 176 void MasterState::On(const Packet::Part &pack) {
 177         if (state) {
 178                 // kicked
 179                 std::cout << "kicked by server" << std::endl;
 180         } else {
 181                 // join refused
 182                 std::cout << "login refused by server" << std::endl;
 183         }
 184         Quit();
 185 }
 186
 187 }
 188 }