604 lines
24 KiB
C++
604 lines
24 KiB
C++
#include "precompile.h"
|
|
|
|
#include <a8/mutable_xobject.h>
|
|
|
|
#include "framemaker.h"
|
|
#include "human.h"
|
|
#include "room.h"
|
|
#include "typeconvert.h"
|
|
#include "car.h"
|
|
#include "app.h"
|
|
#include "perfmonitor.h"
|
|
#include "incubator.h"
|
|
#include "frameeventdata.h"
|
|
#include "effect.h"
|
|
#include "sandtable.h"
|
|
|
|
#include "mt/AirLine.h"
|
|
|
|
void FrameMaker::Debug_FullObject(Human* hum)
|
|
{
|
|
#if 0
|
|
if (!hum->GetFrameData().new_objects.empty()) {
|
|
auto out_data = a8::MutableXObject::CreateArray();
|
|
for (auto& pair : hum->GetFrameData().new_objects) {
|
|
auto xobj = a8::MutableXObject::CreateObject();
|
|
xobj->SetVal("uniid", pair.first);
|
|
if (pair.second.Get()) {
|
|
xobj->SetVal("matched", 1);
|
|
xobj->SetVal("type", pair.second.Get()->GetEntityType());
|
|
xobj->SetVal("pos", a8::Format("%d,%d",
|
|
{pair.second.Get()->GetPos().x,
|
|
pair.second.Get()->GetPos().y}));
|
|
} else {
|
|
xobj->SetVal("matched", 0);
|
|
xobj->SetVal("type", 0);
|
|
xobj->SetVal("pos", a8::Format("%d,%d",
|
|
{0,
|
|
0}));
|
|
}
|
|
out_data->Push(*xobj);
|
|
}
|
|
hum->TraverseObservers
|
|
(
|
|
[&out_data] (Human* hum, bool& stop)
|
|
{
|
|
if (hum->IsPlayer()) {
|
|
hum->SendDebugMsg(a8::Format("view_debug frameno:%d server_full_obj:%s",
|
|
{
|
|
hum->room->GetFrameNo() / 2,
|
|
out_data->ToJsonStr()
|
|
}));
|
|
}
|
|
});
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void FrameMaker::Debug_OutObject(Human* hum)
|
|
{
|
|
#if 0
|
|
if (!hum->GetFrameData().out_objects.empty()) {
|
|
auto out_data = a8::MutableXObject::CreateArray();
|
|
for (auto& itr : hum->GetFrameData().out_objects) {
|
|
int uniid = itr;
|
|
auto xobj = a8::MutableXObject::CreateObject();
|
|
xobj->SetVal("uniid", uniid);
|
|
Entity* entity = hum->room->GetEntityByUniId(uniid);
|
|
if (entity) {
|
|
xobj->SetVal("matched", 1);
|
|
xobj->SetVal("pos", a8::Format("%d,%d", {entity->GetPos().x, entity->GetPos().y}));
|
|
} else {
|
|
xobj->SetVal("matched", 0);
|
|
xobj->SetVal("pos", a8::Format("%d,%d", {0, 0}));
|
|
}
|
|
out_data->Push(*xobj);
|
|
}
|
|
hum->TraverseObservers
|
|
(
|
|
[&out_data] (Human* hum, bool& stop)
|
|
{
|
|
if (hum->IsPlayer()) {
|
|
hum->SendDebugMsg(a8::Format("view_debug frameno:%d server_out_obj:%s",
|
|
{
|
|
hum->room->GetFrameNo() / 2,
|
|
out_data->ToJsonStr()
|
|
}));
|
|
}
|
|
});
|
|
}
|
|
#endif
|
|
}
|
|
|
|
std::shared_ptr<cs::SMUpdate> FrameMaker::MakeUpdateMsg(Human* hum)
|
|
{
|
|
FrameData* framedata = &hum->GetFrameData();
|
|
auto msg = std::make_shared<cs::SMUpdate>();
|
|
Room* room = hum->room;
|
|
|
|
PreProcess(msg.get(), room, hum, framedata);
|
|
SerializeLootObjects(msg.get(), room, hum, framedata);
|
|
SerializeNewObjects(msg.get(), room, hum, framedata);
|
|
SerializeImageObjects(msg.get(), room, hum, framedata);
|
|
SerializePartObjects(msg.get(), room, hum, framedata);
|
|
SerializeDelObjects(msg.get(), room, hum, framedata);
|
|
SerializeOutObjects(msg.get(), room, hum, framedata);
|
|
SerializeShots(msg.get(), room, hum, framedata);
|
|
SerializeEmotes(msg.get(), room, hum, framedata);
|
|
SerializeBullets(msg.get(), room, hum, framedata);
|
|
SerializePlaySkills(msg.get(), room, hum, framedata);
|
|
SerializeExplosions(msg.get(), room, hum, framedata);
|
|
SerializeChgedBuffs(msg.get(), room, hum, framedata);
|
|
SerializeChgedEffects(msg.get(), room, hum, framedata);
|
|
SerializeChgedBulletNums(msg.get(), room, hum, framedata);
|
|
SerializeChgedHps(msg.get(), room, hum, framedata);
|
|
SerializeChgedSkillCds(msg.get(), room, hum, framedata);
|
|
SerializeChgedSkillCurrTimes(msg.get(), room, hum, framedata);
|
|
SerializeChgedItems(msg.get(), room, hum, framedata);
|
|
SerializeChgedWeaponAmmo(msg.get(), room, hum, framedata);
|
|
SerializeDeadAliveObjs(msg.get(), room, hum, framedata);
|
|
SerializeChgedCars(msg.get(), room, hum, framedata);
|
|
SerializeChgedProps(msg.get(), room, hum, framedata);
|
|
SerializeDelBullets(msg.get(), room, hum, framedata);
|
|
PostProcess(msg.get(), room, hum, framedata);
|
|
return msg;
|
|
}
|
|
|
|
void FrameMaker::PreProcess(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
{
|
|
msg->set_frameno(hum->room->GetFrameNo() / 2);
|
|
if (hum->room->GetGasData().GetGasMode() == GasJump) {
|
|
cs::MFPlane* p = msg->mutable_plane();
|
|
TypeConvert::ToPb(hum->room->plane.start_point, p->mutable_start_point());
|
|
TypeConvert::ToPb(hum->room->plane.end_point, p->mutable_end_point());
|
|
TypeConvert::ToPb(hum->room->plane.curr_pos, p->mutable_pos());
|
|
p->set_plane_speed(room->GetAirLine()->plane_speed());
|
|
}
|
|
}
|
|
{
|
|
size_t chg_prop_size = framedata->chged_bullet_nums_.size() +
|
|
framedata->chged_hps_.size() * 2 +
|
|
framedata->chged_skillcds_.size() +
|
|
framedata->chged_skill_curr_times_.size() +
|
|
framedata->chged_items_.size() +
|
|
framedata->chged_weapon_ammo_.size() +
|
|
framedata->chged_cars_.size() +
|
|
framedata->chged_props_.size();
|
|
if (chg_prop_size > 0) {
|
|
msg->mutable_chged_property_list()->Reserve(chg_prop_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::PostProcess(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (room->frame_event_data->airdrops_.size() > 0) {
|
|
*msg->mutable_airdrop() = room->frame_event_data->airdrops_.Get(0);
|
|
}
|
|
if (room->frame_event_data->airraids_.size() > 0) {
|
|
*msg->mutable_airraid() = room->frame_event_data->airraids_.Get(0);
|
|
}
|
|
if (room->GetGasData().GetGasMode() == GasMoving) {
|
|
msg->set_gas_progress(room->GetGasData().gas_progress);
|
|
glm::vec3 v3(room->GetGasData().pos_old.x, 0.0f, room->GetGasData().pos_old.y);
|
|
TypeConvert::ToPb(v3, msg->mutable_gas_pos_old());
|
|
}
|
|
if (room->IsPveRoom()) {
|
|
int left_time = room->GetIncubator()->GetPveLeftTime();
|
|
msg->set_game_left_time(left_time);
|
|
} else if (room->IsMobaModeRoom()) {
|
|
int left_time = room->GetMobaLeftTime();
|
|
msg->set_game_left_time(left_time);
|
|
}
|
|
room->GetSandTable()->FillMFSandTable(msg, hum, framedata);
|
|
}
|
|
|
|
void FrameMaker::SerializeLootObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
|
|
}
|
|
|
|
void FrameMaker::SerializeNewObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->new_objects.empty()) {
|
|
#ifdef MYDEBUG
|
|
Debug_FullObject(hum);
|
|
#endif
|
|
msg->mutable_full_objects()->Reserve(framedata->new_objects.size());
|
|
if (framedata->new_objects.size() > PerfMonitor::Instance()->max_full_objects_num) {
|
|
PerfMonitor::Instance()->max_full_objects_num = framedata->new_objects.size();
|
|
}
|
|
for (auto& pair : framedata->new_objects) {
|
|
Entity* e = pair.second.Get();
|
|
if (!e) {
|
|
continue;
|
|
}
|
|
if (e != hum &&
|
|
e->GetEntityType() == ET_Player &&
|
|
((Human*)e)->HasBuffEffect(kBET_Fly)){
|
|
continue;
|
|
}
|
|
bool sync = false;
|
|
if ((hum->IsPlayer() || hum->HasObserver()) && e->CanSeeMe(hum)) {
|
|
sync = true;
|
|
e->FillMFObjectFull(room, (Human*)hum, msg->add_full_objects());
|
|
}
|
|
#ifdef MYDEBUG1
|
|
a8::XPrintf("add full object can_see:%d sync:%d type:%d\n", {e->CanSeeMe(hum), sync, hum->IsPlayer()});
|
|
#endif
|
|
#ifdef MYDEBUG
|
|
if (f8::App::Instance()->HasFlag(2) && e->GetEntityType() == ET_Player) {
|
|
hum->room->BroadcastDebugMsg(a8::Format("投放 %d pos:%d,%d 出现",
|
|
{
|
|
e->GetUniId(),
|
|
e->GetPos().GetX(),
|
|
e->GetPos().GetY(),
|
|
}));
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeImageObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (auto& pair : framedata->image_objects) {
|
|
Creature* c = pair.second.Get();
|
|
if (c) {
|
|
c->FillMFObjectImage(room, (Human*)hum, msg->add_image_objects());
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializePartObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->part_objects.empty()) {
|
|
msg->mutable_part_objects()->Reserve(framedata->part_objects.size());
|
|
if (framedata->part_objects.size() > PerfMonitor::Instance()->max_part_objects_num) {
|
|
PerfMonitor::Instance()->max_part_objects_num = framedata->part_objects.size();
|
|
}
|
|
int deleted_uniid = 0;
|
|
for (auto& pair : framedata->part_objects) {
|
|
Entity* entity = pair.second.object.Get();
|
|
if (!entity) {
|
|
#ifdef MYDEBUG1
|
|
A8_ABORT();
|
|
#endif
|
|
deleted_uniid = pair.first;
|
|
continue;
|
|
}
|
|
if (entity->IsDead(room) &&
|
|
hum->room->GetFrameNo() - entity->GetDeadFrameNo(room) > 10) {
|
|
continue;
|
|
} else {
|
|
if (room->GetGasData().GetGasMode() == GasJump &&
|
|
entity != hum &&
|
|
entity->GetEntityType() == ET_Player &&
|
|
((Human*)entity)->HasBuffEffect(kBET_Fly)) {
|
|
continue;
|
|
}
|
|
}
|
|
#if 0
|
|
if (((Human*)hum)->GetPos().ManhattanDistance(entity->GetPos()) > VIEW_RANGE + 300) {
|
|
continue;
|
|
}
|
|
#endif
|
|
entity->FillMFObjectPart(room, (Human*)hum, msg->add_part_objects());
|
|
}
|
|
if (deleted_uniid > 0) {
|
|
framedata->part_objects.erase(deleted_uniid);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeDelObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->del_objects.empty()) {
|
|
msg->mutable_del_objids()->Reserve(framedata->del_objects.size());
|
|
for (auto& itr : framedata->del_objects) {
|
|
msg->add_del_objids(itr);
|
|
#ifdef MYDEBUG
|
|
if (f8::App::Instance()->HasFlag(2)) {
|
|
room->BroadcastDebugMsg(a8::Format("投放 删除对象%d",
|
|
{
|
|
itr
|
|
}));
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeOutObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->out_objects.empty()) {
|
|
msg->mutable_out_objids()->Reserve(framedata->out_objects.size());
|
|
#ifdef MYDEBUG
|
|
Debug_OutObject(hum);
|
|
#endif
|
|
for (auto& itr : framedata->out_objects) {
|
|
msg->add_out_objids(itr);
|
|
#ifdef MYDEBUG
|
|
if (f8::App::Instance()->HasFlag(2)) {
|
|
room->BroadcastDebugMsg(a8::Format("投放 移除视野对象%d",
|
|
{
|
|
itr
|
|
}));
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeShots(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->shots_.empty()) {
|
|
msg->mutable_shots()->Reserve(framedata->shots_.size());
|
|
for (size_t idx : framedata->shots_) {
|
|
if (idx < room->frame_event_data->shots_.size()) {
|
|
auto& tuple = room->frame_event_data->shots_[idx];
|
|
if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
|
|
if (std::get<0>(tuple).Get()->IsPlayer()) {
|
|
a8::XPrintf("player shot\n", {});
|
|
}
|
|
*msg->add_shots() = std::get<1>(tuple);
|
|
} else {
|
|
#ifdef MYDEBUG1
|
|
A8_ABORT();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeEmotes(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->emotes_) {
|
|
msg->mutable_emotes()->Reserve(framedata->emotes_.size());
|
|
if (idx < room->frame_event_data->emotes_.size()) {
|
|
auto& tuple = room->frame_event_data->emotes_[idx];
|
|
if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
|
|
*msg->add_emotes() = std::get<1>(tuple);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeBullets(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->bullets_.empty()) {
|
|
msg->mutable_bullets()->Reserve(framedata->bullets_.size());
|
|
if (framedata->bullets_.size() > PerfMonitor::Instance()->max_bullet_num) {
|
|
PerfMonitor::Instance()->max_bullet_num = framedata->bullets_.size();
|
|
}
|
|
for (size_t idx : framedata->bullets_) {
|
|
if (idx < room->frame_event_data->bullets_.size()) {
|
|
auto& tuple = room->frame_event_data->bullets_[idx];
|
|
if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
|
|
*msg->add_bullets() = std::get<1>(tuple);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializePlaySkills(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->play_skills_) {
|
|
msg->mutable_play_skill_list()->Reserve(framedata->play_skills_.size());
|
|
if (idx < room->frame_event_data->play_skills_.size()) {
|
|
auto& tuple = room->frame_event_data->play_skills_[idx];
|
|
if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
|
|
*msg->add_play_skill_list() = std::get<1>(tuple);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeExplosions(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->explosions_) {
|
|
msg->mutable_explosions()->Reserve(framedata->explosions_.size());
|
|
if (idx < room->frame_event_data->explosions_.size()) {
|
|
auto& tuple = room->frame_event_data->explosions_[idx];
|
|
*msg->add_explosions() = std::get<1>(tuple);
|
|
#ifdef MYDEBUG1
|
|
a8::XPrintf("AddExplosion %d, %s pos=%d,%d effect:%d\n",
|
|
{
|
|
hum->GetUniId(),
|
|
hum->name,
|
|
std::get<1>(tuple).pos().x(),
|
|
std::get<1>(tuple).pos().y(),
|
|
std::get<1>(tuple).effect()
|
|
});
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedBuffs(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->chged_buffs_.empty()) {
|
|
msg->mutable_chged_buff_list()->Reserve(framedata->chged_buffs_.size());
|
|
for (size_t idx : framedata->chged_buffs_) {
|
|
if (idx < room->frame_event_data->chged_buffs_.size()) {
|
|
auto p = msg->add_chged_buff_list();
|
|
*p = std::get<1>(room->frame_event_data->chged_buffs_[idx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedEffects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->chged_effects_.empty()) {
|
|
msg->mutable_chged_effect_list()->Reserve(framedata->chged_effects_.size());
|
|
for (size_t idx : framedata->chged_effects_) {
|
|
if (idx < room->frame_event_data->chged_effects_.size()) {
|
|
auto p = msg->add_chged_effect_list();
|
|
*p = std::get<1>(room->frame_event_data->chged_effects_[idx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedBulletNums(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->chged_bullet_nums_.empty()) {
|
|
for (size_t idx : framedata->chged_bullet_nums_) {
|
|
if (idx < room->frame_event_data->chged_bullet_nums_.size()) {
|
|
CreatureWeakPtr& target = room->frame_event_data->chged_bullet_nums_[idx];
|
|
if (target.Get()->GetCurrWeapon()) {
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropBulletNum);
|
|
p->set_value(target.Get()->GetCurrWeapon()->ammo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedHps(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->chged_hps_) {
|
|
if (idx < room->frame_event_data->chged_hps_.size()) {
|
|
CreatureWeakPtr& target = room->frame_event_data->chged_hps_[idx];
|
|
if (target.Get() && hum->CanSee(target.Get())) {
|
|
{
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropHp);
|
|
p->set_value(target.Get()->GetHP());
|
|
}
|
|
{
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropMaxHp);
|
|
p->set_value(target.Get()->GetMaxHP());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedSkillCds(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->chged_skillcds_.empty()) {
|
|
for (size_t idx : framedata->chged_skillcds_) {
|
|
if (idx < room->frame_event_data->chged_skillcds_.size()) {
|
|
auto tuple = room->frame_event_data->chged_skillcds_[idx];
|
|
CreatureWeakPtr target = std::get<0>(tuple);
|
|
int skill_id = std::get<1>(tuple);
|
|
int left_time = std::get<2>(tuple);
|
|
if (target.Get()) {
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropSkillLeftTime);
|
|
p->set_property_subtype(skill_id);
|
|
p->set_value(left_time);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedSkillCurrTimes(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->chged_skill_curr_times_) {
|
|
if (idx < room->frame_event_data->chged_skill_curr_times_.size()) {
|
|
auto tuple = room->frame_event_data->chged_skill_curr_times_[idx];
|
|
CreatureWeakPtr& target = std::get<0>(tuple);
|
|
int skill_id = std::get<1>(tuple);
|
|
int curr_times = std::get<2>(tuple);
|
|
if (target.Get()) {
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropSkillCurrTimes);
|
|
p->set_property_subtype(skill_id);
|
|
p->set_value(curr_times);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedItems(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->chged_items_) {
|
|
if (idx < room->frame_event_data->chged_items_.size()) {
|
|
auto& tuple = room->frame_event_data->chged_items_[idx];
|
|
{
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id((std::get<0>(tuple)).Get()->GetUniId());
|
|
p->set_property_type(kPropItem);
|
|
p->set_property_subtype(std::get<1>(tuple));
|
|
p->set_value(std::get<2>(tuple));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedWeaponAmmo(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->chged_weapon_ammo_) {
|
|
if (idx < room->frame_event_data->chged_weapon_ammo_.size()) {
|
|
auto& tuple = room->frame_event_data->chged_weapon_ammo_[idx];
|
|
{
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id((std::get<0>(tuple)).Get()->GetUniId());
|
|
p->set_property_type(kPropWeaponAmmo);
|
|
p->set_property_subtype(std::get<1>(tuple));
|
|
p->set_value(std::get<2>(tuple));
|
|
p->set_value2(std::get<3>(tuple));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeDeadAliveObjs(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->dead_alive_objs_.empty()) {
|
|
msg->mutable_dead_alive_objs()->Reserve(framedata->dead_alive_objs_.size());
|
|
for (size_t idx : framedata->dead_alive_objs_) {
|
|
if (idx < room->frame_event_data->dead_alive_objs_.size()) {
|
|
auto p = msg->add_dead_alive_objs();
|
|
p->add_values(std::get<0>(room->frame_event_data->dead_alive_objs_[idx]));
|
|
p->add_values(std::get<1>(room->frame_event_data->dead_alive_objs_[idx]));
|
|
p->add_values(std::get<2>(room->frame_event_data->dead_alive_objs_[idx]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedCars(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
for (size_t idx : framedata->chged_cars_) {
|
|
if (idx < room->frame_event_data->chged_cars_.size()) {
|
|
CreatureWeakPtr& target = room->frame_event_data->chged_cars_[idx];
|
|
if (target.Get() && target.Get()->IsHuman() && hum->CanSee(target.Get())) {
|
|
auto p = msg->add_chged_property_list();
|
|
p->set_obj_id(target.Get()->GetUniId());
|
|
p->set_property_type(kPropCar);
|
|
if (target.Get()->AsHuman()->GetCar()) {
|
|
p->set_property_subtype(target.Get()->AsHuman()->GetCar()->GetUniId());
|
|
p->set_value(target.Get()->AsHuman()->GetSeat());
|
|
} else {
|
|
p->set_property_subtype(0);
|
|
p->set_value(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeChgedProps(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->chged_props_.empty()) {
|
|
msg->mutable_chged_property_list()->Reserve(framedata->chged_props_.size());
|
|
for (size_t idx : framedata->chged_props_) {
|
|
if (idx < room->frame_event_data->chged_props_.size()) {
|
|
auto& p = room->frame_event_data->chged_props_[idx];
|
|
auto& target = std::get<0>(p);
|
|
if (target.Get()) {
|
|
*msg->add_chged_property_list() = std::get<1>(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FrameMaker::SerializeDelBullets(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
|
|
{
|
|
if (!framedata->del_bullets_.empty()) {
|
|
msg->mutable_del_bullets()->Reserve(framedata->del_bullets_.size());
|
|
for (size_t idx : framedata->del_bullets_) {
|
|
if (idx < room->frame_event_data->del_bullets_.size()) {
|
|
int bullet_uniid = room->frame_event_data->del_bullets_[idx];
|
|
msg->add_del_bullets(bullet_uniid);
|
|
}
|
|
}
|
|
}
|
|
}
|