3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 #include "content_sao.h"
21 #include "collision.h"
22 #include "environment.h"
24 #include "main.h" // For g_profiler
26 #include "serialization.h" // For compressZlib
27 #include "tool.h" // For ToolCapabilities
30 core::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
36 class DummyLoadSAO : public ServerActiveObject
39 DummyLoadSAO(ServerEnvironment *env, v3f pos, u8 type):
40 ServerActiveObject(env, pos)
42 ServerActiveObject::registerType(type, create);
44 // Pretend to be the test object (to fool the client)
46 { return ACTIVEOBJECT_TYPE_TEST; }
47 // And never save to disk
48 bool isStaticAllowed() const
51 static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
52 const std::string &data)
54 return new DummyLoadSAO(env, pos, 0);
57 void step(float dtime, bool send_recommended)
60 infostream<<"DummyLoadSAO step"<<std::endl;
66 // Prototype (registers item for deserialization)
67 DummyLoadSAO proto1_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_RAT);
68 DummyLoadSAO proto2_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_OERKKI1);
69 DummyLoadSAO proto3_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_FIREFLY);
70 DummyLoadSAO proto4_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_MOBV2);
76 class TestSAO : public ServerActiveObject
79 TestSAO(ServerEnvironment *env, v3f pos):
80 ServerActiveObject(env, pos),
84 ServerActiveObject::registerType(getType(), create);
87 { return ACTIVEOBJECT_TYPE_TEST; }
89 static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
90 const std::string &data)
92 return new TestSAO(env, pos);
95 void step(float dtime, bool send_recommended)
104 m_base_position.Y += dtime * BS * 2;
105 if(m_base_position.Y > 8*BS)
106 m_base_position.Y = 2*BS;
108 if(send_recommended == false)
118 data += itos(0); // 0 = position
120 data += itos(m_base_position.X);
122 data += itos(m_base_position.Y);
124 data += itos(m_base_position.Z);
126 ActiveObjectMessage aom(getId(), false, data);
127 m_messages_out.push_back(aom);
136 // Prototype (registers item for deserialization)
137 TestSAO proto_TestSAO(NULL, v3f(0,0,0));
143 class ItemSAO : public ServerActiveObject
147 { return ACTIVEOBJECT_TYPE_ITEM; }
149 float getMinimumSavedMovement()
152 static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
153 const std::string &data)
155 std::istringstream is(data, std::ios::binary);
160 // check if version is supported
163 std::string itemstring = deSerializeString(is);
164 infostream<<"create(): Creating item \""
165 <<itemstring<<"\""<<std::endl;
166 return new ItemSAO(env, pos, itemstring);
169 ItemSAO(ServerEnvironment *env, v3f pos,
170 const std::string itemstring):
171 ServerActiveObject(env, pos),
172 m_itemstring(itemstring),
173 m_itemstring_changed(false),
175 m_last_sent_position(0,0,0)
177 ServerActiveObject::registerType(getType(), create);
180 void step(float dtime, bool send_recommended)
182 ScopeProfiler sp2(g_profiler, "step avg", SPT_AVG);
186 const float interval = 0.2;
187 if(m_move_interval.step(dtime, interval)==false)
191 core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
192 collisionMoveResult moveresult;
194 m_speed_f += v3f(0, -dtime*9.81*BS, 0);
195 // Maximum movement without glitches
196 f32 pos_max_d = BS*0.25;
198 if(m_speed_f.getLength()*dtime > pos_max_d)
199 m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
200 v3f pos_f = getBasePosition();
201 v3f pos_f_old = pos_f;
202 IGameDef *gamedef = m_env->getGameDef();
203 moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
204 pos_max_d, box, dtime, pos_f, m_speed_f);
206 if(send_recommended == false)
209 if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
211 setBasePosition(pos_f);
212 m_last_sent_position = pos_f;
214 std::ostringstream os(std::ios::binary);
215 // command (0 = update position)
218 writeV3F1000(os, m_base_position);
219 // create message and add to list
220 ActiveObjectMessage aom(getId(), false, os.str());
221 m_messages_out.push_back(aom);
223 if(m_itemstring_changed)
225 m_itemstring_changed = false;
227 std::ostringstream os(std::ios::binary);
228 // command (1 = update itemstring)
231 os<<serializeString(m_itemstring);
232 // create message and add to list
233 ActiveObjectMessage aom(getId(), false, os.str());
234 m_messages_out.push_back(aom);
238 std::string getClientInitializationData()
240 std::ostringstream os(std::ios::binary);
244 writeV3F1000(os, m_base_position);
246 os<<serializeString(m_itemstring);
250 std::string getStaticData()
252 infostream<<__FUNCTION_NAME<<std::endl;
253 std::ostringstream os(std::ios::binary);
257 os<<serializeString(m_itemstring);
261 ItemStack createItemStack()
264 IItemDefManager *idef = m_env->getGameDef()->idef();
266 item.deSerialize(m_itemstring, idef);
267 infostream<<__FUNCTION_NAME<<": m_itemstring=\""<<m_itemstring
268 <<"\" -> item=\""<<item.getItemString()<<"\""
272 catch(SerializationError &e)
274 infostream<<__FUNCTION_NAME<<": serialization error: "
275 <<"m_itemstring=\""<<m_itemstring<<"\""<<std::endl;
281 const ToolCapabilities *toolcap,
282 ServerActiveObject *puncher,
283 float time_from_last_punch)
285 // Directly delete item in creative mode
286 if(g_settings->getBool("creative_mode") == true)
292 // Take item into inventory
293 ItemStack item = createItemStack();
294 Inventory *inv = puncher->getInventory();
297 std::string wieldlist = puncher->getWieldList();
298 ItemStack leftover = inv->addItem(wieldlist, item);
299 puncher->setInventoryModified();
306 m_itemstring = leftover.getItemString();
307 m_itemstring_changed = true;
316 std::string m_itemstring;
317 bool m_itemstring_changed;
319 v3f m_last_sent_position;
320 IntervalLimiter m_move_interval;
323 // Prototype (registers item for deserialization)
324 ItemSAO proto_ItemSAO(NULL, v3f(0,0,0), "");
326 ServerActiveObject* createItemSAO(ServerEnvironment *env, v3f pos,
327 const std::string itemstring)
329 return new ItemSAO(env, pos, itemstring);
336 #include "scriptapi.h"
337 #include "luaentity_common.h"
339 // Prototype (registers item for deserialization)
340 LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
342 LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
343 const std::string &name, const std::string &state):
344 ServerActiveObject(env, pos),
348 m_prop(new LuaEntityProperties),
351 m_acceleration(0,0,0),
354 m_last_sent_position(0,0,0),
355 m_last_sent_velocity(0,0,0),
356 m_last_sent_position_timer(0),
357 m_last_sent_move_precision(0),
358 m_armor_groups_sent(false)
360 // Only register type if no environment supplied
362 ServerActiveObject::registerType(getType(), create);
366 // Initialize something to armor groups
367 m_armor_groups["fleshy"] = 3;
368 m_armor_groups["snappy"] = 2;
371 LuaEntitySAO::~LuaEntitySAO()
374 lua_State *L = m_env->getLua();
375 scriptapi_luaentity_rm(L, m_id);
380 void LuaEntitySAO::addedToEnvironment()
382 ServerActiveObject::addedToEnvironment();
384 // Create entity from name
385 lua_State *L = m_env->getLua();
386 m_registered = scriptapi_luaentity_add(L, m_id, m_init_name.c_str());
390 scriptapi_luaentity_get_properties(L, m_id, m_prop);
391 // Initialize HP from properties
392 m_hp = m_prop->hp_max;
395 // Activate entity, supplying serialized state
396 scriptapi_luaentity_activate(L, m_id, m_init_state.c_str());
399 ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
400 const std::string &data)
408 std::istringstream is(data, std::ios::binary);
410 u8 version = readU8(is);
411 // check if version is supported
413 name = deSerializeString(is);
414 state = deSerializeLongString(is);
416 else if(version == 1){
417 name = deSerializeString(is);
418 state = deSerializeLongString(is);
420 velocity = readV3F1000(is);
425 infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
426 <<state<<"\")"<<std::endl;
427 LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
429 sao->m_velocity = velocity;
434 void LuaEntitySAO::step(float dtime, bool send_recommended)
436 m_last_sent_position_timer += dtime;
438 if(m_prop->physical){
439 core::aabbox3d<f32> box = m_prop->collisionbox;
442 collisionMoveResult moveresult;
443 f32 pos_max_d = BS*0.25; // Distance per iteration
444 v3f p_pos = getBasePosition();
445 v3f p_velocity = m_velocity;
446 IGameDef *gamedef = m_env->getGameDef();
447 moveresult = collisionMovePrecise(&m_env->getMap(), gamedef,
448 pos_max_d, box, dtime, p_pos, p_velocity);
450 setBasePosition(p_pos);
451 m_velocity = p_velocity;
453 m_velocity += dtime * m_acceleration;
455 m_base_position += dtime * m_velocity + 0.5 * dtime
456 * dtime * m_acceleration;
457 m_velocity += dtime * m_acceleration;
461 lua_State *L = m_env->getLua();
462 scriptapi_luaentity_step(L, m_id, dtime);
465 if(send_recommended == false)
468 // TODO: force send when acceleration changes enough?
469 float minchange = 0.2*BS;
470 if(m_last_sent_position_timer > 1.0){
472 } else if(m_last_sent_position_timer > 0.2){
475 float move_d = m_base_position.getDistanceFrom(m_last_sent_position);
476 move_d += m_last_sent_move_precision;
477 float vel_d = m_velocity.getDistanceFrom(m_last_sent_velocity);
478 if(move_d > minchange || vel_d > minchange ||
479 fabs(m_yaw - m_last_sent_yaw) > 1.0){
480 sendPosition(true, false);
483 if(m_armor_groups_sent == false){
484 m_armor_groups_sent = true;
485 std::ostringstream os(std::ios::binary);
486 writeU8(os, LUAENTITY_CMD_UPDATE_ARMOR_GROUPS);
487 writeU16(os, m_armor_groups.size());
488 for(ItemGroupList::const_iterator i = m_armor_groups.begin();
489 i != m_armor_groups.end(); i++){
490 os<<serializeString(i->first);
491 writeS16(os, i->second);
493 // create message and add to list
494 ActiveObjectMessage aom(getId(), true, os.str());
495 m_messages_out.push_back(aom);
499 std::string LuaEntitySAO::getClientInitializationData()
501 std::ostringstream os(std::ios::binary);
505 writeV3F1000(os, m_base_position);
507 writeF1000(os, m_yaw);
511 std::ostringstream prop_os(std::ios::binary);
512 m_prop->serialize(prop_os);
513 os<<serializeLongString(prop_os.str());
518 std::string LuaEntitySAO::getStaticData()
520 infostream<<__FUNCTION_NAME<<std::endl;
521 std::ostringstream os(std::ios::binary);
525 os<<serializeString(m_init_name);
528 lua_State *L = m_env->getLua();
529 std::string state = scriptapi_luaentity_get_staticdata(L, m_id);
530 os<<serializeLongString(state);
532 os<<serializeLongString(m_init_state);
537 writeV3F1000(os, m_velocity);
539 writeF1000(os, m_yaw);
543 int LuaEntitySAO::punch(v3f dir,
544 const ToolCapabilities *toolcap,
545 ServerActiveObject *puncher,
546 float time_from_last_punch)
549 // Delete unknown LuaEntities when punched
554 ItemStack *punchitem = NULL;
555 ItemStack punchitem_static;
557 punchitem_static = puncher->getWieldedItem();
558 punchitem = &punchitem_static;
561 PunchDamageResult result = getPunchDamage(
565 time_from_last_punch);
569 setHP(getHP() - result.damage);
571 actionstream<<getDescription()<<" punched by "
572 <<puncher->getDescription()<<", damage "<<result.damage
573 <<" hp, health now "<<getHP()<<" hp"<<std::endl;
576 std::ostringstream os(std::ios::binary);
578 writeU8(os, LUAENTITY_CMD_PUNCHED);
580 writeS16(os, result.damage);
582 writeS16(os, getHP());
583 // create message and add to list
584 ActiveObjectMessage aom(getId(), true, os.str());
585 m_messages_out.push_back(aom);
592 lua_State *L = m_env->getLua();
593 scriptapi_luaentity_punch(L, m_id, puncher,
594 time_from_last_punch, toolcap, dir);
599 void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
603 lua_State *L = m_env->getLua();
604 scriptapi_luaentity_rightclick(L, m_id, clicker);
607 void LuaEntitySAO::setHP(s16 hp)
613 s16 LuaEntitySAO::getHP()
618 void LuaEntitySAO::setPos(v3f pos)
620 m_base_position = pos;
621 sendPosition(false, true);
624 void LuaEntitySAO::moveTo(v3f pos, bool continuous)
626 m_base_position = pos;
628 sendPosition(true, true);
631 float LuaEntitySAO::getMinimumSavedMovement()
636 std::string LuaEntitySAO::getDescription()
638 std::ostringstream os(std::ios::binary);
639 os<<"LuaEntitySAO at (";
640 os<<(m_base_position.X/BS)<<",";
641 os<<(m_base_position.Y/BS)<<",";
642 os<<(m_base_position.Z/BS);
644 return std::string("LuaEntitySAO");
647 void LuaEntitySAO::setVelocity(v3f velocity)
649 m_velocity = velocity;
652 v3f LuaEntitySAO::getVelocity()
657 void LuaEntitySAO::setAcceleration(v3f acceleration)
659 m_acceleration = acceleration;
662 v3f LuaEntitySAO::getAcceleration()
664 return m_acceleration;
667 void LuaEntitySAO::setYaw(float yaw)
672 float LuaEntitySAO::getYaw()
677 void LuaEntitySAO::setTextureMod(const std::string &mod)
679 std::ostringstream os(std::ios::binary);
681 writeU8(os, LUAENTITY_CMD_SET_TEXTURE_MOD);
683 os<<serializeString(mod);
684 // create message and add to list
685 ActiveObjectMessage aom(getId(), false, os.str());
686 m_messages_out.push_back(aom);
689 void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
690 bool select_horiz_by_yawpitch)
692 std::ostringstream os(std::ios::binary);
694 writeU8(os, LUAENTITY_CMD_SET_SPRITE);
697 writeU16(os, num_frames);
698 writeF1000(os, framelength);
699 writeU8(os, select_horiz_by_yawpitch);
700 // create message and add to list
701 ActiveObjectMessage aom(getId(), false, os.str());
702 m_messages_out.push_back(aom);
705 std::string LuaEntitySAO::getName()
710 void LuaEntitySAO::setArmorGroups(const ItemGroupList &armor_groups)
712 m_armor_groups = armor_groups;
713 m_armor_groups_sent = false;
716 void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
718 m_last_sent_move_precision = m_base_position.getDistanceFrom(
719 m_last_sent_position);
720 m_last_sent_position_timer = 0;
721 m_last_sent_yaw = m_yaw;
722 m_last_sent_position = m_base_position;
723 m_last_sent_velocity = m_velocity;
724 //m_last_sent_acceleration = m_acceleration;
726 float update_interval = m_env->getSendRecommendedInterval();
728 std::ostringstream os(std::ios::binary);
730 writeU8(os, LUAENTITY_CMD_UPDATE_POSITION);
733 writeU8(os, do_interpolate);
735 writeV3F1000(os, m_base_position);
737 writeV3F1000(os, m_velocity);
739 writeV3F1000(os, m_acceleration);
741 writeF1000(os, m_yaw);
742 // is_end_position (for interpolation)
743 writeU8(os, is_movement_end);
744 // update_interval (for interpolation)
745 writeF1000(os, update_interval);
747 // create message and add to list
748 ActiveObjectMessage aom(getId(), false, os.str());
749 m_messages_out.push_back(aom);