ObjectHandle InsertItemCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*definitionManager_);
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Insert");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<InsertItemCommandArgument>();
if (!InsertItemCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Insert");
return ObjectHandle(std::move(handle));
}
genericObject.set("Id", pCommandArgs->key_);
genericObject.set("Name", "Insert");
genericObject.set("Type", "Insert");
genericObject.set("PostValue", pCommandArgs->value_);
return ObjectHandle(std::move(handle));
}
bool ModelQtTypeConverter::toVariant( const QVariant & qVariant, Variant & o_variant ) const
{
if (qVariant.canConvert< QtTableModel * >())
{
auto model = qVariant.value< QtTableModel * >();
o_variant = ObjectHandle( &model->source() );
return true;
}
if (qVariant.canConvert< QtTreeModel * >())
{
auto model = qVariant.value< QtTreeModel * >();
o_variant = ObjectHandle( &model->source() );
return true;
}
if (qVariant.canConvert< QtListModel * >())
{
auto model = qVariant.value< QtListModel * >();
o_variant = ObjectHandle( &model->source() );
return true;
}
if (qVariant.canConvert< QtItemModel * >())
{
auto model = qVariant.value< QtItemModel * >();
o_variant = ObjectHandle( &model->source() );
return true;
}
return false;
}
ObjectHandle SetItemDataCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*definitionManager_);
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Data");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<SetItemDataCommandArgument>();
if (!SetItemDataCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Data");
return ObjectHandle(std::move(handle));
}
genericObject.set("Name", "Data");
genericObject.set("Type", "Data");
const auto& oldValue = (pCommandArgs->oldValue_);
const auto& newValue = (pCommandArgs->newValue_);
genericObject.set("PreValue", oldValue);
genericObject.set("PostValue", newValue);
return ObjectHandle(std::move(handle));
}
ObjectHandle MoveItemDataCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*get<IDefinitionManager>());
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<MoveItemDataCommandArgument>();
if (!MoveItemDataCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
genericObject.set("Name", "Move");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
//------------------------------------------------------------------------------
ObjectHandle reflectedCast(const ObjectHandle& other, const TypeId& typeIdDest,
const IDefinitionManager& definitionManager)
{
std::shared_ptr<IObjectHandleStorage> storage =
std::make_shared<ObjectHandleStorageReflectedCast>(other.storage(), typeIdDest, definitionManager);
return ObjectHandle(storage);
}
ObjectHandle ObjectHandle::lookup(ManagedObject *object)
{
for (auto it = objectByHandle.begin(); it != objectByHandle.end(); it++) {
if (it->second.ptr == object) return(ObjectHandle(it->first));
}
return(nullHandle);
}
bool toVariant( const QVariant & qVariant, Variant & o_variant ) const override
{
if ( static_cast<int>( qVariant.type() ) != static_cast<int>( QMetaType::QObjectStar ))
{
return false;
}
o_variant = ObjectHandle( qvariant_cast< QObject * >( qVariant ) );
return true;
}
void XMLReader::StackItem::cast(IDefinitionManager& definitionManager)
{
object = ObjectHandle();
collection = nullptr;
if (auto v = value.value<ObjectHandle*>())
{
object = *v;
}
else if (auto v = value.value<Collection*>())
{
collection = v;
}
else
{
if (auto definition = definitionManager.getDefinition(value.type()->typeId().getName()))
{
object = ObjectHandle(&value, definition);
}
}
}
void CompoundCommand::deserialize(ISerializer& serializer)
{
size_t size = 0;
serializer.deserialize(size);
std::string id;
for (size_t i = 0; i < size; ++i)
{
serializer.deserialize(id);
addCommand(id.c_str(), ObjectHandle());
}
getMacroObject().getBase<MacroObject>()->deserialize(serializer);
}
void TestUIContext::select(std::string id)
{
std::string oldId = selectedId_;
selectedId_ = models_.find(id) != models_.end() ? id : NO_ID;
treeVisible_ = selectedId_ != NO_ID;
selectedModel_ = treeVisible_ ? models_.at(selectedId_) : ObjectHandle();
definition_->bindProperty("treeVisible", handle()).setValue(treeVisible_);
if (oldId != selectedId_)
{
auto tree = std::static_pointer_cast<proto::PropertyTreeModel>(selectedTree_);
tree->setObject(selectedModel_);
}
}
pair<ObjectHandle,double> BoundedObject::checkCollision(Pd origin, Vd direction, Object *ignore)
{
double collision = numeric_limits<double>::infinity();
//--- We only check lbl rbh, could be improved-----
Point<double> a = bb.lbl;
Point<double> b = bb.rth;
//--- Origin does not have to be rotated
Point<double> p = (-rotation)*(origin - this->origin);
//--- Vector only needs to be rotated
//--- We might need the inverse of rotation here
Vector<double> v = (-rotation)*direction;
//--- Now check if we have a collision in the x direction
double lambda1, lambda2;
if(v.x != 0){
lambda1 = (a.x - p.x)/(v.x);
lambda2 = (b.x - p.x)/(v.x);
if(insideBox(p + v*lambda1, a, b) && 0 < lambda1 && lambda1 < collision){
collision = lambda1;
}
if (insideBox(p + v*lambda2, a, b) && 0 < lambda2 && lambda2 < collision){
collision = lambda2;
}
}
//---- y direction
if(v.y != 0){
lambda1 = (a.y - p.y)/(v.y);
lambda2 = (b.y - p.y)/(v.y);
if(insideBox(p + v*lambda1, a, b) && 0 < lambda1 && lambda1 < collision){
collision = lambda1;
}
if(insideBox(p + v*lambda2,a,b) && 0 < lambda2 && lambda2 < collision){
collision = lambda2;
}
}
//--- z direction
if(v.z != 0){
lambda1 = (a.z - p.z)/(v.z);//intersection with axis in lbl.z
lambda2 = (b.z - p.z)/(v.z);
if(insideBox(p + v*lambda1, a, b) && 0 < lambda1 && lambda1 < collision){
collision = lambda1;
}
if(insideBox(p + v*lambda2, a, b) && 0 < lambda2 && lambda2 < collision){
collision = lambda2;
}
}
return make_pair(ObjectHandle(),collision);
}
void erase( const PropertyAccessor & pa, const Variant & eraseKey )
{
Key key;
if (!createKey( pa, key ))
{
pa.erase( eraseKey );
return;
}
std::unique_ptr<ReflectedCollectionEraseCommandParameters> commandParameters( new ReflectedCollectionEraseCommandParameters() );
commandParameters->id_ = key.first;
commandParameters->path_ = key.second;
commandParameters->key_ = eraseKey;
const auto itr = commands_.emplace( std::pair< Key, CommandInstancePtr >( key, commandManager_.queueCommand(
getClassIdentifier<ReflectedCollectionEraseCommand>(), ObjectHandle( std::move( commandParameters ) ) ) ) );
commandManager_.waitForInstance( itr->second );
commands_.erase( itr );
}
ObjectHandle World::trace(Point<double> origin, Vector<double> &path, Object* ignore)
{
pair<ObjectHandle, double> closest = make_pair(ObjectHandle(), !path);
BoundedObject *bo;
pair<ObjectHandle, double> ret;
for (Object::iterator it = begin(); it != end(); ++it)
{
if (!(bo = TO(BoundedObject,*it))) continue;
if((!TO(Player, *it) && !TO(Terrain, *it)) || TO(Object, *it) == ignore) continue;
ret = bo->checkCollision(origin, ~path, ignore);
if (ret.second < closest.second){
closest = ret;
if(!TO(Terrain, *it)){
closest.first = *it;
}
}
}
path = ~path * closest.second;
return closest.first;
}
//------------------------------------------------------------------------------
ObjectHandle reflectedRoot(const ObjectHandle& source, const IDefinitionManager& definitionManager)
{
if (!source.isValid())
{
return source;
}
auto root = source.storage();
auto reflectedRoot = definitionManager.getObjectDefinition(root) != nullptr ? root : nullptr;
for (;;)
{
auto inner = root->inner();
if (inner == nullptr)
{
break;
}
root = inner;
reflectedRoot = definitionManager.getObjectDefinition(root) != nullptr ? root : nullptr;
}
return ObjectHandle(reflectedRoot);
}
void Build()
{
Camera &cam = game.controller->camera;
GridPoint clicked = game.world->terrain->getGridCoordinates(cam.origin, cam.objective);
if(clicked.isValid())
{
#ifdef AUTOBUILD
int structure = game.world->terrain->canPlaceStructure(clicked);
ObjectHandle tower;
switch(structure){
case 1: case 11: tower = Objects::DefenseTower(game.player->id); break;
case 2: case 12: tower = Objects::ResourceMine(game.player->id); break;
case 3: case 13: tower = Objects::RichResourceMine(game.player->id); break;
default: tower = ObjectHandle();
}
Resource cost = 0;
if(tower){
Building *b = TO(Building, tower);
if(b) cost = b->cost;
}
map<unsigned char,Team>::iterator it = Game::game.teams.find(Game::game.player->team);
if(it != Game::game.teams.end()){
if(it->second.resources >= cost){
game.world->terrain->setSelected(GridPoint(-1, -1));
if (!game.world->terrain->placeStructure(clicked, tower)){
Echo("There's already a tower there");
}else{
NetCode::Build(clicked,TO(Structure,tower));
it->second.resources -= cost;
}
}else{
Echo("You don't have enough money");
}
}
#endif
}
else
Echo("Invalid place to build");
}
Variant invoke( const PropertyAccessor & pa, const ReflectedMethodParameters & parameters )
{
Key key;
if (!createKey( pa, key ))
{
return pa.invoke( parameters );
}
std::unique_ptr<ReflectedMethodCommandParameters> commandParameters( new ReflectedMethodCommandParameters() );
commandParameters->setId( key.first );
commandParameters->setPath( key.second.c_str() );
commandParameters->setParameters( parameters );
const auto itr = commands_.emplace( std::pair< Key, CommandInstancePtr >( key, commandManager_.queueCommand(
getClassIdentifier<InvokeReflectedMethodCommand>(), ObjectHandle( std::move( commandParameters ),
pa.getDefinitionManager()->getDefinition<ReflectedMethodCommandParameters>() ) ) ) );
commandManager_.waitForInstance( itr->second );
ObjectHandle returnValueObject = itr->second.get()->getReturnValue();
commands_.erase( itr );
Variant* returnValuePointer = returnValueObject.getBase<Variant>();
assert( returnValuePointer != nullptr );
return *returnValuePointer;
}
ObjectHandle TriPatchObject::CreateTriObjRep(TimeValue t) {
TriObject *tri = CreateNewTriObject();
PrepareMesh(t); // Turn it into a mesh
tri->GetMesh() = patch.GetMesh(); // Place it into the TriObject
return(ObjectHandle(tri));
}
ObjectHandle BoundedObject::checkCollision2(Pd origin, Vd direction)
{
return ObjectHandle();
}
void Fire()
{
if (!game.input->grabbing) return; // Ignore when not selected
if (!NetCode::TryLock())
{
game.firing = true;
return;
}
game.firing = false;
switch (game.player->weapon)
{
case weapWrench:
Build();
return;
case weapLaser:
{
Camera &cam = game.controller->camera;
Vd vec = ~(game.player->rotation * Vd(0,1,0));
double yaw = atan2(vec.x, vec.y);
Pd gunLoc = game.player->origin;// + game.player->model.weapon->origin;
gunLoc.x = gunLoc.x + game.player->model.weapon->origin.x * cos(yaw)
+ game.player->model.weapon->origin.y * sin(yaw);
gunLoc.y = gunLoc.y + game.player->model.weapon->origin.x * sin(yaw)
+ game.player->model.weapon->origin.y * cos(yaw);
gunLoc.z = gunLoc.z + game.player->model.weapon->origin.z;
Vd lookVec = (~(Vd(game.controller->target)+ -Vd(cam.origin))) * 38;
Pd target = game.controller->target;
ObjectHandle collision;
if(game.controller->firstPerson){
lookVec = (~(game.controller->camAngle * Vd(0,1,0)))*38;
collision = game.world->trace(game.controller->camera.origin, lookVec, game.player);
}else{
collision = game.world->trace(game.controller->target, lookVec, game.player);
}
if (collision)
{
Pd collisionPoint;
if(game.controller->firstPerson){
collisionPoint = game.controller->camera.origin + (lookVec);
}else{
collisionPoint = game.controller->target + (lookVec);
}
Qd beam = gunLoc.lookAt(collisionPoint);
ObjectHandle laser = LaserBeam(gunLoc, beam, !lookVec);
game.world->addLaserBeam(laser);
NetCode::Fire(*TO(LaserBeam,laser));
Player *p = TO(Player, collision);
if(p){
//if(p->team != game.player->team){//Precent teamkill
p->damage(10.0, game.player->id);
NetCode::Hit(p->id, 10.0, true);
//}
}else{
Building *b = TO(Building, collision);
if(b){
/* Enable team kill on towers to demolish
Player *own = NULL;
if(Game::game.players.count(t->owner))
own = TO(Player, Game::game.players[t->owner]);
if(own && own->team != game.player->team){*/
b->damage(10.0, game.player->id);
NetCode::Attack(b->loc, 10.0, true);
//}
}
}
}
else{
game.world->addLaserBeam(ObjectHandle(LaserBeam(gunLoc, cam.objective, !lookVec)));
}
return;
}
break;
}
}
ObjectHandle TriObject::CreateTriObjRep(TimeValue t) {
return(ObjectHandle(this));
}
// From Object
ObjectHandle TargetObject::ApplyTransform(Matrix3& matrix){
return(ObjectHandle(this));
}