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 // TODO: this clutter is a giant mess
  42 InteractiveState::InteractiveState(MasterState &master, uint32_t player_id)
  43 : master(master)
  44 , block_types()
  45 , save(master.GetEnv().config.GetWorldPath(master.GetWorldConf().name, master.GetClientConf().host))
  46 , world(block_types, master.GetWorldConf(), save)
  47 , chunk_renderer(world, master.GetWorldConf().load.load_dist)
  48 , interface(
  49         master.GetInterfaceConf(),
  50         master.GetEnv(),
  51         world,
  52         *world.AddPlayer(master.GetInterfaceConf().player_name, player_id)
  53 ) {
  54         TextureIndex tex_index;
  55         master.GetEnv().loader.LoadBlockTypes("default", block_types, tex_index);
  56         chunk_renderer.LoadTextures(master.GetEnv().loader, tex_index);
  57         chunk_renderer.FogDensity(master.GetWorldConf().fog_density);
  58         // TODO: better solution for initializing HUD
  59         interface.SelectNext();
  60 }
  61
  62 void InteractiveState::OnEnter() {
  63         master.GetEnv().window.GrabMouse();
  64 }
  65
  66 void InteractiveState::Handle(const SDL_Event &event) {
  67         switch (event.type) {
  68                 case SDL_KEYDOWN:
  69                         interface.HandlePress(event.key);
  70                         break;
  71                 case SDL_KEYUP:
  72                         interface.HandleRelease(event.key);
  73                         break;
  74                 case SDL_MOUSEBUTTONDOWN:
  75                         interface.HandlePress(event.button);
  76                         break;
  77                 case SDL_MOUSEBUTTONUP:
  78                         interface.HandleRelease(event.button);
  79                         break;
  80                 case SDL_MOUSEMOTION:
  81                         interface.Handle(event.motion);
  82                         break;
  83                 case SDL_MOUSEWHEEL:
  84                         interface.Handle(event.wheel);
  85                         break;
  86                 case SDL_QUIT:
  87                         master.Quit();
  88                         break;
  89                 default:
  90                         break;
  91         }
  92 }
  93
  94 void InteractiveState::Update(int dt) {
  95         master.Update(dt);
  96
  97         interface.Update(dt);
  98         world.Update(dt);
  99         chunk_renderer.Rebase(interface.Player().ChunkCoords());
 100         chunk_renderer.Update(dt);
 101
 102         glm::mat4 trans = interface.Player().Transform(interface.Player().ChunkCoords());
 103         glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
 104         glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
 105         master.GetEnv().audio.Position(interface.Player().Position());
 106         master.GetEnv().audio.Velocity(interface.Player().Velocity());
 107         master.GetEnv().audio.Orientation(dir, up);
 108 }
 109
 110 void InteractiveState::Render(Viewport &viewport) {
 111         viewport.WorldPosition(interface.Player().Transform(interface.Player().ChunkCoords()));
 112         chunk_renderer.Render(viewport);
 113         world.Render(viewport);
 114         interface.Render(viewport);
 115 }
 116
 117
 118 MasterState::MasterState(
 119         Environment &env,
 120         const World::Config &wc,
 121         const Interface::Config &ic,
 122         const Client::Config &cc)
 123 : env(env)
 124 , world_conf(wc)
 125 , intf_conf(ic)
 126 , client_conf(cc)
 127 , state()
 128 , client(cc)
 129 , init_state(*this)
 130 , login_packet(-1) {
 131         client.GetConnection().SetHandler(this);
 132 }
 133
 134 void MasterState::Quit() {
 135         env.state.PopUntil(this);
 136 }
 137
 138
 139 void MasterState::OnEnter() {
 140         login_packet = client.SendLogin(intf_conf.player_name);
 141         env.state.Push(&init_state);
 142 }
 143
 144
 145 void MasterState::Handle(const SDL_Event &event) {
 146
 147 }
 148
 149
 150 void MasterState::Update(int dt) {
 151         client.Handle();
 152         client.Update(dt);
 153 }
 154
 155
 156 void MasterState::Render(Viewport &) {
 157
 158 }
 159
 160
 161 void MasterState::OnPacketLost(std::uint16_t id) {
 162         if (id == login_packet) {
 163                 login_packet = client.SendLogin(intf_conf.player_name);
 164         }
 165 }
 166
 167 void MasterState::OnTimeout() {
 168         if (client.GetConnection().Closed()) {
 169                 Quit();
 170                 // TODO: push disconnected message
 171         }
 172 }
 173
 174 void MasterState::On(const Packet::Join &pack) {
 175         pack.ReadWorldName(world_conf.name);
 176
 177         if (state) {
 178                 // changing worlds
 179                 std::cout << "server changing worlds" << std::endl;
 180         } else {
 181                 // joining game
 182                 std::cout << "joined game" << std::endl;
 183         }
 184
 185         uint32_t player_id;
 186         pack.ReadPlayerID(player_id);
 187         state.reset(new InteractiveState(*this, player_id));
 188
 189         pack.ReadPlayer(state->GetInterface().Player());
 190
 191         env.state.PopAfter(this);
 192         env.state.Push(state.get());
 193 }
 194
 195 void MasterState::On(const Packet::Part &pack) {
 196         if (state) {
 197                 // kicked
 198                 std::cout << "kicked by server" << std::endl;
 199         } else {
 200                 // join refused
 201                 std::cout << "login refused by server" << std::endl;
 202         }
 203         Quit();
 204 }
 205
 206 }
 207 }