void environment::spawn_player(point2 location)
{
// player props
auto weapon = std::make_shared<body_component::item_type>();
weapon->add({ rl::effect::weapon_damage, 0x00, 50 });
weapon->add({ rl::effect::equipment, static_cast<unsigned int>(rl::equipment_slot::hand_main) });
weapon->set_name("Copper Sword");
weapon->set_tag("copper_sword");
// make player
auto task = m_factory->produce();
auto img = task->add_appearance('@', { 1, 1, 1 });
auto pawn = task->add_location(location);
auto body = task->add_body(100, 100);
auto character = task->add_character();
// setup
body->set_name("You");
body->set_tag("player");
body->join_faction(1);
body->add(weapon);
body->equip(weapon);
character->add_skill("sk_bash");
character->add_skill("sk_panacea");
character->add_skill("sk_teleport");
character->add_skill("sk_fireball");
character->add_skill("sk_indigo");
m_terrain.add(task->assemble(persistency::permanent));
impersonate(pawn);
}
void notify_ops(CHANNEL * chan, const char *fmt, ...)
{
LIST *list;
CHANUSER *chanUser;
char buf[256];
int len;
va_list ap;
va_start(ap, fmt);
vsnprintf(buf + 4, sizeof(buf) - 4, fmt, ap);
va_end(ap);
len = strlen(buf + 4);
set_len(buf, len);
set_tag(buf, MSG_SERVER_NOSUCH);
for (list = chan->users; list; list = list->next)
{
chanUser = list->data;
ASSERT(chanUser->magic == MAGIC_CHANUSER);
if(ISUSER(chanUser->user->con) && ((chanUser->flags & ON_CHANNEL_OPERATOR) || chanUser->user->level > LEVEL_USER))
{
queue_data(chanUser->user->con, buf, 4 + len);
}
}
}
void
tags_box_widget::set_tags(const std::list<uint>& l)
{
reset_tags();
std::list<uint>::const_iterator iter;
for (iter = l.begin(); iter != l.end(); iter++) {
set_tag((int)*iter);
}
}
/**
* Create new guarded memory.
*
* Wraps, starting at the given "base_ptr" with guards. Allows reuse of stack allocated helper.
*
* @param base_ptr allocation wishing to be wrapped, must be at least "GuardedMemory::get_total_size()" bytes.
* @param user_size the size of the user data to be wrapped.
* @param tag optional general purpose tag.
*
* @return user data pointer (inner pointer to supplied "base_ptr").
*/
void* wrap_with_guards(void* base_ptr, size_t user_size, const void* tag = NULL) {
assert(base_ptr != NULL, "Attempt to wrap NULL with memory guard");
_base_addr = (u_char*)base_ptr;
get_head_guard()->build();
get_head_guard()->set_user_size(user_size);
get_tail_guard()->build();
set_tag(tag);
set_user_bytes(uninitBlockPad);
assert(verify_guards(), "Expected valid memory guards");
return get_user_ptr();
}
void LoginScene::loginRelease( CCObject* sender )
{
auto pWidget = dynamic_cast<UIWidget*>(dynamic_cast<UIButton*>(sender)->getParent());
auto pTBName = dynamic_cast<UITextField*>(pWidget->getChildByName("name_TextField"));
auto pTBPassword = dynamic_cast<UITextField*>(pWidget->getChildByName("password_TextField"));
boost::shared_ptr<common::Login> pMsgLogin(new common::Login);
pMsgLogin->set_username(pTBName->getStringValue());
pMsgLogin->set_password(pTBPassword->getStringValue());
auto pConnection = game_network::get_instance()->create_connection("127.0.0.1", "1991");
pConnection->set_tag(GAME_SESSION);
game_network::get_instance()->send_message_after_connected_send(SESSIONS::GAME_SESSION, pMsgLogin);
}
static void push_node(lua_State *L, const GumboNode *node) {
luaL_checkstack(L, 10, "Unable to allocate Lua stack space");
switch (node->type) {
case GUMBO_NODE_ELEMENT: {
const GumboElement *element = &node->v.element;
lua_createtable(L, 0, 7);
set_tag(L, element);
set_sourcepos(L, element->start_pos);
if (node->parse_flags != GUMBO_INSERTION_NORMAL) {
set_integer(L, "parseFlags", node->parse_flags);
}
set_attributes(L, &element->attributes);
set_children(L, &element->children, 1);
setmetatable(L, Element);
return;
}
case GUMBO_NODE_TEMPLATE: {
const GumboElement *element = &node->v.element;
lua_createtable(L, 0, 8);
set_literal(L, "localName", "template");
set_sourcepos(L, element->start_pos);
set_attributes(L, &element->attributes);
lua_createtable(L, 0, 0);
setmetatable(L, NodeList);
lua_setfield(L, -2, "childNodes");
lua_createtable(L, 0, 1);
set_children(L, &element->children, 1);
setmetatable(L, DocumentFragment);
lua_setfield(L, -2, "content");
setmetatable(L, Element);
return;
}
case GUMBO_NODE_TEXT:
create_text_node(L, &node->v.text, Text);
return;
case GUMBO_NODE_WHITESPACE:
create_text_node(L, &node->v.text, Text);
set_literal(L, "type", "whitespace");
return;
case GUMBO_NODE_COMMENT:
create_text_node(L, &node->v.text, Comment);
return;
case GUMBO_NODE_CDATA:
create_text_node(L, &node->v.text, Text);
set_literal(L, "type", "cdata");
return;
default:
luaL_error(L, "GumboNodeType value out of bounds: %d", node->type);
return;
}
}
/* SensorSettings with arguments */
SensorSettings::SensorSettings (const Glib::ustring& tag,
bool online,
const gdouble x,
const gdouble y,
const guint adata,
const Glib::ustring& type)
{
set_tag (tag);
set_online (online);
set_x_coord (x);
set_y_coord (y);
set_amount_data (adata);
set_type (type);
}
void environment::start()
{
end();
m_time = 0;
m_running = true;
m_world.resize(settings::world_width, settings::world_height);
m_world.generate(m_settings.seed());
spawn_player(m_world.spawn() * point2(settings::cell_width, settings::cell_height));
// ui
tie_map();
m_ui->deactivate("title");
m_ui->activate("ingame");
// make chest
auto chest = m_factory->produce();
chest->add_appearance('$', { 1, 1, 1 });
chest->add_location({ 2, 2 });
auto body = chest->add_body(250, 150);
body->set_name("Iron chest");
chest->add_container();
m_terrain.add(*chest);
auto ore = std::make_shared<body_component::item_type>();
ore->add({ rl::effect::ore_power, 0x00, 10 });
ore->add({ rl::effect::value, 0x00, 5 });
ore->add({ rl::effect::weight, 0x00, 1 });
ore->set_name("Copper ore");
ore->set_tag("ore_copper");
auto vein = m_factory->produce();
vein->add_appearance('0');
vein->add_location({ 3, 3 });
vein->add_body();
auto v = vein->add_resource();
v->deposit(ore);
m_terrain.add(*vein);
auto anvil = m_factory->produce();
anvil->add_appearance('t');
anvil->add_location({ 3, 0 });
anvil->add_body();
anvil->add_container();
m_terrain.add(*anvil);
}
inline set_tag
container_category(const TestSet&) {
return set_tag();
}
set_tag container_category(const BOOST_STD_EXTENSION_NAMESPACE::hash_set<Key,Eq,Hash,Alloc>&)
{ return set_tag(); }
set_tag container_category(const std::set<Key,Cmp,Alloc>&)
{ return set_tag(); }
inline explicit tagged_ptr(value_type* ptr, tag_type tag)
:
tagged_ptr(ptr)
{
set_tag(tag);
}
inline void reset(value_t* ptr, tag_type tag)
{
ptr_ = ptr;
set_tag(tag);
}
inline void reset(tag_type tag)
{
ptr_ = nullptr;
set_tag(tag);
}
