void RigidBody::AddBodyToWorld()
{
if (!physicsWorld_)
return;
PROFILE(AddBodyToWorld);
if (mass_ < 0.0f)
mass_ = 0.0f;
if (body_)
RemoveBodyFromWorld();
else
{
// Correct inertia will be calculated below
btVector3 localInertia(0.0f, 0.0f, 0.0f);
body_ = new btRigidBody(mass_, this, shiftedCompoundShape_, localInertia);
body_->setUserPointer(this);
// Check for existence of the SmoothedTransform component, which should be created by now in network client mode.
// If it exists, subscribe to its change events
SmoothedTransform* transform = GetComponent<SmoothedTransform>();
if (transform)
{
hasSmoothedTransform_ = true;
SubscribeToEvent(transform, E_TARGETPOSITION, HANDLER(RigidBody, HandleTargetPosition));
SubscribeToEvent(transform, E_TARGETROTATION, HANDLER(RigidBody, HandleTargetRotation));
}
// Check if CollisionShapes already exist in the node and add them to the compound shape.
// Do not update mass yet, but do it once all shapes have been added
PODVector<CollisionShape*> shapes;
node_->GetComponents<CollisionShape>(shapes);
for (PODVector<CollisionShape*>::Iterator i = shapes.Begin(); i != shapes.End(); ++i)
(*i)->NotifyRigidBody(false);
// Check if this node contains Constraint components that were waiting for the rigid body to be created, and signal them
// to create themselves now
PODVector<Constraint*> constraints;
node_->GetComponents<Constraint>(constraints);
for (PODVector<Constraint*>::Iterator i = constraints.Begin(); i != constraints.End(); ++i)
(*i)->CreateConstraint();
}
UpdateMass();
UpdateGravity();
int flags = body_->getCollisionFlags();
if (phantom_)
flags |= btCollisionObject::CF_NO_CONTACT_RESPONSE;
else
flags &= ~btCollisionObject::CF_NO_CONTACT_RESPONSE;
if (kinematic_)
flags |= btCollisionObject::CF_KINEMATIC_OBJECT;
else
flags &= ~btCollisionObject::CF_KINEMATIC_OBJECT;
body_->setCollisionFlags(flags);
body_->forceActivationState(kinematic_ ? DISABLE_DEACTIVATION : ISLAND_SLEEPING);
if (!IsEnabledEffective())
return;
btDiscreteDynamicsWorld* world = physicsWorld_->GetWorld();
world->addRigidBody(body_, collisionLayer_, collisionMask_);
inWorld_ = true;
readdBody_ = false;
if (mass_ > 0.0f)
Activate();
else
{
SetLinearVelocity(Vector3::ZERO);
SetAngularVelocity(Vector3::ZERO);
}
}
void CollisionShape::UpdateShape()
{
PROFILE(UpdateCollisionShape);
ReleaseShape();
if (!physicsWorld_)
return;
if (node_)
{
Vector3 newWorldScale = node_->GetWorldScale();
switch (shapeType_)
{
case SHAPE_BOX:
shape_ = new btBoxShape(ToBtVector3(size_ * 0.5f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_SPHERE:
shape_ = new btSphereShape(size_.x_ * 0.5f);
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_STATICPLANE:
shape_ = new btStaticPlaneShape(btVector3(0.0f, 1.0f, 0.0f), 0.0f);
break;
case SHAPE_CYLINDER:
shape_ = new btCylinderShape(btVector3(size_.x_ * 0.5f, size_.y_ * 0.5f, size_.x_ * 0.5f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_CAPSULE:
shape_ = new btCapsuleShape(size_.x_ * 0.5f, Max(size_.y_ - size_.x_, 0.0f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_CONE:
shape_ = new btConeShape(size_.x_ * 0.5f, size_.y_);
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_TRIANGLEMESH:
size_ = size_.Abs();
if (model_)
{
// Check the geometry cache
Pair<Model*, unsigned> id = MakePair(model_.Get(), lodLevel_);
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >& cache = physicsWorld_->GetTriMeshCache();
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >::Iterator j = cache.Find(id);
if (j != cache.End())
geometry_ = j->second_;
else
{
geometry_ = new TriangleMeshData(model_, lodLevel_);
// Check if model has dynamic buffers, do not cache in that case
if (!HasDynamicBuffers(model_, lodLevel_))
cache[id] = geometry_;
}
TriangleMeshData* triMesh = static_cast<TriangleMeshData*>(geometry_.Get());
shape_ = new btScaledBvhTriangleMeshShape(triMesh->shape_, ToBtVector3(newWorldScale * size_));
// Watch for live reloads of the collision model to reload the geometry if necessary
SubscribeToEvent(model_, E_RELOADFINISHED, HANDLER(CollisionShape, HandleModelReloadFinished));
}
break;
case SHAPE_CONVEXHULL:
size_ = size_.Abs();
if (customGeometryID_ && GetScene())
{
Node* node = GetScene()->GetNode(customGeometryID_);
CustomGeometry* custom = node ? node->GetComponent<CustomGeometry>() : 0;
if (custom)
{
geometry_ = new ConvexData(custom);
ConvexData* convex = static_cast<ConvexData*>(geometry_.Get());
shape_ = new btConvexHullShape((btScalar*)convex->vertexData_.Get(), convex->vertexCount_, sizeof(Vector3));
shape_->setLocalScaling(ToBtVector3(newWorldScale * size_));
LOGINFO("Set convexhull from customgeometry");
}
else
LOGWARNING("Could not find custom geometry component from node ID " + String(customGeometryID_) + " for convex shape creation");
}
else if (model_)
{
// Check the geometry cache
Pair<Model*, unsigned> id = MakePair(model_.Get(), lodLevel_);
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >& cache = physicsWorld_->GetConvexCache();
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >::Iterator j = cache.Find(id);
if (j != cache.End())
geometry_ = j->second_;
else
{
geometry_ = new ConvexData(model_, lodLevel_);
// Check if model has dynamic buffers, do not cache in that case
if (!HasDynamicBuffers(model_, lodLevel_))
cache[id] = geometry_;
}
ConvexData* convex = static_cast<ConvexData*>(geometry_.Get());
shape_ = new btConvexHullShape((btScalar*)convex->vertexData_.Get(), convex->vertexCount_, sizeof(Vector3));
shape_->setLocalScaling(ToBtVector3(newWorldScale * size_));
SubscribeToEvent(model_, E_RELOADFINISHED, HANDLER(CollisionShape, HandleModelReloadFinished));
}
break;
case SHAPE_TERRAIN:
size_ = size_.Abs();
{
Terrain* terrain = GetComponent<Terrain>();
if (terrain && terrain->GetHeightData())
{
geometry_ = new HeightfieldData(terrain);
HeightfieldData* heightfield = static_cast<HeightfieldData*>(geometry_.Get());
shape_ = new btHeightfieldTerrainShape(heightfield->size_.x_, heightfield->size_.y_,
heightfield->heightData_.Get(), 1.0f, heightfield->minHeight_, heightfield->maxHeight_, 1, PHY_FLOAT,
false);
shape_->setLocalScaling(ToBtVector3(Vector3(heightfield->spacing_.x_, 1.0f, heightfield->spacing_.z_) *
newWorldScale * size_));
}
}
break;
default:
break;
}
if (shape_)
{
shape_->setUserPointer(this);
shape_->setMargin(margin_);
}
cachedWorldScale_ = newWorldScale;
}
if (physicsWorld_)
physicsWorld_->CleanupGeometryCache();
recreateShape_ = false;
}
/* See documentation in header file. */
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
void* user)
{
/* Uses a fair bit of stack (use heap instead if you need to) */
#if INI_USE_STACK
char line[INI_MAX_LINE];
int max_line = INI_MAX_LINE;
#else
char* line;
int max_line = INI_INITIAL_ALLOC;
#endif
#if INI_ALLOW_REALLOC
char* new_line;
int offset;
#endif
char section[MAX_SECTION] = "";
char prev_name[MAX_NAME] = "";
char* start;
char* end;
char* name;
char* value;
int lineno = 0;
int error = 0;
#if !INI_USE_STACK
line = (char*)malloc(INI_INITIAL_ALLOC);
if (!line) {
return -2;
}
#endif
#if INI_HANDLER_LINENO
#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
#else
#define HANDLER(u, s, n, v) handler(u, s, n, v)
#endif
/* Scan through stream line by line */
while (reader(line, max_line, stream) != NULL) {
#if INI_ALLOW_REALLOC
offset = strlen(line);
while (offset == max_line - 1 && line[offset - 1] != '\n') {
max_line *= 2;
if (max_line > INI_MAX_LINE)
max_line = INI_MAX_LINE;
new_line = realloc(line, max_line);
if (!new_line) {
free(line);
return -2;
}
line = new_line;
if (reader(line + offset, max_line - offset, stream) == NULL)
break;
if (max_line >= INI_MAX_LINE)
break;
offset += strlen(line + offset);
}
#endif
lineno++;
start = line;
#if INI_ALLOW_BOM
if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
(unsigned char)start[1] == 0xBB &&
(unsigned char)start[2] == 0xBF) {
start += 3;
}
#endif
start = lskip(rstrip(start));
if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
/* Start-of-line comment */
}
#if INI_ALLOW_MULTILINE
else if (*prev_name && *start && start > line) {
/* Non-blank line with leading whitespace, treat as continuation
of previous name's value (as per Python configparser). */
if (!HANDLER(user, section, prev_name, start) && !error)
error = lineno;
}
#endif
else if (*start == '[') {
/* A "[section]" line */
end = find_chars_or_comment(start + 1, "]");
if (*end == ']') {
*end = '\0';
strncpy0(section, start + 1, sizeof(section));
*prev_name = '\0';
}
else if (!error) {
/* No ']' found on section line */
error = lineno;
}
}
else if (*start) {
/* Not a comment, must be a name[=:]value pair */
end = find_chars_or_comment(start, "=:");
if (*end == '=' || *end == ':') {
*end = '\0';
name = rstrip(start);
value = end + 1;
#if INI_ALLOW_INLINE_COMMENTS
end = find_chars_or_comment(value, NULL);
if (*end)
*end = '\0';
#endif
value = lskip(value);
rstrip(value);
/* Strip surrounding double and single quotes */
if ((*value == '"') && (value[strlen(value) - 1] == '"')) {
value[strlen(value) - 1] = '\0';
value += 1;
} else {
if ((*value == '"') && (value[strlen(value) - 1] == '"')) {
value[strlen(value) - 1] = '\0';
value += 1;
}
}
/* Valid name[=:]value pair found, call handler */
strncpy0(prev_name, name, sizeof(prev_name));
if (!HANDLER(user, section, name, value) && !error)
error = lineno;
}
else if (!error) {
/* No '=' or ':' found on name[=:]value line */
error = lineno;
}
}
#if INI_STOP_ON_FIRST_ERROR
if (error)
break;
#endif
}
#if !INI_USE_STACK
free(line);
#endif
return error;
}
/* See documentation in header file. */
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
void* user)
{
/* Uses a fair bit of stack (use heap instead if you need to) */
#if INI_USE_STACK
char line[INI_MAX_LINE];
#else
char* line;
#endif
char section[MAX_SECTION] = "";
char prev_name[MAX_NAME] = "";
char* start;
char* end;
char* name;
char* value;
int lineno = 0;
int error = 0;
#if !INI_USE_STACK
line = (char*)malloc(INI_MAX_LINE);
if (!line) {
return -2;
}
#endif
#if INI_HANDLER_LINENO
#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
#else
#define HANDLER(u, s, n, v) handler(u, s, n, v)
#endif
/* Scan through stream line by line */
while (reader(line, INI_MAX_LINE, stream) != NULL) {
lineno++;
start = line;
#if INI_ALLOW_BOM
if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
(unsigned char)start[1] == 0xBB &&
(unsigned char)start[2] == 0xBF) {
start += 3;
}
#endif
start = lskip(rstrip(start));
if (*start == ';' || *start == '#') {
/* Per Python configparser, allow both ; and # comments at the
start of a line */
}
#if INI_ALLOW_MULTILINE
else if (*prev_name && *start && start > line) {
/* Non-blank line with leading whitespace, treat as continuation
of previous name's value (as per Python configparser). */
if (!HANDLER(user, section, prev_name, start) && !error)
error = lineno;
}
#endif
else if (*start == '[') {
/* A "[section]" line */
end = find_chars_or_comment(start + 1, "]");
if (*end == ']') {
*end = '\0';
strncpy0(section, start + 1, sizeof(section));
*prev_name = '\0';
}
else if (!error) {
/* No ']' found on section line */
error = lineno;
}
}
else if (*start) {
/* Not a comment, must be a name[=:]value pair */
end = find_chars_or_comment(start, "=:");
if (*end == '=' || *end == ':') {
*end = '\0';
name = rstrip(start);
value = end + 1;
#if INI_ALLOW_INLINE_COMMENTS
end = find_chars_or_comment(value, NULL);
if (*end)
*end = '\0';
#endif
value = lskip(value);
rstrip(value);
/* Valid name[=:]value pair found, call handler */
strncpy0(prev_name, name, sizeof(prev_name));
if (!HANDLER(user, section, name, value) && !error)
error = lineno;
}
else if (!error) {
/* No '=' or ':' found on name[=:]value line */
error = lineno;
}
}
#if INI_STOP_ON_FIRST_ERROR
if (error)
break;
#endif
}
#if !INI_USE_STACK
free(line);
#endif
return error;
}
return true;
}
#endif
CommandInfo kCommandInfo_GetActiveSpell =
{
"GetPlayerSpell",
"GetActiveSpell",
0,
"returns the base spell object for the player's active spell",
0,
0,
NULL,
HANDLER(Cmd_GetActiveSpell_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_SetActiveSpell =
{
"SetActiveSpell",
"sspl",
0,
"sets the active spell to the argument",
0,
1,
kParams_OneSpellItem,
HANDLER(Cmd_SetActiveSpell_Execute),
DEFINE_COMMAND(PrintTileInfo, debug command for printing traits and values, 0, 2, kParams_OneString_OneInt);
DEFINE_COMMAND(GetMapMenuMarkerName, returns the name of the currently selected map marker, 0, 0, NULL);
DEFINE_COMMAND(GetMapMenuMarkerRef, returns a reference to the currently selected map marker, 0, 0, NULL);
DEFINE_COMMAND(GetBarterItem, returns the active item in a container menu, 0, 0, NULL);
DEFINE_COMMAND(GetBarterItemQuantity, returns the selected quantity of the active item in a container menu, 0, 0, NULL);
DEFINE_COMMAND(GetLastTransactionItem, returns the item most recently bought or sold by the player, 0, 0, NULL);
DEFINE_COMMAND(GetLastTransactionQuantity, returns the quantity of the most recent buy/sell transaction, 0, 0, NULL);
CommandInfo kCommandInfo_GetQMItem =
{
"GetQMItem", "GetQuantityMenuItem", 0,
"returns the active item in the quantity menu",
0, 0, NULL,
HANDLER(Cmd_GetQuantityMenuItem_Execute), Cmd_Default_Parse,
NULL, 0
};
CommandInfo kCommandInfo_GetQMCurrent =
{
"GetQMCurrent", "GetQuantityMenuCurrentQuantity", 0,
"returns the current quantity in the quantity menu",
0, 0, NULL,
HANDLER(Cmd_GetQuantityMenuCurrentQuantity_Execute), Cmd_Default_Parse,
NULL, 0
};
CommandInfo kCommandInfo_GetQMMaximum =
{
"GetQMMaximum", "GetQuantityMenuMaximumQuantity", 0,
};
int op1_pre1_call_counter;
KEDR_COI_TEST_DEFINE_HANDLER_FUNC(op1_pre1, op1_pre1_call_counter)
int op2_post1_call_counter;
KEDR_COI_TEST_DEFINE_HANDLER_FUNC(op2_post1, op2_post1_call_counter)
int op2_post2_call_counter;
KEDR_COI_TEST_DEFINE_HANDLER_FUNC(op2_post2, op2_post2_call_counter)
static struct kedr_coi_handler pre_handlers[] =
{
HANDLER(op1, op1_pre1),
kedr_coi_handler_end
};
static struct kedr_coi_handler post_handlers[] =
{
HANDLER(op2, op2_post1),
HANDLER_EXTERNAL(op2, op2_post2),
kedr_coi_handler_end
};
static struct kedr_coi_payload payload =
{
.pre_handlers = pre_handlers,
.post_handlers = post_handlers
};
return true;
}
#endif
CommandInfo kCommandInfo_GetClass =
{
"GetClass",
"gclass",
0,
"returns the ref to the class of the calling actor",
0,
1,
kParams_OneOptionalNPC,
HANDLER(Cmd_GetClass_Execute),
Cmd_Default_Parse,
NULL,
0
};
static ParamInfo kParams_IsMajor[2] =
{
{ "skill", kParamType_ActorValue, 0 },
{ "class", kParamType_Class, 1 },
};
static ParamInfo kParams_IsMajorC[2] =
{
{ "skill", kParamType_Integer, 0 },
{ "class", kParamType_Class, 1 },
#include "lwip/sys.h"
#include "lwip/pbuf.h"
#if LWIP_DEBUG_TIMERNAMES
#define HANDLER(x) x, #x
#else /* LWIP_DEBUG_TIMERNAMES */
#define HANDLER(x) x
#endif /* LWIP_DEBUG_TIMERNAMES */
/** This array contains all stack-internal cyclic timers. To get the number of
* timers, use LWIP_ARRAYSIZE() */
struct lwip_cyclic_timer lwip_cyclic_timers[] = {
#if LWIP_TCP
/* The TCP timer is a special case: it does not have to run always and
is triggered to start from TCP using tcp_timer_needed() */
{TCP_TMR_INTERVAL, HANDLER(tcp_tmr)},
#endif /* LWIP_TCP */
#if LWIP_IPV4
#if IP_REASSEMBLY
{IP_TMR_INTERVAL, HANDLER(ip_reass_tmr)},
#endif /* IP_REASSEMBLY */
#if LWIP_ARP
{ARP_TMR_INTERVAL, HANDLER(etharp_tmr)},
#endif /* LWIP_ARP */
#if LWIP_DHCP
{DHCP_COARSE_TIMER_MSECS, HANDLER(dhcp_coarse_tmr)},
{DHCP_FINE_TIMER_MSECS, HANDLER(dhcp_fine_tmr)},
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
{AUTOIP_TMR_INTERVAL, HANDLER(autoip_tmr)},
#endif /* LWIP_AUTOIP */
static bool Cmd_GetFactions_Execute(COMMAND_ARGS)
{
class Counter {
public:
Counter(ArrayID arrID) : m_arrID(arrID), m_curIndex(0) { }
bool Accept(const TESActorBaseData::FactionListData* entry) {
if (entry == NULL)
return false;
g_ArrayMap.SetElementFormID(m_arrID, m_curIndex++, entry->faction->refID);
return true;
}
private:
ArrayID m_arrID;
UInt32 m_curIndex;
};
TESActorBase* actor = NULL;
ArrayID arr = g_ArrayMap.Create(kDataType_Numeric, true, scriptObj->GetModIndex());
*result = arr;
if (ExtractArgs(PASS_EXTRACT_ARGS, &actor)) {
if (actor == NULL && thisObj && (thisObj->baseForm->typeID == kFormType_Creature || thisObj->baseForm->typeID == kFormType_NPC))
actor = OBLIVION_CAST(thisObj->baseForm, TESForm, TESActorBase);
if (actor) {
FactionListVisitor(&actor->actorBaseData.factionList).Visit(Counter(arr));
}
}
return true;
}
void HelloWorld::SubscribeToEvents()
{
SubscribeToEvent(Urho3D::E_UPDATE, HANDLER(HelloWorld, HandleUpdate));
SubscribeToEvent(Urho3D::E_ENDRENDERING, HANDLER(HelloWorld, HandlePostRender));
}
{
{ "which", kParamType_Integer, 0 },
{ "race", kParamType_Race, 1 },
{ "sex", kParamType_Sex, 1},
};
CommandInfo kCommandInfo_GetRaceAttribute =
{
"GetRaceAttribute",
"",
0,
"returns the specified attibute for the race",
0,
2,
kParams_GetRaceAttribute,
HANDLER(Cmd_GetRaceAttribute_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_GetRaceAttributeC =
{
"GetRaceAttributeC",
"",
0,
"returns the specified attibute for the race",
0,
2,
kParams_GetRaceAttributeC,
HANDLER(Cmd_GetRaceAttribute_Execute),
void ExitDialog::DoActivation() {
SubscribeToEvent(yesButton, E_RELEASED, HANDLER(ExitDialog, YesButtonPressedHandler));
SubscribeToEvent(noButton, E_RELEASED, HANDLER(ExitDialog, NoButtonPressedHandler));
}
};
DEFINE_COMMAND(MoveTextInputCursor,
moves the cursor forward or backward by the specified number of characters,
0,
2,
kParams_MoveTextInputCursor);
DEFINE_COMMAND(GetTextInputCursorPos,
returns the current cursor position,
0,
0,
NULL);
DEFINE_COMMAND(SetTextInputDefaultControlsDisabled, disables or enables handling of default controls, 0, 1, kParams_OneInt);
DEFINE_COMMAND(SetTextInputControlHandler, sets a function script to handle text box controls, 0, 1, kParams_OneInventoryObject);
static ParamInfo kOBSEParams_SetInputText[2] =
{
{ "text", kOBSEParamType_String, 0 },
{ "pos", kOBSEParamType_Number, 0 },
};
CommandInfo kCommandInfo_SetInputText =
{
"SetInputText", "", 0, "sets the text and cursor position of text input menu",
0, 2, kOBSEParams_SetInputText,
HANDLER(Cmd_SetInputText_Execute),
Cmd_Expression_Parse, NULL, 0
};
bool LoadScriptState::Begin()
{
if (!project_)
{
ErrorExit("LoadScriptState::Begin(): projectSettings file is not set. ");
return false;
}
GetSubsystem<ResourceCache>()->SetAutoReloadResources(true);
String extension = GetExtension(project_->mainScript_);
if (extension != ".lua" && extension != ".luc")
{
#ifdef URHO3D_ANGELSCRIPT
// Instantiate and register the AngelScript subsystem
context_->RegisterSubsystem(new Script(context_));
// Hold a shared pointer to the script file to make sure it is not unloaded during runtime
scriptFile_ = GetSubsystem<ResourceCache>()->GetResource<ScriptFile>(project_->mainScript_);
/// \hack If we are running the editor, also instantiate Lua subsystem to enable editing Lua ScriptInstances
#ifdef URHO3D_LUA
if (scriptFileName_.Contains("Editor.as", false))
context_->RegisterSubsystem(new LuaScript(context_));
#endif
// If script loading is successful, proceed to main loop
if (scriptFile_ && scriptFile_->Execute("void Start()"))
{
// Subscribe to script's reload event to allow live-reload of the application
SubscribeToEvent(scriptFile_, E_RELOADSTARTED, HANDLER(LoadScriptState, HandleScriptReloadStarted));
SubscribeToEvent(scriptFile_, E_RELOADFINISHED, HANDLER(LoadScriptState, HandleScriptReloadFinished));
SubscribeToEvent(scriptFile_, E_RELOADFAILED, HANDLER(LoadScriptState, HandleScriptReloadFailed));
return AppState::Begin();
}
#else
ErrorExit("AngelScript is not enabled!");
return false;
#endif
}
else
{
#ifdef URHO3D_LUA
// Instantiate and register the Lua script subsystem
LuaScript* luaScript = new LuaScript(context_);
context_->RegisterSubsystem(luaScript);
// If script loading is successful, proceed to main loop
if (luaScript->ExecuteFile(scriptFileName_))
{
luaScript->ExecuteFunction("Start");
return AppState::Begin();
}
#else
ErrorExit("Lua is not enabled!");
return false;
#endif
}
// The script was not successfully loaded. Show the last error message and do not run the main loop
ErrorExit();
return AppState::Begin();
}
static ParamInfo kParams_OneIntOneOptionalActorBase[2] =
{
{ "bool", kParamType_Integer, 0 },
{ "base actor", kParamType_ActorBase, 1 },
};
CommandInfo kCommandInfo_GetNumFactions =
{
"GetNumFactions", "",
0,
"returns the number of factions to which an actor belongs",
0,
1,
kParams_OneOptionalActorBase,
HANDLER(Cmd_GetNumFactions_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_GetNthFaction =
{
"GetNthFaction", "",
0,
"returns the nth faction to which an actor belongs",
0,
2,
kParams_OneIntOneOptionalActorBase,
HANDLER(Cmd_GetNthFaction_Execute),
Cmd_Default_Parse,
void RangerSkill5::Start()
{
skillSprite_ = (Sprite*)(main_->mySceneNode_->GetComponent<HUD>()->
hud_->GetChild("skill5", false)->GetChild(0)->GetChild(0));
SubscribeToEvent(E_HUDBUTT, HANDLER(RangerSkill5, HandleHudButt));
}
return true;
}
#endif
CommandInfo kCommandInfo_SquareRoot =
{
"SquareRoot",
"sqrt",
0,
"Calculates the root of a value",
0,
1,
kParams_OneFloat,
HANDLER(Cmd_SquareRoot_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_Pow =
{
"Pow",
"pow",
0,
"Calculates one value raised to the power of another",
0,
2,
kParams_TwoFloats,
HANDLER(Cmd_Pow_Execute),
void AtomicTool::Start()
{
// Subscribe to events
SubscribeToEvent(E_COMMANDERROR, HANDLER(AtomicTool, HandleCommandError));
SubscribeToEvent(E_COMMANDFINISHED, HANDLER(AtomicTool, HandleCommandFinished));
SubscribeToEvent(E_LICENSE_EULAREQUIRED, HANDLER(AtomicTool, HandleLicenseEulaRequired));
SubscribeToEvent(E_LICENSE_ACTIVATIONREQUIRED, HANDLER(AtomicTool, HandleLicenseActivationRequired));
SubscribeToEvent(E_LICENSE_ERROR, HANDLER(AtomicTool, HandleLicenseError));
SubscribeToEvent(E_LICENSE_SUCCESS, HANDLER(AtomicTool, HandleLicenseSuccess));
const Vector<String>& arguments = GetArguments();
ToolSystem* tsystem = new ToolSystem(context_);
context_->RegisterSubsystem(tsystem);
ToolEnvironment* env = new ToolEnvironment(context_);
context_->RegisterSubsystem(env);
//#ifdef ATOMIC_DEV_BUILD
if (!env->InitFromJSON())
{
ErrorExit(ToString("Unable to initialize tool environment from %s", env->GetDevConfigFilename().CString()));
return;
}
if (!cliDataPath_.Length())
{
cliDataPath_ = env->GetRootSourceDir() + "/Resources/";
}
//#endif
tsystem->SetCLI();
tsystem->SetDataPath(cliDataPath_);
if (activationKey_.Length())
{
DoActivation();
return;
} else if (deactivate_)
{
DoDeactivation();
return;
}
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
SharedPtr<CommandParser> parser(new CommandParser(context_));
SharedPtr<Command> cmd(parser->Parse(arguments));
if (!cmd)
{
String error = "No command found";
if (parser->GetErrorMessage().Length())
error = parser->GetErrorMessage();
ErrorExit(error);
return;
}
if (cmd->RequiresProjectLoad())
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String projectDirectory = fileSystem->GetCurrentDir();
Vector<String> projectFiles;
fileSystem->ScanDir(projectFiles, projectDirectory, "*.atomic", SCAN_FILES, false);
if (!projectFiles.Size())
{
ErrorExit(ToString("No .atomic project file in %s", projectDirectory.CString()));
return;
}
else if (projectFiles.Size() > 1)
{
ErrorExit(ToString("Multiple .atomic project files found in %s", projectDirectory.CString()));
return;
}
String projectFile = projectDirectory + "/" + projectFiles[0];
if (!tsystem->LoadProject(projectFile))
{
//ErrorExit(ToString("Failed to load project: %s", projectFile.CString()));
//return;
}
// Set the build path
String buildFolder = projectDirectory + "/" + "Build";
buildSystem->SetBuildPath(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
fileSystem->CreateDir(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
ErrorExit(ToString("Failed to create build folder: %s", buildFolder.CString()));
return;
}
}
}
command_ = cmd;
// BEGIN LICENSE MANAGEMENT
if (cmd->RequiresLicenseValidation())
{
GetSubsystem<LicenseSystem>()->Initialize();
}
else
{
if (command_.Null())
{
GetSubsystem<Engine>()->Exit();
return;
}
command_->Run();
}
// END LICENSE MANAGEMENT
}
*result = GetSystemMetrics(SM_SWAPBUTTON) ? 1 : 0;
return true;
}
#endif
CommandInfo kCommandInfo_GetControl =
{
"GetControl",
"gc",
0,
"Get the key which is used for a particular control",
0,
1,
kParams_OneInt,
HANDLER(Cmd_GetControl_Execute),
Cmd_Default_Parse,
NULL,
0
};
DEFINE_COMMAND(GetAltControl2,
returns the mouse button code assigned to the specified control,
0,
1,
kParams_OneInt);
CommandInfo kCommandInfo_GetAltControl =
{
"GetAltControl",
"gac",
{"variable", kParamType_Float, 1},
{"variable", kParamType_Float, 1},
{"variable", kParamType_Float, 1},
{"variable", kParamType_Float, 1},
};
CommandInfo kCommandInfo_PrintToConsole =
{
"PrintToConsole",
"printc",
0,
"Print formatted string to console",
0,
21,
kParams_Message,
HANDLER(Cmd_PrintToConsole_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_PrintToFile =
{
"PrintToFile",
"printf",
0,
"Append formatted string to file",
0,
11,
kParams_StringFormatFile,
HANDLER(Cmd_PrintToFile_Execute),
SceneEditor3D ::SceneEditor3D(Context* context, const String &fullpath, TBTabContainer *container) :
ResourceEditor(context, fullpath, container)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
SharedPtr<File> xmlFile = cache->GetFile(fullpath);
if (GetExtension(fullpath) == ".scene")
scene_->LoadXML(*xmlFile);
else
scene_->Load(*xmlFile);
scene_->SetUpdateEnabled(false);
sceneView_ = new SceneView3D(context_, this);
// EARLY ACCESS
if (fullpath.Find(String("ToonTown")) != String::NPOS)
{
sceneView_->GetCameraNode()->SetWorldPosition(Vector3(-119.073, 76.1121, 16.47763));
Quaternion q(0.55, 0.14, 0.8, -0.2);
sceneView_->SetYaw(q.YawAngle());
sceneView_->SetPitch(q.PitchAngle());
sceneView_->GetCameraNode()->SetWorldRotation(q);
}
else
{
Node* playerSpawn = scene_->GetChild("PlayerInfoStart", true);
if (playerSpawn)
{
sceneView_->GetCameraNode()->SetPosition(playerSpawn->GetPosition());
sceneView_->SetYaw(playerSpawn->GetRotation().EulerAngles().y_);
}
}
TBWidgetDelegate* delegate = sceneView_->GetWidgetDelegate();
delegate->SetGravity(WIDGET_GRAVITY_ALL);
rootContentWidget_->AddChild(delegate);
gizmo3D_ = new Gizmo3D(context_);
gizmo3D_->SetView(sceneView_);
gizmo3D_->Show();
SubscribeToEvent(E_UPDATE, HANDLER(SceneEditor3D, HandleUpdate));
SubscribeToEvent(E_EDITORACTIVENODECHANGE, HANDLER(SceneEditor3D, HandleEditorActiveNodeChange));
// FIXME: Set the size at the end of setup, so all children are updated accordingly
// future size changes will be handled automatically
TBRect rect = container_->GetContentRoot()->GetRect();
rootContentWidget_->SetSize(rect.w, rect.h);
// TODO: generate this event properly
VariantMap eventData;
eventData[EditorActiveSceneChange::P_SCENE] = scene_;
SendEvent(E_EDITORACTIVESCENECHANGE, eventData);
SubscribeToEvent(E_EDITORPLAYSTARTED, HANDLER(SceneEditor3D, HandlePlayStarted));
SubscribeToEvent(E_EDITORPLAYSTOPPED, HANDLER(SceneEditor3D, HandlePlayStopped));
}
EditorStrings::EditorStrings(Context* context) :
Object(context)
{
InitializeStrings();
SubscribeToEvent(E_EDITORSHUTDOWN, HANDLER(EditorStrings, HandleEditorShutdown));
}
void Bird::Set(Vector3 position) {
rootNode_->SetPosition(position);
rootNode_->SetEnabledRecursive(true);
SubscribeToEvent(E_UPDATE, HANDLER(Bird, HandleUpdate));
}
return true;
}
#endif
CommandInfo kCommandInfo_IsScripted =
{
"IsScripted",
"",
0,
"returns 1 if the object or reference has a script attached to it",
0,
1,
kParams_OneOptionalInventoryObject,
HANDLER(Cmd_IsScripted_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_GetScript =
{
"GetScript",
"",
0,
"returns the script of the referenced or passed object",
0,
1,
kParams_OneOptionalInventoryObject,
HANDLER(Cmd_GetScript_Execute),
void Vehicle::OnNodeSet(Node* node)
{
if (node)
SubscribeToEvent(GetScene()->GetComponent<PhysicsWorld>(), E_PHYSICSPRESTEP, HANDLER(Vehicle, HandleFixedUpdate));
}
static void iq_get_query_XEP77_REGISTER (TestConnectorServer *self,
WockyStanza *xml);
static void iq_set_query_XEP77_REGISTER (TestConnectorServer *self,
WockyStanza *xml);
static void iq_sent (GObject *source,
GAsyncResult *result,
gpointer data);
static void iq_sent_unregistered (GObject *source,
GAsyncResult *result,
gpointer data);
#define HANDLER(ns,x) { WOCKY_XMPP_NS_##ns, #x, handle_##x }
static stanza_handler handlers[] =
{
HANDLER (SASL_AUTH, auth),
HANDLER (TLS, starttls),
{ NULL, NULL, NULL }
};
#define IQH(S,s,name,nsp,ns) \
{ WOCKY_STANZA_SUB_TYPE_##S, #name, WOCKY_##nsp##_NS_##ns, \
iq_##s##_##name##_##nsp##_##ns }
static iq_handler iq_handlers[] =
{
IQH (SET, set, bind, XMPP, BIND),
IQH (SET, set, session, XMPP, SESSION),
IQH (GET, get, query, JABBER, AUTH),
IQH (SET, set, query, JABBER, AUTH),
IQH (GET, get, query, XEP77, REGISTER),
return true;
}
#endif
CommandInfo kCommandInfo_IsCreature =
{
"IsCreature",
"",
0,
"returns 1 if the passed actor base is a creature",
0,
1,
kParams_OneOptionalActorBase,
HANDLER(Cmd_IsCreature_Execute),
Cmd_Default_Parse,
NULL,
0
};
CommandInfo kCommandInfo_GetCreatureType =
{
"GetCreatureType",
"",
0,
"returns the type of the calling creature or passed refID",
0,
1,
kParams_OneOptionalActorBase,
HANDLER(Cmd_GetCreatureType_Execute),
pdu->u.enquire_link.sequence_number);
}
static SMPP_PDU *handle_enquire_link_resp(ESME *esme, SMPP_PDU *pdu)
{
return NULL;
}
static struct {
unsigned long type;
SMPP_PDU *(*handler)(ESME *, SMPP_PDU *);
} handlers[] = {
#define HANDLER(name) { name, handle_ ## name },
HANDLER(bind_transmitter)
HANDLER(bind_receiver)
HANDLER(submit_sm)
HANDLER(deliver_sm_resp)
HANDLER(unbind)
HANDLER(enquire_link)
HANDLER(enquire_link_resp)
#undef HANDLER
};
static int num_handlers = sizeof(handlers) / sizeof(handlers[0]);
static void handle_pdu(ESME *esme, SMPP_PDU *pdu)
{
SMPP_PDU *resp;
Octstr *os;
ret_t
cherokee_handler_error_add_headers (cherokee_handler_error_t *hdl, cherokee_buffer_t *buffer)
{
cherokee_connection_t *conn = HANDLER_CONN(hdl);
/* It has special headers on protocol upgrading
*/
switch (conn->upgrade) {
case http_upgrade_nothing:
break;
case http_upgrade_tls10:
cherokee_buffer_add_str (buffer, "Upgrade: TLS/1.0, HTTP/1.1"CRLF);
break;
case http_upgrade_http11:
cherokee_buffer_add_str (buffer, "Upgrade: HTTP/1.1"CRLF);
break;
default:
SHOULDNT_HAPPEN;
}
/* 1xx, 204 and 304 (Not Modified) responses have to be managed
* by "content" handlers, anyway this test ensures that
* it'll never send wrong and unrelated headers in case that
* a 1xx, 204 or 304 response is managed by this handler.
* 304 responses should only include the
* Last-Modified, ETag, Expires and Cache-Control headers.
*/
if (!http_code_with_body (conn->error_code)) {
return ret_ok;
}
if (cherokee_connection_should_include_length(conn)) {
HANDLER(hdl)->support |= hsupport_length;
if (conn->error_code == http_range_not_satisfiable) {
/* The handler that attended the request has put the content
* length in conn->range_end in order to allow it to send the
* right length to the client.
*
* "Content-Range: bytes *" "/" FMT_OFFSET CRLF
*/
cherokee_buffer_add_str (buffer, "Content-Range: bytes */");
cherokee_buffer_add_ullong10(buffer, (cullong_t)conn->range_end);
cherokee_buffer_add_str (buffer, CRLF);
}
cherokee_buffer_add_str (buffer, "Content-Length: ");
cherokee_buffer_add_ulong10 (buffer, (culong_t) hdl->content.len);
cherokee_buffer_add_str (buffer, CRLF);
}
/* Usual headers
*/
cherokee_buffer_add_str (buffer, "Content-Type: text/html"CRLF);
if (http_type_400(conn->error_code) ||
http_type_500(conn->error_code))
{
cherokee_buffer_add_str (buffer, "Cache-Control: no-cache"CRLF);
cherokee_buffer_add_str (buffer, "Pragma: no-cache"CRLF);
}
return ret_ok;
}
