LocatedEntity * CharacterClient::lookFor(const RootEntity & ent)
{
Look op;
op->setArgs1(ent);
op->setFrom(getId());
return sendLook(op);
}
void BaseMind::init(OpVector& res)
{
Look look;
Root lookArg;
lookArg->setId(m_entityId);
look->setArgs1(lookArg);
look->setFrom(getId());
res.push_back(look);
}
void AccountServerLobbyintegration::test_lobby_look()
{
test_send_count = 0;
Look op;
op->setFrom(m_account->getId());
OpVector res;
m_account->operation(op, res);
ASSERT_TRUE(!res.empty());
}
void EntityImporterBase::startEntityWalking()
{
m_state = ENTITY_WALKSTART;
Look l;
l->setFrom(mAvatarId);
l->setSerialno(newSerialNumber());
sendOperation(l);
}
LocatedEntity * CharacterClient::look(const std::string & id)
{
Look op;
if (!id.empty()) {
Anonymous ent;
ent->setId(id);
op->setArgs1(ent);
}
op->setFrom(getId());
return sendLook(op);
}
static void lookAtEntity(ClientConnection& con, const std::string & eid,
const std::string & loc)
{
Look l;
l->setFrom(con.getCharacterId());
Anonymous lookEnt;
lookEnt->setId(eid);
l->setArgs1(lookEnt);
int serial = con.send(l);
verbose( std::cout << "Waiting for In-game look response on connection "
<< con.getAccount() << std::endl << std::flush; );
void ClientConnection::processOOGLook(const Look& lk)
{
const std::vector<Root>& args = lk->getArgs();
std::string lookTarget;
if (args.empty()) {
lookTarget = "_lobby";
} else {
lookTarget = args.front()->getId();
}
RootEntity thing;
if (m_server->m_accounts.count(lookTarget))
{
thing = m_server->m_accounts[lookTarget];
if (lookTarget != lk->getFrom())
{
// prune
thing->removeAttr("characters");
thing->removeAttr("password");
}
}
else if (m_server->m_world.count(lookTarget))
{
// ensure it's owned by the account, i.e in characters
if (!entityIsCharacter(lookTarget))
{
sendError("not allowed to look at that entity", lk);
return;
}
thing = m_server->m_world[lookTarget];
}
else if (m_server->m_rooms.count(lookTarget))
{
// should check room view permissions?
thing = m_server->m_rooms[lookTarget];
} else {
// didn't find any entity with the id
sendError("processed OOG look for unknown entity " + lookTarget, lk);
return;
}
Sight st;
st->setArgs1(thing);
st->setFrom(lookTarget);
st->setTo(lk->getFrom());
st->setRefno(lk->getSerialno());
send(st);
}
void View::sendLookAt(const std::string& eid)
{
Look look;
if (!eid.empty()) {
PendingSightMap::iterator pending = m_pending.find(eid);
if (pending != m_pending.end()) {
switch (pending->second)
{
case SACTION_QUEUED:
// flip over to default (APPEAR) as normal
pending->second = SACTION_APPEAR; break;
case SACTION_DISCARD:
case SACTION_HIDE:
if (m_notifySights.count(eid) == 0) {
// no-one cares, don't bother to look
m_pending.erase(pending);
issueQueuedLook();
return;
} // else someone <em>does</em> care, so let's do the look, but
// keep SightAction unchanged so it discards / is hidden as
// expected.
break;
case SACTION_APPEAR:
// this can happen if a queued entity disappears and then
// re-appears, all while in the look queue. we can safely fall
// through.
break;
default:
// broken state handling logic
assert(false);
break;
}
} else {
// no previous entry, default to APPEAR
m_pending.insert(pending, std::make_pair(eid, SACTION_APPEAR));
}
// pending map is in the right state, build up the args now
Root what;
what->setId(eid);
look->setArgs1(what);
}
look->setFrom(m_owner->getId());
getConnection()->send(look);
}
void Accountintegration::test_LookOperation()
{
Anonymous new_char;
LocatedEntity * chr = m_ac->addNewCharacter("thing", new_char,
RootEntity());
Anonymous op_arg;
op_arg->setId("1");
op_arg->setId(chr->getId());
Look op;
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
// FIXME This doesn't test a lot
}
void MindProperty::apply(LocatedEntity * ent)
{
if (m_factory == 0) {
return;
}
Character * chr = dynamic_cast<Character *>(ent);
if (chr == 0) {
log(NOTICE, "Mind property applied to non-character");
return;
}
if (chr->m_mind != 0) {
log(NOTICE, "Mind property character already has a mind");
return;
}
chr->m_mind = m_factory->newMind(ent->getId(), ent->getIntId());
chr->m_mind->setType(ent->getType());
if (m_factory->m_scriptFactory != 0) {
m_factory->m_scriptFactory->addScript(chr->m_mind);
}
Setup s;
Anonymous setup_arg;
setup_arg->setName("mind");
s->setTo(ent->getId());
s->setArgs1(setup_arg);
ent->sendWorld(s);
Look l;
l->setTo(ent->getId());
ent->sendWorld(l);
}
void Flusher::setup(const std::string & arg, OpVector & ret)
{
shared_ptr<ObjectContext> flush_context = m_context.lock();
if (!flush_context) {
m_complete = true;
return;
}
type = arg;
m_description = String::compose("flushing %1", type);
// Send a look to search by type.
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, type));
l->setArgs1(lmap);
flush_context->setFromContext(l);
ret.push_back(l);
}
int main(int argc, char** argv)
{
std::string atlas_xml_path;
char * srcdir_env = getenv("srcdir");
if (srcdir_env != 0) {
atlas_xml_path = srcdir_env;
atlas_xml_path += "/";
}
atlas_xml_path += "../../protocol/spec/atlas.xml";
try {
Atlas::Objects::loadDefaults(atlas_xml_path);
} catch(Atlas::Objects::DefaultLoadingException e) {
std::cout << "DefaultLoadingException: "
<< e.getDescription() << std::endl;
}
Root root = Atlas::Objects::objectDefinitions.find("root")->second;
Root root_inst;
root_inst->setAttr("id", std::string("root_instantiation"));
assert(root->getAttr("id").asString() == "root");
assert(root_inst->getAttr("id").asString() == "root_instantiation");
assert(root->getAttr("parents").asList().size() == 0);
assert(root_inst->getAttr("parents").asList().size() == 1);
assert((*root_inst->getAttr("parents").asList().begin()).asString() ==
"root");
Look look = smart_dynamic_cast<Look>(objectDefinitions.find("look")->second);
Look look_inst;
look_inst->setAttr("id", std::string("look_instantiation"));
assert(look->getAttr("id").asString() == "look");
assert(look_inst->getAttr("id").asString() == "look_instantiation");
assert(look->getAttr("parents").asList().size() == 1);
assert((*look->getAttr("parents").asList().begin()).asString() ==
"perceive");
assert(look_inst->getAttr("parents").asList().size() == 1);
assert((*look_inst->getAttr("parents").asList().begin()).asString() ==
"look");
Account acct = smart_dynamic_cast<Account>(objectDefinitions.find("account")->second);
Account acct_inst;
acct_inst->setAttr("id", std::string("account_instantiation"));
assert(acct->getAttr("id").asString() == "account");
assert(acct_inst->getAttr("id").asString() == "account_instantiation");
assert(acct->getAttr("parents").asList().size() == 1);
assert((*acct->getAttr("parents").asList().begin()).asString() ==
"admin_entity");
assert(acct_inst->getAttr("parents").asList().size() == 1);
assert((*acct_inst->getAttr("parents").asList().begin()).asString() ==
"account");
{
Atlas::Objects::Entity::Anonymous anon;
anon->setLoc("12345");
ListType velocity;
velocity.push_back(1.4);
velocity.push_back(2.4);
velocity.push_back(3.4);
anon->setVelocityAsList(velocity);
ListType bbox;
bbox.push_back(1.4);
bbox.push_back(2.4);
bbox.push_back(3.4);
bbox.push_back(2.4);
anon->setAttr("bbox", bbox);
Atlas::Objects::Operation::Move move;
move->setFrom("123456");
move->setTo("123456");
move->setSeconds(12345678);
move->setId("123456");
move->setArgs1(anon);
Atlas::Objects::Operation::Sight sight;
sight->setFrom("123456");
sight->setTo("123456");
sight->setSeconds(12345678);
sight->setId("123456");
sight->setArgs1(move);
Atlas::Message::MapType map;
sight->addToMessage(map);
std::cout << map.size() << std::flush;
assert(map.size() == 7);
assert(map["objtype"].String() == "op");
assert(map["from"].String() == "123456");
assert(map["to"].String() == "123456");
assert(map["seconds"].Float() == 12345678);
assert(map["id"].String() == "123456");
assert(map["args"].List().size() == 1);
}
}
void Flusher::operation(const Operation & op, OpVector & res)
{
shared_ptr<ObjectContext> flush_context = m_context.lock();
if (!flush_context) {
m_complete = true;
return;
}
if (op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
// We have a sight op, check if its the sight of an entity we
// want to delete.
const std::vector<Root> & args = op->getArgs();
if (args.empty()) {
std::cerr << "Got empty sight" << std::endl << std::flush;
return;
}
const Root & arg = args.front();
assert(arg.isValid());
RootEntity sight_ent = smart_dynamic_cast<RootEntity>(arg);
if (!sight_ent.isValid()) {
return;
}
if (!sight_ent->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
std::cerr << "Got sight no ID" << std::endl << std::flush;
return;
}
if (!sight_ent->hasAttrFlag(Atlas::Objects::PARENTS_FLAG)) {
std::cerr << "Got sight no PARENTS" << std::endl << std::flush;
return;
}
if (sight_ent->getParents().empty() ||
sight_ent->getParents().front() != type) {
return;
}
const std::string & id = sight_ent->getId();
std::cout << "Deleting: " << type << "(" << id << ")"
<< std::endl << std::flush;
// Send a delete to the entity we have seen.
Delete d;
Anonymous dmap;
dmap->setId(id);
d->setArgs1(dmap);
flush_context->setFromContext(d);
d->setTo(id);
res.push_back(d);
// Send a tick for a short time in the future so that
// we can look again once this entity is definitly gone.
Tick t;
Anonymous tick_arg;
tick_arg->setName("flusher");
flush_context->setFromContext(t);
t->setTo(t->getFrom());
t->setFutureSeconds(0.1);
t->setArgs1(tick_arg);
res.push_back(t);
} else if (op->getParents().front() == "tick") {
// We have a tick op, check if its the one we sent ourselves
// to schedule the next look.
if (op->getArgs().empty() ||
op->getArgs().front()->getName() != "flusher") {
std::cout << "Not for us" << std::endl << std::flush;
return;
}
// Send another look by type.
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, type));
l->setArgs1(lmap);
flush_context->setFromContext(l);
res.push_back(l);
} else if (op->getParents().front() == "unseen") {
// We have an unseen op, which signals our last look returned
// no results.
m_complete = true;
}
}
void Interactive::exec(const std::string & cmd, const std::string & arg)
{
bool reply_expected = true;
reply_flag = false;
error_flag = false;
boost::shared_ptr<ObjectContext> command_context = m_currentContext.lock();
if (!command_context) {
std::cout << "ERROR: Context free" << std::endl << std::flush;
return;
}
if (cmd == "stat") {
Get g;
send(g);
} else if (cmd == "install") {
size_t space = arg.find(' ');
if (space == std::string::npos || space >= (arg.size() - 1)) {
std::cout << "usage: install <type id> <parent id>"
<< std::endl << std::flush;
} else {
Create c;
c->setFrom(m_accountId);
Anonymous ent;
ent->setId(std::string(arg, 0, space));
ent->setObjtype("class");
ent->setParents(std::list<std::string>(1, std::string(arg, space + 1)));
c->setArgs1(ent);
send(c);
}
reply_expected = false;
} else if (cmd == "look") {
Look l;
if (!arg.empty()) {
Anonymous cmap;
cmap->setId(arg);
l->setArgs1(cmap);
}
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
} else if (cmd == "logout") {
Logout l;
l->setFrom(m_accountId);
if (!arg.empty()) {
Anonymous lmap;
lmap->setId(arg);
l->setArgs1(lmap);
reply_expected = false;
}
send(l);
} else if (cmd == "say") {
Talk t;
Anonymous ent;
ent->setAttr("say", arg);
t->setArgs1(ent);
t->setFrom(m_accountId);
send(t);
} else if (cmd == "help" || cmd == "?") {
reply_expected = false;
help();
} else if (cmd == "query") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "reload") {
if (arg.empty()) {
reply_expected = false;
std::cout << "reload: Argument required" << std::endl << std::flush;
} else {
Set s;
Anonymous tmap;
tmap->setObjtype("class");
tmap->setId(arg);
s->setArgs1(tmap);
s->setFrom(m_accountId);
send(s);
}
} else if (cmd == "get") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "monitor") {
ClientTask * task = new OperationMonitor;
if (runTask(task, arg) == 0) {
Monitor m;
m->setArgs1(Anonymous());
m->setFrom(m_accountId);
send(m);
}
reply_expected = false;
} else if (cmd == "unmonitor") {
OperationMonitor * om = dynamic_cast<OperationMonitor *>(m_currentTask);
if (om != 0) {
Monitor m;
m->setFrom(m_accountId);
send(m);
reply_expected = false;
SystemTime now;
now.update();
time_t monitor_time = now.seconds() - om->startTime();
std::cout << om->count() << " operations monitored in "
<< monitor_time << " seconds = "
<< om->count() / monitor_time
<< " operations per second"
<< std::endl << std::flush;
endTask();
}
} else if (cmd == "connect") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: connect <hostname> <port>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("hostname", args[0]);
cmap->setAttr("port", strtol(args[1].c_str(), 0, 10));
Connect m;
m->setArgs1(cmap);
// No serialno yet
// FIXME add serialno once Juncture context can handle this
command_context->setFromContext(m);
send(m);
}
} else if (cmd == "add_agent") {
std::string agent_type("creator");
if (!arg.empty()) {
agent_type = arg;
}
Create c;
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, agent_type));
cmap->setName("cycmd agent");
cmap->setObjtype("obj");
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
} else if (cmd == "delete") {
if (arg.empty()) {
std::cout << "Please specify the entity to delete" << std::endl << std::flush;
reply_expected = false;
} else {
Delete del;
Anonymous del_arg;
del_arg->setId(arg);
del->setArgs1(del_arg);
command_context->setFromContext(del);
send(del);
reply_expected = false;
}
} else if (cmd == "find_by_name") {
if (arg.empty()) {
std::cout << "Please specify the name to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setName(arg);
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "find_by_type") {
if (arg.empty()) {
std::cout << "Please specify the type to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, arg));
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "flush") {
if (arg.empty()) {
// FIXME usage
std::cout << "Please specify the type to flush" << std::endl << std::flush;
reply_expected = false;
} else {
ClientTask * task = new Flusher(command_context);
runTask(task, arg);
reply_expected = false;
}
} else if (cmd == "cancel") {
if (endTask() != 0) {
std::cout << "No task currently running" << std::endl << std::flush;
}
} else if (cmd == "dump") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityExporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "restore") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityImporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "create") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() < 1) {
std::cout << "usage: create <type> <params> ... "
<< std::endl << std::flush;
} else {
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, args[0]));
cmap->setObjtype("obj");
Create c;
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
}
reply_expected = false;
} else if (cmd == "login") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: login <username> <password>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("username", args[0]);
cmap->setAttr("password", args[1]);
Login m;
m->setArgs1(cmap);
m->setSerialno(newSerialNo());
command_context->setFromContext(m);
send(m);
}
} else {
reply_expected = false;
std::cout << cmd << ": Command not known" << std::endl << std::flush;
}
if (!reply_expected) {
updatePrompt();
return;
}
// Wait for reply
time_t wait_start_time = time(NULL);
while (!reply_flag) {
if (time(NULL) - wait_start_time > 5) {
std::cout << cmd << ": No reply from server" << std::endl << std::flush;
return;
}
if (select(false) != 0) {
return;
}
}
}
int WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
#ifdef _WIN32_WCE
LPWSTR lpCmdLine,
#else
LPSTR lpCmdLine2,
#endif
int nCmdShow)
#endif
{
#ifdef WIN32
Args args(GetCommandLine(), "DRIVER FILE");
#else
Args args(argc, argv, "DRIVER FILE");
#endif
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
InitialiseDataPath();
Profile::SetFiles(_T(""));
Profile::Load();
const Waypoints way_points;
InterfaceBlackboard blackboard;
blackboard.SetComputerSettings().SetDefaults();
GlideComputerTaskEvents task_events;
TaskManager task_manager(way_points);
task_manager.SetTaskEvents(task_events);
Airspaces airspace_database;
AirspaceWarningManager airspace_warning(airspace_database);
ProtectedTaskManager protected_task_manager(task_manager,
blackboard.GetComputerSettings().task);
LoadFiles(airspace_database);
GlideComputer glide_computer(way_points, airspace_database,
protected_task_manager,
task_events);
glide_computer.SetTerrain(terrain);
glide_computer.Initialise();
glide_computer.ReadComputerSettings(blackboard.GetComputerSettings());
ScreenGlobalInit screen_init;
LoadReplay(replay, glide_computer, blackboard);
delete replay;
#ifdef WIN32
ResourceLoader::Init(hInstance);
#endif
Layout::Initialize(640, 480);
SingleWindow main_window;
main_window.set(_T("STATIC"), _T("RunAnalysis"),
PixelRect{0, 0, 640, 480});
Fonts::Initialize();
dialog_settings.SetDefaults();
Look *look = new Look();
look->Initialise();
look->InitialiseConfigured(blackboard.GetUISettings());
SetXMLDialogLook(look->dialog);
dialog_look = &look->dialog;
main_window.show();
dlgAnalysisShowModal(main_window, *look, blackboard, glide_computer,
&protected_task_manager,
&airspace_database,
terrain);
delete look;
Fonts::Deinitialize();
delete terrain;
DeinitialiseDataPath();
return 0;
}
int main()
{
database_flag = false;
(void)new Domain;
WorldRouter world;
Entity & e = world.m_gameWorld;
ServerRouting server(world, "noruleset", "unittesting",
"1", 1, "2", 2);
CommServer commServer(server);
TestCommClient * tc = new TestCommClient(commServer);
Connection * c = new Connection(*tc, server, "addr", "3", 3);
TestAccount * ac = new TestAccount(c, "user", "password", "4", 4);
Entity * chr;
{
chr = new Entity("5", 5);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("6", 6);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("7", 7);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
}
{
Anonymous new_char;
Entity * chr = ac->testAddNewCharacter("thing", new_char,
RootEntity());
assert(chr != 0);
}
ac->getType();
{
MapType emap;
ac->addToMessage(emap);
}
{
RootEntity ent;
ac->addToEntity(ent);
}
{
Create op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, "game_entity"));
ac->operation(op, res);
op_arg->setName("Bob");
ac->operation(op, res);
}
{
Get op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Imaginary op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setLoc("2");
ac->operation(op, res);
}
{
Look op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
}
{
Set op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
op_arg->setAttr("guise", "foo");
ac->operation(op, res);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
BBox newBox(WFMath::Point<3>(-0.5, -0.5, 0.0),
WFMath::Point<3>(-0.5, -0.5, 2.0));
chr->m_location.setBBox(newBox);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
op_arg->setAttr("tasks", ListType());
ac->operation(op, res);
}
{
Talk op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op_arg->setLoc("1");
ac->operation(op, res);
}
{
Logout op;
OpVector res;
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
// Move has no meaning
Move op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Entity e("7", 7);
int ret = ac->connectCharacter(&e);
assert(ret == -1);
}
{
Character e("8", 8);
int ret = ac->connectCharacter(&e);
assert(ret == 0);
}
delete ac;
return 0;
}