int MWMechanics::Alchemy::addIngredient (const MWWorld::Ptr& ingredient)
{
// find a free slot
int slot = -1;
for (int i=0; i<static_cast<int> (mIngredients.size()); ++i)
if (mIngredients[i].isEmpty())
{
slot = i;
break;
}
if (slot==-1)
return -1;
for (TIngredientsIterator iter (mIngredients.begin()); iter!=mIngredients.end(); ++iter)
if (!iter->isEmpty() && Misc::StringUtils::ciEqual(ingredient.getClass().getId(ingredient),
iter->getClass().getId(*iter)))
return -1;
mIngredients[slot] = ingredient;
updateEffects();
return slot;
}
void MWMechanics::Alchemy::removeIngredient (int index)
{
if (index>=0 && index<static_cast<int> (mIngredients.size()))
{
mIngredients[index] = MWWorld::Ptr();
updateEffects();
}
}
AudioSettings::AudioSettings(TabFrame* parent) : TabFrameItem(parent) {
setIcon(Icon::Device::Speaker);
setText("Audio");
layout.setMargin(5);
driverLabel.setFont(Font().setBold()).setText("Driver Settings");
latencyLabel.setText("Latency:");
latencyCombo.append(ComboButtonItem().setText("0ms"));
latencyCombo.append(ComboButtonItem().setText("20ms"));
latencyCombo.append(ComboButtonItem().setText("40ms"));
latencyCombo.append(ComboButtonItem().setText("60ms"));
latencyCombo.append(ComboButtonItem().setText("80ms"));
latencyCombo.append(ComboButtonItem().setText("100ms"));
switch(settings["Audio/Latency"].natural()) {
case 0: latencyCombo.item(0)->setSelected(); break;
case 20: latencyCombo.item(1)->setSelected(); break;
case 40: latencyCombo.item(2)->setSelected(); break;
case 60: latencyCombo.item(3)->setSelected(); break;
case 80: latencyCombo.item(4)->setSelected(); break;
case 100: latencyCombo.item(5)->setSelected(); break;
}
latencyCombo.onChange([&] { updateDriver(); });
frequencyLabel.setText("Frequency:");
auto frequencyValue = audio->get(Audio::Frequency).get<uint>(44100);
frequencyCombo.append(ComboButtonItem().setText({frequencyValue, "hz"}));
frequencyCombo.setEnabled(false);
resamplerLabel.setText("Resampler:");
resamplerCombo.append(ComboButtonItem().setText("IIR - Biquad"));
resamplerCombo.setEnabled(false);
exclusiveMode.setText("Exclusive Mode");
exclusiveMode.setChecked(settings["Audio/Exclusive"].boolean()).onToggle([&] { updateDriver(); });
if(!audio->cap(Audio::Exclusive)) exclusiveMode.remove();
effectsLabel.setFont(Font().setBold()).setText("Effects");
volumeLabel.setText("Volume:");
volumeValue.setAlignment(0.5);
volumeSlider.setLength(501).setPosition(settings["Audio/Volume"].natural()).onChange([&] { updateEffects(); });
balanceLabel.setText("Balance:");
balanceValue.setAlignment(0.5);
balanceSlider.setLength(101).setPosition(settings["Audio/Balance"].natural()).onChange([&] { updateEffects(); });
reverbEnable.setText("Reverb").setChecked(settings["Audio/Reverb/Enable"].boolean()).onToggle([&] { updateEffects(); });
updateDriver();
updateEffects();
}
void Element::update(float dt)
{
BBGE_PROF(Element_update);
if (!core->particlesPaused)
{
updateLife(dt);
updateEffects(dt);
if (drawGrid)
updateGrid(dt);
}
// updateCullVariables();
}
void updateAllEffects(void) {
updateEffects(ch0->note, ch0->waveTable_ref);
updateEffects(ch1->note, ch1->waveTable_ref);
updateEffects(ch2->note, ch2->waveTable_ref);
updateEffects(ch3->note, ch3->waveTable_ref);
updateEffects(ch4->note, ch4->waveTable_ref);
updateEffects(ch5->note, ch5->waveTable_ref);
}
void EnemyBase::update()
{
updateEffects();
bar.centerToPoint(this->getCenterX(),this->getCenterY() - getHeight()/2 - 10);
if(road != NULL)
if(currentRoadTile < road->getRoadLenght() - 1)
{
SDL_Point nextTile = road->getPointAt(currentRoadTile + 1);
SDL_Point curTile = road->getPointAt(currentRoadTile);
int dirX = nextTile.x - curTile.x;
int dirY = nextTile.y - curTile.y;
move(dirX * speed,dirY * speed);
distance += (double)speed;
double cpX = nextTile.x * TILEWIDTH + TILEWIDTH/2;
double cpY = nextTile.y * TILEHEIGHT + TILEHEIGHT/2;
if(dirX != 0)
{
if((cpX - getCenterX()) * dirX <= 0)
{
setX(cpX - getWidth()/2);
currentRoadTile++;
}
}
else
{
if((cpY - getCenterY())*dirY <= 0)
{
setY(cpY - getHeight()/2);
currentRoadTile++;
}
}
}
else
{
reachedEnd = true;
}
}
void QuestsWindow::setMap(const Map *const map)
{
if (mMap != map)
{
mMap = map;
mMapEffects.clear();
if (!mMap)
return;
const std::string name = mMap->getProperty("shortName");
FOR_EACH (std::vector<QuestEffect*>::const_iterator, it, mAllEffects)
{
const QuestEffect *const effect = *it;
if (effect && name == effect->map)
mMapEffects.push_back(effect);
}
updateEffects();
}
void Camera::update(const ego_mesh_t *mesh)
{
// Update the _turnTime counter.
if (CameraTurnMode::None != _turnMode)
{
_turnTime = 255;
}
else if (_turnTime > 0)
{
_turnTime--;
}
// Camera controls.
for (PLA_REF ipla = 0; ipla < MAX_PLAYER; ++ipla)
{
// Don't do invalid players.
if (INVALID_PLA(ipla))
{
continue;
}
player_t *ppla = PlaStack.get_ptr(ipla);
// Handle camera control from this player.
readInput(ppla->pdevice);
}
// Update the special camera effects like grog.
updateEffects();
// Update the average position of the tracked characters.
updateTrack(mesh);
// Move the camera center, if need be.
updateCenter();
// Make the zadd and zoom work together.
updateZoom();
// Update the position of the camera.
updatePosition();
// Set the view matrix.
makeMatrix();
}
void MWMechanics::Alchemy::removeIngredients()
{
bool needsUpdate = false;
for (TIngredientsContainer::iterator iter (mIngredients.begin()); iter!=mIngredients.end(); ++iter)
if (!iter->isEmpty())
{
iter->getContainerStore()->remove(*iter, 1, mAlchemist);
if (iter->getRefData().getCount()<1)
{
needsUpdate = true;
*iter = MWWorld::Ptr();
}
}
if (needsUpdate)
updateEffects();
}
/*
Uses:
Affects:
*/
void Territory::update(UpdateInfo info, Controls * controls, Sounds * sounds)
{
this->sounds = sounds;
// Update all player projectiles
/*
Uses: playerProjectile
Affects: playerProjectile
*/
updatePlayerProjectiles(info, controls);
/*
Uses: playerProjectiles(boundingBox), enemies(boundingBox), playerProjectiles(piercing)
Affects: playerProjectiles(piercing), enemies(hp), effects(spawns)
*/
collidePlayerProjectiles(info, controls);
// Update all enemies.
/*
Uses: enemies
Affects: enemies
*/
updateEnemies(info);
// Check if the player is hit by enemy projectiles.
/*
Uses: enemyProjectiles
Affects: enemyProjectiles
*/
updateEnemyProjectiles(info, controls);
/*
Uses: enemyProjectiles(boundingBox), player(boundingBox), enemyProjectiles(piercing)
Affects: enemyProjectiles(piercing), player(hp), sounds(play)
*/
collideEnemyProjectiles(info, controls);
/*
Uses: enemyProjectiles(boundingBox), player(isInSafe), partitionedSafeZonesTiles(boundingBox)
Affects: enemyProjectiles(expend)
*/
collideEnemyProjectilesSafe(info, controls);
// Update player and safe zone checks.
/*
Uses: player(getBoundingBox, getConvexHull, getSpeed), safeZonesTiles(getBoundingBox, getConvexHull)
Affects: player(update, setIsInSafeZone, setSafeZoneIndex)
*/
updatePlayer(info, controls);
// Update all effects.
/*
Uses: effects
Affects: effects
*/
updateEffects(info);
// Spawn enemy
/*
Uses: enemySpawner, getSpawnPoints
Affects: enemySpawner, spawnQueue, entityCluster.getCollection(1), entityCluster.getCollection(0)
*/
enemySpawner.update(getSpawnPoints(), spawnQueue, player, entityCluster.getCollection(1), entityCluster.getCollection(0), info);
// Background tile stuff.
/*
Uses: tileColorings
Affects: floorTiles(setColor), tileColorings
*/
cleanFloorTiles();
// Enemy aura colorization on floor tiles.
/*
Uses: enemies(getPosition), territory(getPosition), floorTiles(getColor)
Affects: floorTiles(setColor), tileColorings
*/
colorEnemyAuraTiles();
// Beware this section can change if this territory is active.
// Handle the case of the player trying to cross the territory border.
/*
Uses: floorTiles,player(getBoundingBox, getConvexHull, getPosition, getSpeed), this(position)
Affects: world(changeTerritory), player(setPosition)
*/
collideBorderTiles();
}
void QuestsWindow::rebuild(const bool playSound)
{
mQuestsModel->clear();
mQuestLinks.clear();
StringVect &names = mQuestsModel->getNames();
std::vector<Image*> &images = mQuestsModel->getImages();
std::vector<QuestItem*> complete;
std::vector<QuestItem*> incomplete;
std::vector<QuestItem*> hidden;
int updatedQuest = -1;
int newCompleteStatus = -1;
for (std::map<int, int>::const_iterator it = mVars.begin(),
it_end = mVars.end(); it != it_end; ++ it)
{
const int var = (*it).first;
const int val = (*it).second;
const std::vector<QuestItem*> &quests = mQuests[var];
FOR_EACH (std::vector<QuestItem*>::const_iterator, it2, quests)
{
if (!*it2)
continue;
QuestItem *const quest = *it2;
// complete quest
if (quest->complete.find(val) != quest->complete.end())
complete.push_back(quest);
// incomplete quest
else if (quest->incomplete.find(val) != quest->incomplete.end())
incomplete.push_back(quest);
// hidden quest
else
hidden.push_back(quest);
}
}
int k = 0;
for (std::vector<QuestItem*>::const_iterator it = complete.begin(),
it_end = complete.end(); it != it_end; ++ it, k ++)
{
QuestItem *const quest = *it;
if (quest->completeFlag == 0 || (quest->broken
&& quest->completeFlag == -1))
{
updatedQuest = k;
newCompleteStatus = 1;
}
quest->completeFlag = 1;
mQuestLinks.push_back(quest);
names.push_back(quest->name);
if (mCompleteIcon)
{
mCompleteIcon->incRef();
images.push_back(mCompleteIcon);
}
else
{
images.push_back(nullptr);
}
}
for (std::vector<QuestItem*>::const_iterator it = incomplete.begin(),
it_end = incomplete.end(); it != it_end; ++ it, k ++)
{
QuestItem *const quest = *it;
if (quest->completeFlag == -1)
{
updatedQuest = k;
newCompleteStatus = 0;
}
quest->completeFlag = 0;
mQuestLinks.push_back(quest);
names.push_back(quest->name);
if (mIncompleteIcon)
{
mIncompleteIcon->incRef();
images.push_back(mIncompleteIcon);
}
else
{
images.push_back(nullptr);
}
}
FOR_EACH (std::vector<QuestItem*>::const_iterator, it, hidden)
(*it)->completeFlag = -1;
if (updatedQuest == -1 || updatedQuest >= static_cast<int>(
mQuestLinks.size()))
{
updatedQuest = static_cast<int>(mQuestLinks.size() - 1);
}
if (updatedQuest >= 0)
{
mQuestsListBox->setSelected(updatedQuest);
showQuest(mQuestLinks[updatedQuest]);
if (playSound && effectManager)
{
switch (newCompleteStatus)
{
case 0:
effectManager->trigger(mNewQuestEffectId, player_node);
break;
case 1:
effectManager->trigger(mCompleteQuestEffectId,
player_node);
break;
default:
break;
}
}
}
updateEffects();
}
/*!
Sets internal pointers to frequently used QML items, thus reducing the overhead
of repeated searching for them at runtime.
*/
void CcfQmlBaseScenario::init()
{
if (mScenarioFile != "") {
QStringList unitSideList;
QObject *unitsLoader = child("unitsLoader");
QObject *unitItem = unitsLoader->property("unitsItem").value<QObject *>();
QObject *map = child("map");
if (unitItem->objectName() != "Campaign") {
// This is a single scenario
map->set("source", unitItem->getString("mapFile"));
QObjectList tempList = unitItem->children();
for (int i = 0; i < tempList.count(); ++i) {
CcfQmlBaseUnit *unit = ccfUnit(tempList.at(i));
if ((unit != 0) && (unit->property("unitIndex").isValid())) {
unit->setUnitIndex(i);
connect(this, &CcfQmlBaseScenario::togglePause,
unit, &CcfQmlBaseUnit::togglePause);
connect(unit, &CcfQmlBaseUnit::actionFinished,
this, &CcfQmlBaseScenario::actionFinished);
connect(unit, &CcfQmlBaseUnit::movementStateChange,
this, &CcfQmlBaseScenario::handleUnitMovement);
unitSideList.append(unit->getUnitSide());
mUnits.append(unit);
}
}
mMapItem = map->property("mapItem").value<CcfQmlBaseMap *>();
if(mMapItem != 0)
mMapItem->setUnits(mUnits);
else
mlogger->error("MapItem object was not properly initialised",
"Robin Hood is a jerk");
} else {
// This is a campaign
// TODO: add some clever code here ;)
}
mScenarioState->setAvailableSides(unitSideList);
mAimLine = item("aimLine");
mGameArea = item("gameArea");
mZoomArea = item("zoomArea");
mContextMenu = item("contextMenu");
mEffectsTimer = child("effectsTimer");
mRotationTimer = child("rotationTimer");
mFollowingTimer = child("followingTimer");
mMouseAreaMain = child("mouseAreaMain");
mRoster = findChild<CcfQmlBaseRosterMenu *>("roster");
mRoster->populateUnits(mUnits);
connect(mContextMenu, SIGNAL(menuEntryClicked(QString)), this, SLOT(scheduleContextAction(QString)));
connect(mRotationTimer, SIGNAL(triggered()), this, SLOT(updateAimLine()));
connect(mEffectsTimer, SIGNAL(triggered()), this, SLOT(updateEffects()));
connect(mFollowingTimer, SIGNAL(triggered()), this, SLOT(updateFollowingUnit()));
connect(child("sceneUpdateTimer"), SIGNAL(triggered()), this, SLOT(updateUnitVisibility()));
connect(child("rubberBandTimer"), SIGNAL(triggered()), this, SLOT(updateRubberBand()));
hideNonPlayerUnits();
setSideMarks();
}
}
Ogre::Vector3 Animation::runAnimation(float duration)
{
Ogre::Vector3 movement(0.0f);
AnimStateMap::iterator stateiter = mStates.begin();
while(stateiter != mStates.end())
{
AnimState &state = stateiter->second;
const NifOgre::TextKeyMap &textkeys = state.mSource->mTextKeys;
NifOgre::TextKeyMap::const_iterator textkey(textkeys.upper_bound(state.mTime));
float timepassed = duration * state.mSpeedMult;
while(state.mPlaying)
{
float targetTime;
if(state.mTime >= state.mLoopStopTime && state.mLoopCount > 0)
goto handle_loop;
targetTime = state.mTime + timepassed;
if(textkey == textkeys.end() || textkey->first > targetTime)
{
if(mNonAccumCtrl && stateiter->first == mAnimationTimePtr[0]->getAnimName())
updatePosition(state.mTime, targetTime, movement);
state.mTime = std::min(targetTime, state.mStopTime);
}
else
{
if(mNonAccumCtrl && stateiter->first == mAnimationTimePtr[0]->getAnimName())
updatePosition(state.mTime, textkey->first, movement);
state.mTime = textkey->first;
}
state.mPlaying = (state.mTime < state.mStopTime);
timepassed = targetTime - state.mTime;
while(textkey != textkeys.end() && textkey->first <= state.mTime)
{
handleTextKey(state, stateiter->first, textkey);
textkey++;
}
if(state.mTime >= state.mLoopStopTime && state.mLoopCount > 0)
{
handle_loop:
state.mLoopCount--;
state.mTime = state.mLoopStartTime;
state.mPlaying = true;
textkey = textkeys.lower_bound(state.mTime);
while(textkey != textkeys.end() && textkey->first <= state.mTime)
{
handleTextKey(state, stateiter->first, textkey);
textkey++;
}
if(state.mTime >= state.mLoopStopTime)
break;
}
if(timepassed <= 0.0f)
break;
}
if(!state.mPlaying && state.mAutoDisable)
{
mStates.erase(stateiter++);
resetActiveGroups();
}
else
++stateiter;
}
for(size_t i = 0;i < mObjectRoot->mControllers.size();i++)
mObjectRoot->mControllers[i].update();
// Apply group controllers
for(size_t grp = 0;grp < sNumGroups;grp++)
{
const std::string &name = mAnimationTimePtr[grp]->getAnimName();
if(!name.empty() && (stateiter=mStates.find(name)) != mStates.end())
{
const Ogre::SharedPtr<AnimSource> &src = stateiter->second.mSource;
for(size_t i = 0;i < src->mControllers[grp].size();i++)
src->mControllers[grp][i].update();
}
}
if(mSkelBase)
{
// HACK: Dirty the animation state set so that Ogre will apply the
// transformations to entities this skeleton instance is shared with.
mSkelBase->getAllAnimationStates()->_notifyDirty();
}
updateEffects(duration);
return movement;
}
