void FeatureInst::deserialize(GameState* gs, SerializeBuffer& serializer) {
GameInst::deserialize(gs, serializer);
serializer.read_int(feature);
serializer.read_int(last_seen_spr);
serializer.read_int(spriteid);
serializer.read_int(sprite_frame);
}
void net_recv_game_init_data(SerializeBuffer& sb, int sender,
GameStateInitData& init_data, PlayerData& pd) {
//Write seed
sb.read_int(init_data.seed);
init_data.seed_set_by_network_message = true;
//Read player data
int localidx;
sb.read_int(localidx);
pd.set_local_player_idx(localidx);
int playern;
sb.read_int(playern);
LANARTS_ASSERT(pd.all_players().empty());
for (int i = 0; i < playern; i++) {
std::string name;
class_id classtype;
int net_id;
sb.read(name);
sb.read_int(classtype);
sb.read_int(net_id);
pd.register_player(name, NULL, classtype, net_id);
}
printf("Received init packet: seed = 0x%X, localid = %d, nplayers = %d\n",
init_data.seed, localidx, playern);
}
void GameInstSet::deserialize(GameState* gs, SerializeBuffer& serializer) {
serializer.read_int(grid_w);
serializer.read_int(grid_h);
//Resize and clear
unit_grid.resize(grid_w * grid_h);
clear();
int amnt;
serializer.read_int(amnt);
serializer.read_int(next_id);
for (int i = 0; i < amnt; i++) {
InstType type;
int id;
serializer.read_int(type);
serializer.read_int(id);
printf("Deserializing id=%d\n", id);
GameInst* inst = get_instance(id);
bool has_inst = inst != NULL;
if (!has_inst) {
inst = from_inst_type(type);
inst->deserialize(gs, serializer);
inst->last_x = inst->x;
inst->last_y = inst->y;
inst->id = id;
add_instance(inst, inst->id);
} else {
safe_deserialize(inst, gs, serializer);
}
LANARTS_ASSERT(
serializer_equals_read(serializer, inst->integrity_hash()));
}
}
void net_recv_game_init_data(SerializeBuffer& sb, int sender,
GameStateInitData& init_data, PlayerData& pd) {
//Write seed
sb.read(init_data);
init_data.received_init_data = true;
//Read player data
int localidx;
sb.read_int(localidx);
int playern;
sb.read_int(playern);
LANARTS_ASSERT(pd.all_players().empty());
for (int i = 0; i < playern; i++) {
std::string name;
std::string classtype;
int net_id;
sb.read(name);
sb.read(classtype);
sb.read_int(net_id);
pd.register_player(name, NULL, classtype, LuaValue(), (i == localidx), net_id);
}
printf(
"Received init packet: seed = 0x%X, localid = %d, nplayers = %d, "
"frame_action_repeat = %d, regen_level_on_death = %d, network_debug_mode = %d, time_per_step = %f\n",
init_data.seed, localidx, playern, init_data.frame_action_repeat,
(int) init_data.regen_on_death,
(int) init_data.network_debug_mode, init_data.time_per_step);
}
void Equipment::deserialize(SerializeBuffer& serializer) {
inventory.deserialize(serializer);
weapon.deserialize(serializer);
projectile.deserialize(serializer);
serializer.read_int(projectile_amnt);
armour.deserialize(serializer);
serializer.read_int(money);
}
void EffectStats::deserialize(GameState* gs, SerializeBuffer& serializer) {
lua_State* L = gs->get_luastate();
for (int i = 0; i < EFFECTS_MAX; i++) {
serializer.read_int(effects[i].effectid);
effects[i].state.deserialize(L, serializer);
if (!effects[i].state.isnil(L)) {
lua_init_metatable(L, effects[i].state, effects[i].effectid);
}
serializer.read_int(effects[i].t_remaining);
}
}
void net_recv_player_actions(SerializeBuffer& sb, int sender, PlayerData& pd) {
int frame, player_number;
sb.read_int(frame);
sb.read_int(player_number);
PlayerDataEntry& pde = pd.all_players().at(player_number);
ActionQueue actions;
sb.read_container(actions);
pde.action_queue.queue_actions_for_frame(actions, frame);
// printf("Receiving %d actions for player %d from %d \n", actions.size(),
// player_number, sender);
}
bool GameNetConnection::_handle_message(int sender,
SerializeBuffer& serializer) {
// Read type from buffer
message_t type;
serializer.read_int(type);
switch (type) {
case PACKET_CLIENT2SERV_CONNECTION_AFFIRM: {
net_recv_connection_affirm(serializer, sender, pd);
break;
}
case PACKET_SERV2CLIENT_INITIALPLAYERDATA: {
net_recv_game_init_data(serializer, sender, init_data, pd);
break;
}
case PACKET_ACTION: {
net_recv_player_actions(serializer, sender, pd);
break;
}
case PACKET_CHAT_MESSAGE: {
ChatMessage msg;
msg.deserialize(serializer);
chat.add_message(msg);
break;
}
default:
serializer.move_read_position(-(int)sizeof(int));
return false;
}
return true;
}
void GameScreen::deserialize(GameState *gs, SerializeBuffer &serializer) {
serializer.read_int(index);
// hud details not serialized as they are ephermal user interface state
serializer.read(focus_player_id);
current_level = read_gamemap(gs, serializer);
serializer.read(last_player_pos);
}
// Only the server is concerned with this message
void net_recv_connection_affirm(SerializeBuffer& sb, int sender,
PlayerData& pd) {
std::string name;
class_id classtype;
sb.read(name);
sb.read_int(classtype);
printf("connection affirm read\n");
pd.register_player(name, NULL, classtype, sender);
printf("now there are %d players\n", (int)pd.all_players().size());
pd.set_local_player_idx(0);
}
void net_recv_sync_data(SerializeBuffer& sb, GameState* gs) {
printf("Got sync on frame %d\n", gs->frame());
int mtwistseed;
sb.read_int(mtwistseed);
gs->rng().init_genrand(mtwistseed);
gs->deserialize(sb);
std::vector<PlayerDataEntry>& pdes = gs->player_data().all_players();
for (int i = 0; i < pdes.size(); i++) {
pdes[i].player()->set_local_player(pdes[i].is_local_player);
}
}
static bool has_message(std::vector<QueuedMessage>& delayed_messages,
int type) {
for (int i = 0; i < delayed_messages.size(); i++) {
SerializeBuffer* msg = delayed_messages[i].message;
int msg_type;
msg->read_int(msg_type);
msg->move_read_position(-(int)sizeof(int));
if (type == msg_type) {
return true;
}
}
return false;
}
void net_recv_sync_data(SerializeBuffer& sb, GameState* gs) {
int mtwistseed;
sb.read_int(mtwistseed);
gs->rng().init_genrand(mtwistseed);
int nplayer = gs->player_data().get_local_player_idx();
gs->deserialize(sb);
std::vector<PlayerDataEntry>& pdes = gs->player_data().all_players();
for (int i = 0; i < pdes.size(); i++) {
pdes[i].player()->set_local_player(false);
}
gs->player_data().set_local_player_idx(nplayer);
gs->game_world().set_current_level(gs->local_player()->current_level);
}
static int find_message_type(QueuedMessage& qm,
std::vector<QueuedMessage>& delayed_messages, int type) {
for (int i = 0; i < delayed_messages.size(); i++) {
qm = delayed_messages[i];
SerializeBuffer* msg = qm.message;
int msg_type;
msg->read_int(msg_type);
msg->move_read_position(-(int) sizeof(int));
if (type == msg_type) {
return i;
}
}
return -1;
}
void GameScreenSet::deserialize(GameState *gs, SerializeBuffer &serializer) {
serializer.read_int(current_screen);
simulation_map = read_gamemap(gs, serializer);
serializer.read_container(screens, [&](GameScreen& screen) {
screen.deserialize(gs, serializer);
});
GameSettings& settings = gs->game_settings();
int n_local_players = 0;
for (PlayerDataEntry &player: gs->player_data().all_players()) {
if (player.is_local_player) {
n_local_players++;
}
}
// Number of split-screens tiled together
int n_x = 1, n_y = 1;
if (n_local_players <= 2) {
n_x = n_local_players;
} else if (n_local_players <= 4) {
// More than 2, less than 4? Try 2x2 tiling
n_x = 2, n_y = 2;
} else if (n_local_players <= 6) {
n_x = 3, n_y = 2;
} else {
LANARTS_ASSERT(n_local_players <= 9);
// Last resort, Try 3x3 tiling
n_x = 3, n_y = 3;
}
const int WIDTH = settings.view_width / n_x;
const int HEIGHT = settings.view_height / n_y; // / N_PLAYERS;
std::vector<BBox> bounding_boxes;
for (GameScreen& screen : screens) {
const int x1 = (screen.index % n_x) * WIDTH, y1 = (screen.index / n_x) * HEIGHT;
bounding_boxes.push_back(BBox {x1, y1, x1 + WIDTH, y1 + HEIGHT});
}
if (bounding_boxes.size() == 3) {
bounding_boxes[1] = {WIDTH, 0, settings.view_width, settings.view_height};
}
for (GameScreen& screen : screens) {
BBox b = bounding_boxes[screen.index];
screen.window_region = b;
screen.hud = GameHud {
BBox(b.x2 - GAME_SIDEBAR_WIDTH, b.y1, b.x2, b.y2),
BBox(b.x1, b.y1, b.x2 - GAME_SIDEBAR_WIDTH, b.y2)
};
screen.view = GameView {0, 0, b.width() - GAME_SIDEBAR_WIDTH, b.height()};
}
}
static bool extract_message(QueuedMessage& qm,
std::vector<QueuedMessage>& delayed_messages, int type) {
for (int i = 0; i < delayed_messages.size(); i++) {
qm = delayed_messages[i];
SerializeBuffer* msg = qm.message;
int msg_type;
msg->read_int(msg_type);
if (type == msg_type) {
delayed_messages.erase(delayed_messages.begin() + i);
return true;
}
msg->move_read_position(-(int)sizeof(int));
}
return false;
}
