//-------------------------------------------------------------- // // Name: G_DropItemCmd // Class: None // // Description: Drops an item that is clicked on from the inventory // // Parameters: gentity_t -- the entity issuing the command. This // is the player who issued the command. // // Returns: qboolean -- true if the command was executed. // //-------------------------------------------------------------- qboolean G_DropItemCmd( const gentity_t *ent ) { if ( gi.argc() < 1 ) return false ; if ( !ent->entity->isSubclassOf( Player ) ) return false ; Player *player = (Player*)ent->entity ; str objectName = gi.argv( 1 ); str propertyName = gi.argv( 2 ); GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm ) return false ; str itemName = gpm->getStringValue( objectName, propertyName ); if ( itemName == "Empty" ) return false; str tikiName = gpm->getStringValue( itemName, "model" ); str itemType = gpm->getStringValue( itemName, "class" ); str playerItem("CurrentPlayer." + itemType); if ( !gpm->hasObject(playerItem) ) { gi.WPrintf( "Warning: Unknown item type %s for item %s", itemType.c_str(), itemName.c_str() ); return false ; } // Empty the slot gpm->setStringValue( objectName, propertyName, "Empty" ); // Give the player the item to drop //Item *givenItem = player->giveItem(tikiName); Weapon *dropweap; ClassDef *cls; cls = getClass( tikiName.c_str() ); if ( !cls ) { SpawnArgs args; args.setArg( "model", tikiName.c_str() ); cls = args.getClassDef(); if ( !cls ) return false; } dropweap = ( Weapon * )cls->newInstance(); dropweap->setModel( tikiName.c_str() ); dropweap->ProcessPendingEvents(); dropweap->SetOwner(player); dropweap->hideModel(); dropweap->setAttached(true); dropweap->Drop(); return true ; }
//-------------------------------------------------------------- // // Name: processGameplayData // Class: HealthInventoryItem // // Description: Called usually from the tiki file after all other // server side events are called. // // Parameters: Event *ev -- not used // // Returns: None // //-------------------------------------------------------------- void HealthInventoryItem::processGameplayData( Event * ) { GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm->hasObject(getArchetype()) ) return; str objname = getArchetype(); str useanim, usetype, usethread; if ( gpm->hasProperty(objname, "useanim") ) useanim = gpm->getStringValue(objname, "useanim"); if ( gpm->hasProperty(objname, "usethread") ) usethread = gpm->getStringValue(objname, "usethread"); if ( gpm->hasProperty(objname + ".Pickup", "icon") ) usetype = gpm->getStringValue(objname + ".Pickup", "icon"); // If any of these strings were set, add to our UseData object. if ( useanim.length() || usethread.length() || usetype.length() ) { if ( !useData ) useData = new UseData(); useData->setUseAnim(useanim); useData->setUseThread(usethread); useData->setUseType(usetype); } }
//-------------------------------------------------------------- // // Name: processGameplayData // Class: WeaponDualWield // // Description: Process gameplay data // // Parameters: Event *ev -- not used // // Returns: None // //-------------------------------------------------------------- void WeaponDualWield::processGameplayData( Event * ) { ClassDef *cls; GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm->hasObject(getArchetype()) ) return; str leftmodel = gpm->getStringValue(getArchetype(), "leftmodel"); str rightmodel = gpm->getStringValue(getArchetype(), "rightmodel"); if ( !_leftweapon ) { cls = getClass( leftmodel ); if ( !cls ) { SpawnArgs args; args.setArg( "model", leftmodel ); cls = args.getClassDef(); if ( !cls ) return; } _leftweapon = ( Weapon * )cls->newInstance(); _leftweapon->setModel( leftmodel ); _leftweapon->ProcessPendingEvents(); _leftweapon->hideModel(); } if ( !_rightweapon ) { cls = getClass( rightmodel ); if ( !cls ) { SpawnArgs args; args.setArg( "model", rightmodel ); cls = args.getClassDef(); if ( !cls ) return; } _rightweapon = ( Weapon * )cls->newInstance(); _rightweapon->setModel( rightmodel ); _rightweapon->ProcessPendingEvents(); _rightweapon->hideModel(); } // Process gameplay data on myself. Weapon::processGameplayData( NULL ); }
//=============================================================== // Name: G_SwapItemCmd // Class: None // // Description: Swaps an inventory item with the currently held item // of that type. This is fairly specific at this point // to use the Gameplay Database in a particular way. // // The command takes a single string, which defines an // inventory slot object. We retrieve the name of the // item in that inventory slot. If it isn't found, there // isn't an item there and nothing happens. // // If it is found, we determine if the player already has // an item of that type in their local inventory (hands). // This is done by again checking the database. If they // do have a weapon of that type, we swap this one with // that. Otherwise we just give him this weapon. // // Parameters: gentity_t -- the entity issuing the command. This // is the player who issued the command. // // Returns: qboolean -- true if the command was executed. // //=============================================================== qboolean G_SwapItemCmd( const gentity_t *ent ) { if ( gi.argc() < 1 ) return qfalse ; if ( !ent->entity->isSubclassOf( Player ) ) return qfalse ; Player *player = (Player*)ent->entity ; str objectName = gi.argv( 1 ); str propertyName = gi.argv( 2 ); str heldItem ; weaponhand_t hand = WEAPON_RIGHT; GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm ) return false ; str itemName = gpm->getStringValue( objectName, propertyName ); str tikiName = gpm->getStringValue( itemName, "model" ); str itemType = gpm->getStringValue( itemName, "class" ); str playerItem("CurrentPlayer." + itemType); if ( !gpm->hasObject(playerItem) ) { gi.WPrintf( "Warning: Unknown item type %s for item %s", itemType.c_str(), itemName.c_str() ); return qfalse ; } // Get the currently held item, and replace it with the item we clicked on heldItem = gpm->getStringValue( playerItem, "name" ); gpm->setStringValue( playerItem, "name", itemName ); // Ranged weapons are left hand if ( itemType == "Ranged" ) hand = WEAPON_LEFT ; // Remove the currently held item from the player's inventory player->takeItem( heldItem.c_str() ); // Give the player the new item we clicked on player->giveItem( tikiName ); // Use the weapon we clicked on if we picked a weapon of the same type // that we have currently equipped. Otherwise, we just swap out // the slots Weapon *weap = 0; weap = player->GetActiveWeapon(WEAPON_RIGHT); if ( !weap ) weap = player->GetActiveWeapon(WEAPON_LEFT); if ( weap ) { str tmpstr = gpm->getStringValue(weap->getArchetype(), "class"); if ( tmpstr == itemType ) player->useWeapon( itemType, hand ); } // Put the held item in inventory slot the clicked item was in. gpm->setStringValue( objectName, propertyName, heldItem ); return qtrue ; }
/* ============ PlaceItem Puts an item back in the world ============ */ void Item::PlaceItem( void ) { GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( gpm->hasProperty(getArchetype(), "noautopickup") ) { setContents( CONTENTS_USABLE ); setSolidType( SOLID_BBOX ); } else { setSolidType( SOLID_TRIGGER ); } setMoveType( MOVETYPE_TOSS ); showModel(); groundentity = NULL; }
//-------------------------------------------------------------- // // Name: getResult // Class: GameplayFormulaOperand // // Description: Gets the result of the operand given the data // // Parameters: const GameplayFormulaData& formulaData -- Data to use // // Returns: float -- The result, or 1.0 if there's a problem // //-------------------------------------------------------------- float GameplayFormulaOperand::getResult(const GameplayFormulaData& formulaData) { float finalResult = _constant; // Constant is factored in here. str name; GameplayManager *gpm = GameplayManager::getTheGameplayManager(); char firstobj[255], *sptr; strcpy(firstobj, _object.c_str()); sptr = strchr(firstobj, '.'); sptr = 0; // Defines are a special case if ( !strcmp(firstobj,"Defines") ) { finalResult *= gpm->getFloatValue(_property, "value"); return finalResult; } if ( !strcmp(firstobj, "Primary") && formulaData.primary ) name = formulaData.primary->getArchetype(); if ( !strcmp(firstobj, "Secondary") && formulaData.secondary ) name = formulaData.secondary->getArchetype(); if ( !strcmp(firstobj, "Weapon") && formulaData.weapon ) name = formulaData.weapon->getArchetype(); if ( !strcmp(firstobj, "AttackType") ) name = formulaData.attackType; // The object was not one of the code-keywords, check the database // itself for the object and property. if ( !name.length() ) { finalResult *= gpm->getFloatValue(_object, _property); return finalResult; } if ( _inverse ) finalResult *= (1.0f / gpm->getFloatValue(name, _property)); else finalResult *= gpm->getFloatValue(name, _property); return finalResult; }
//=============================================================== // Name: G_PurchaseSkillCmd // Class: None // // Description: Purchases a skill for the current player. This // goes into the gameplay database and looks for a // CurrentPlayer object who has a skillPoints property. // // If its found, we attempt to increment the value // of the skill specified in the command's first argument. // We also decrement by one the number of available skillPoints. // // Parameters: gentity_t -- the entity issuing the command. Not used. // // Returns: qboolean -- true if the command was executed. // //=============================================================== qboolean G_PurchaseSkillCmd( const gentity_t *ent ) { str propname ; if ( gi.argc() < 1 ) return qfalse ; propname = gi.argv( 1 ); GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm ) return false ; float skillPoints = gpm->getFloatValue( "CurrentPlayer", "SkillPoints" ); if ( skillPoints > 0.0f ) { str objName("CurrentPlayer."); objName += propname ; float skillValue = gpm->getFloatValue( objName, "value" ); if ( skillValue < gpm->getFloatValue( objName, "max" ) ) { gpm->setFloatValue( objName, "value", skillValue + 1.0f ); gpm->setFloatValue( "CurrentPlayer", "SkillPoints", skillPoints - 1.0f ); if ( ent->entity->isSubclassOf( Player ) ) { Player *player = (Player*)ent->entity; player->skillChanged( objName ); } } } return qtrue ; }
void HealthInventoryItem::Use( Event *ev ) { Entity *other; Sentient *sen; //Event *event; str sound_name; other = ev->GetEntity<Entity>( 1 ); if ( !other || !other->isSubclassOf( Sentient ) ) { return; } sen = ( Sentient * )other; GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( gpm->hasObject(getArchetype()) ) { if ( gpm->hasFormula("HealthPotion") ) { GameplayFormulaData fd(this); amount = gpm->calculate("HealthPotion", fd, sen->max_health); } str snd = gpm->getStringValue(getArchetype() + ".Use", "wav"); if ( snd.length() ) { int channel = CHAN_BODY; float volume = -1.0f; float mindist = -1.0f; if ( gpm->hasProperty(getArchetype() + ".Use","channel") ) channel = (int)gpm->getFloatValue(getArchetype() + ".Use", "channel"); if ( gpm->hasProperty(getArchetype() + ".Use","volume") ) volume = (int)gpm->getFloatValue(getArchetype() + ".Use", "volume"); if ( gpm->hasProperty(getArchetype() + ".Use","mindist") ) mindist = (int)gpm->getFloatValue(getArchetype() + ".Use", "mindist"); Sound(snd, channel, volume, mindist); } } sen->health += (float)amount; if ( sen->health > sen->max_health ) { sen->health = sen->max_health; } // If we are on fire stop it sen->ProcessEvent( EV_Sentient_StopOnFire ); // Spawn special effect around sentient // Uncomment if we need it /*sound_name = GetRandomAlias( "snd_use" ); if ( sound_name ) other->Sound( sound_name.c_str(), 0 ); event = new Event( EV_AttachModel ); event->AddString( "models/fx_tikifx2.tik" ); event->AddString( "Bip01 Spine" ); // set scale event->AddFloat( 1.0f ); // set targetname event->AddString( "regen" ); // set detach_at_death event->AddInteger( 1 ); // set remove_time event->AddFloat( 2.0f ); other->ProcessEvent( event );*/ PostEvent( EV_Remove, 0.0f ); }
void Health::PickupHealth( Event *ev ) { Sentient *sen; Entity *other; other = ev->GetEntity( 1 ); if ( !other || !other->isSubclassOf( Sentient ) ) { return; } sen = ( Sentient * )other; if ( sen->health >= sen->max_health ) return; if ( !ItemPickup( other, false ) ) { return; } GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( gpm->hasObject(getArchetype()) ) { if ( gpm->hasFormula("HealthPotion") ) { GameplayFormulaData fd(this); amount = gpm->calculate("HealthPotion", fd, sen->max_health); } str snd = gpm->getStringValue(getArchetype() + ".Use", "wav"); if ( snd.length() ) { int channel = CHAN_BODY; float volume = -1.0f; float mindist = -1.0f; if ( gpm->hasProperty(getArchetype() + ".Use","channel") ) channel = (int)gpm->getFloatValue(getArchetype() + ".Use", "channel"); if ( gpm->hasProperty(getArchetype() + ".Use","volume") ) volume = (int)gpm->getFloatValue(getArchetype() + ".Use", "volume"); if ( gpm->hasProperty(getArchetype() + ".Use","mindist") ) mindist = (int)gpm->getFloatValue(getArchetype() + ".Use", "mindist"); Sound(snd, channel, volume, mindist); } } sen->health += (float)amount; if ( sen->health > sen->max_health ) { sen->health = sen->max_health; } // If we are on fire stop it sen->ProcessEvent( EV_Sentient_StopOnFire ); }
Item * Item::ItemPickup( Entity *other, qboolean add_to_inventory, qboolean checkautopickup ) { Sentient * sent; Item * item = NULL; str realname; // Query the gameplay manager and see if we should not auto-pickup this item if ( checkautopickup ) { GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( gpm->hasProperty(getArchetype(), "noautopickup") ) return NULL; } if ( !Pickupable( other ) ) { return NULL; } sent = ( Sentient * )other; if ( add_to_inventory ) { item = sent->giveItem( model, getAmount(), true ); if ( !item ) return NULL; } else { item = this; } // // make sure to copy over the coolness factor :) // item->coolitem = coolitem; item->cool_dialog = cool_dialog; item->cool_anim = cool_anim; item->coolitemforced = coolitemforced; // // let our sent know they received it // we put this here so we can transfer information from the original item we picked up // if ( !isSubclassOf( Weapon ) || add_to_inventory ) sent->ReceivedItem( item ); realname = GetRandomAlias( "snd_pickup" ); if ( realname.length() > 1 ) sent->Sound( realname, CHAN_ITEM ); if ( !Removable() ) { // leave the item for others to pickup return item; } look_at_me = false; CancelEventsOfType( EV_Item_DropToFloor ); CancelEventsOfType( EV_Item_Respawn ); CancelEventsOfType( EV_FadeOut ); setSolidType( SOLID_NOT ); if ( animate && animate->HasAnim( "pickup" ) ) animate->RandomAnimate( "pickup", EV_Item_PickupDone ); else { if ( !no_remove ) { if ( _missingSkin ) { ChangeSkin( _missingSkin, true ); } else { hideModel(); } if ( !Respawnable() ) PostEvent( EV_Remove, FRAMETIME ); } } if ( Respawnable() ) PostEvent( EV_Item_Respawn, RespawnTime() ); // fire off any pickup_thread's if ( pickup_thread.length() ) { ExecuteThread( pickup_thread ); } if ( item && multiplayerManager.checkFlag( MP_FLAG_INSTANT_ITEMS ) ) { Event *ev; ev = new Event( EV_InventoryItem_Use ); ev->AddEntity( other ); item->ProcessEvent( ev ); } return item; }
//-------------------------------------------------------------- // Name: init() // Class: TorsoAimAndFireWeapon // // Description: Initializes the behavior // // Parameters: Actor &self // // Returns: None //-------------------------------------------------------------- void TorsoAimAndFireWeapon::init( Actor &self ) { _self = &self; //Set Our Controller Tag and set up our angles self.SetControllerTag( ActorTorsoTag, gi.Tag_NumForName( self.edict->s.modelindex, "Bip01 Spine1" ) ); _currentTorsoAngles = self.GetControllerAngles( ActorTorsoTag ); _animDone = false; _canAttack = true; _aimAnim = "idle"; _preFireAnim = "idle"; _fireAnim = "idle"; _postFireAnim = "idle"; GameplayManager *gpm = GameplayManager::getTheGameplayManager(); if ( !gpm->hasObject(self.getArchetype()) ) return; str objname = self.combatSubsystem->GetActiveWeaponArchetype(); objname = "Hold" + objname; if ( gpm->hasProperty(objname, "Aim") ) _aimAnim = gpm->getStringValue( objname , "Aim" ); if ( gpm->hasProperty( objname , "PreFire" ) ) _preFireAnim = gpm->getStringValue( objname , "PreFire" ); if ( gpm->hasProperty( objname , "Fire" ) ) _fireAnim = gpm->getStringValue( objname , "Fire" ); if ( gpm->hasProperty( objname , "PostFire" ) ) _postFireAnim = gpm->getStringValue( objname , "PostFire" ); if ( gpm->hasProperty( objname , "AimTimeMin" ) ) _aimTimeMin = gpm->getFloatValue( objname , "AimTimeMin" ); if ( gpm->hasProperty( objname , "AimTimeMax" ) ) _aimTimeMax = gpm->getFloatValue( objname , "AimTimeMax" ); if ( gpm->hasProperty( objname , "FireTimeMin" ) ) _fireTimeMin = gpm->getFloatValue( objname , "FireTimeMin" ); if ( gpm->hasProperty( objname , "FireTimeMax" ) ) _fireTimeMax = gpm->getFloatValue( objname , "FireTimeMax" ); if ( gpm->hasProperty( objname , "ShotCount" ) ) _shots = (int)gpm->getFloatValue( objname , "ShotCount" ); float spreadX, spreadY; spreadX = self.combatSubsystem->GetDataForMyWeapon( "spreadx" ); spreadY = self.combatSubsystem->GetDataForMyWeapon( "spready" ); self.combatSubsystem->OverrideSpread( spreadX , spreadY ); //Clear Out Our VolleyCount _self->shotsFiredThisVolley = 0; updateEnemy(); }
//-------------------------------------------------------------- // Name: init() // Class: GotoCurrentHelperNode // // Description: Initializes the behavior // // Parameters: Actor &self // // Returns: None //-------------------------------------------------------------- void GotoCurrentHelperNode::init( Actor &self ) { str objname; str movementMode; str stateName; GameplayManager *gpm; self.movementSubsystem->setFaceEnemy( _faceEnemy ); // // Animation Selection // 1st We check if we have an explicit animation in the GPD for our state, if we // do, we're going to use that. // // Next, we'll check for StateVar, and pull the animation from that... // If we have nothing there, then we'll just assume the animation passed in // is the animation we are going to try and use // //First check if we're even in the GPM gpm = GameplayManager::getTheGameplayManager(); if ( gpm->hasObject(self.getArchetype()) ) { //Now we're going to check and see if we have state data //in the GPM for our current state that has our movement //mode in it. objname = self.getArchetype(); stateName = self.currentState->getName(); objname = objname + "." + stateName; //If we have a MovementMode property, use its value, else use //the default value of RUN if ( gpm->hasProperty( objname , "MovementMode" ) ) movementMode = gpm->getStringValue( objname , "MovementMode" ); else movementMode = "RUN"; //Now, depending on what our movementMode is, we set a proper //movement animation objname = self.getArchetype(); objname = objname + "." + self.GetAnimSet(); if ( movementMode == "RUN" ) { if ( gpm->hasProperty(objname, "Run") ) _movementAnim = gpm->getStringValue( objname , "Run" ); return; } if ( movementMode == "WALK" ) { if ( gpm->hasProperty(objname, "Walk") ) _movementAnim = gpm->getStringValue( objname , "Walk" ); return; } } // We didn't find anything in the GPD, so let's check for // state vars str movementAnim = self.GetStateVar( _movementAnim ); if ( movementAnim.length() ) _movementAnim = movementAnim; }