void Game::onTaskAnswered()
{
bool oldFinished = isFinished();
m_tasksAnswered++;
if(m_currentTask->isCorrect())
m_tasksAnsweredCorrectly++;
emit tasksAnsweredChanged(m_tasksAnswered);
// Adding points
if (getMode()==Mode::DRAG) {
setPoints(getPoints() + m_currentTask->getScore());
}
else {
if(m_currentTask->isCorrect()){
int receivedPoints = 50 * getMultiplier();
setPoints(getPoints() + receivedPoints);
setMultiplier(getMultiplier()+1);
} else {
setMultiplier(1);
}
}
bool newFinished = isFinished();
if(oldFinished != newFinished)emit finishedChanged(newFinished);
}
bool VpGrid::getGridCoord(int *x, int *y)
{
bool status = false;
*x = getXSpacing() * getMultiplier();
*y = getYSpacing() * getMultiplier();
status = true;
return status;
}
void Tribe::onMemberKilled(Creature* member, Creature* attacker) {
CHECK(member->getTribe() == this);
if (attacker == nullptr)
return;
initStanding(attacker);
standing[attacker] -= killPenalty * getMultiplier(member);
for (Tribe* t : enemyTribes)
if (t->diplomatic) {
t->initStanding(attacker);
t->standing[attacker] += killBonus * getMultiplier(member);
}
}
void Tribe::onMemberAttacked(Creature* member, Creature* attacker) {
if (contains(attacks, make_pair(member, attacker)))
return;
attacks.emplace_back(member, attacker);
initStanding(attacker);
standing[attacker] -= attackPenalty * getMultiplier(member);
}
void ECCell::dataChanged() {
const double voltage = dataDouble("voltage");
m_voltageSource.setVoltage(voltage);
QString display = QString::number(voltage / getMultiplier(voltage), 'g', 3) + getNumberMag(voltage) + "V";
setDisplayText("voltage", display);
}
void ECVCVS::dataChanged() {
double gain = dataDouble("gain");
QString display = QString::number(gain / getMultiplier(gain), 'g', 3) + getNumberMag(gain) + QChar(' ');
setDisplayText("gain", display);
m_vcvs.setGain(gain);
}
void Capacitor::dataChanged() {
double capacitance = dataDouble("Capacitance");
QString display = QString::number(capacitance / getMultiplier(capacitance), 'g', 3) + getNumberMag(capacitance) + "F";
setDisplayText("capacitance", display);
m_capacitance.setCapacitance(capacitance);
}
void Tribe::onAttackEvent(Creature* member, Creature* attacker) {
if (member->getTribe() != this)
return;
if (contains(attacks, make_pair(member, attacker)))
return;
attacks.emplace_back(member, attacker);
initStanding(attacker);
standing[attacker] -= attackPenalty * getMultiplier(member);
}
DigitList &
ScientificPrecision::round(DigitList &value, UErrorCode &status) const {
if (U_FAILURE(status)) {
return value;
}
int32_t exponent = value.getScientificExponent(
fMantissa.fMin.getIntDigitCount(), getMultiplier());
return fMantissa.round(value, exponent, status);
}
void ECPotentiometer::dataChanged()
{
m_resistance = dataDouble("resistance");
QString display = QString::number( m_resistance / getMultiplier(m_resistance), 'g', 3 ) + getNumberMag(m_resistance) + QChar(0x3a9);
setDisplayText( "res", display );
sliderValueChanged( "slider", slider("slider")->value() );
}
void ResistorDIP::dataChanged()
{
initPins();
const double resistance = dataDouble("resistance");
for ( int i=0; i<m_resistorCount; ++i )
m_resistance[i]->setResistance(resistance);
const QString display = QString::number( resistance / getMultiplier(resistance), 'g', 3 ) + getNumberMag(resistance) + QChar(0x3a9);
addDisplayText( "res", QRect( offsetX(), offsetY()-16, 32, 12 ), display );
}
void ECCurrentSignal::dataChanged()
{
const double current = dataDouble("1-current");
const double frequency = dataDouble("1-frequency");
QString display = QString::number( current / getMultiplier(current), 'g', 3 ) + getNumberMag(current) + "A";
setDisplayText( "current", display );
m_currentSignal->setStep(ElementSignal::st_sinusoidal, frequency );
m_currentSignal->setCurrent(current);
}
MUserData *ovalLocatorDrawOverride::prepareForDraw (const MDagPath &objPath, const MDagPath &cameraPath, MUserData *oldData) {
#else
MUserData *ovalLocatorDrawOverride::prepareForDraw (const MDagPath &objPath, const MDagPath &cameraPath, const MHWRender::MFrameContext &frameContext, MUserData *oldData) {
#endif
// Retrieve data cache (create if does not exist)
ovalLocatorData *data =dynamic_cast<ovalLocatorData *>(oldData) ;
if ( !data )
data =new ovalLocatorData () ;
// compute data and cache it
data->multiplier =getMultiplier (objPath) ;
return (data) ;
}
/* Spezialtasten-Druck-Callback - wird ausgefuehrt, wenn Spezialtaste
* (F1 - F12, Links, Rechts, Oben, Unten, Bild-Auf, Bild-Ab, Pos1, Ende oder
* Einfuegen) gedrueckt wird */
void cbSpecial (int key, int x, int y)
{
switch (key)
{
case GLUT_KEY_LEFT:
setPixelDistance(getPixelDistance() - PIXEL_DISTANCE_DELTA);
break;
case GLUT_KEY_RIGHT:
setPixelDistance(getPixelDistance() + PIXEL_DISTANCE_DELTA);
break;
case GLUT_KEY_UP:
setMultiplier(getMultiplier() + MULTIPLIER_DELTA);
break;
case GLUT_KEY_DOWN:
setMultiplier(getMultiplier() - MULTIPLIER_DELTA);
break;
case GLUT_KEY_F1:
toggleWireframeMode();
break;
}
}
// Called by Maya each time the object needs to be drawn.
MUserData* FootPrintDrawOverride::prepareForDraw(
const MDagPath& objPath,
const MDagPath& cameraPath,
const MHWRender::MFrameContext& frameContext,
MUserData* oldData)
{
// Any data needed from the Maya dependency graph must be retrieved and cached in this stage.
// There is one cache data for each drawable instance, if it is not desirable to allow Maya to handle data
// caching, simply return null in this method and ignore user data parameter in draw callback method.
// e.g. in this sample, we compute and cache the data for usage later when we create the
// MUIDrawManager to draw footprint in method addUIDrawables().
FootPrintData* data = dynamic_cast<FootPrintData*>(oldData);
if (!data)
{
data = new FootPrintData();
}
float fMultiplier = getMultiplier(objPath);
data->fSoleLineList.clear();
for (int i = 0; i < soleCount; i++)
{
data->fSoleLineList.append(sole[i][0] * fMultiplier, sole[i][1] * fMultiplier, sole[i][2] * fMultiplier);
}
data->fHeelLineList.clear();
for (int i = 0; i < heelCount; i++)
{
data->fHeelLineList.append(heel[i][0] * fMultiplier, heel[i][1] * fMultiplier, heel[i][2] * fMultiplier);
}
data->fSoleTriangleList.clear();
for (int i = 1; i <= soleCount - 2; i++)
{
data->fSoleTriangleList.append(sole[0][0] * fMultiplier, sole[0][1] * fMultiplier, sole[0][2] * fMultiplier);
data->fSoleTriangleList.append(sole[i][0] * fMultiplier, sole[i][1] * fMultiplier, sole[i][2] * fMultiplier);
data->fSoleTriangleList.append(sole[i+1][0] * fMultiplier, sole[i+1][1] * fMultiplier, sole[i+1][2] * fMultiplier);
}
data->fHeelTriangleList.clear();
for (int i = 1; i <= heelCount - 2; i++)
{
data->fHeelTriangleList.append(heel[0][0] * fMultiplier, heel[0][1] * fMultiplier, heel[0][2] * fMultiplier);
data->fHeelTriangleList.append(heel[i][0] * fMultiplier, heel[i][1] * fMultiplier, heel[i][2] * fMultiplier);
data->fHeelTriangleList.append(heel[i+1][0] * fMultiplier, heel[i+1][1] * fMultiplier, heel[i+1][2] * fMultiplier);
}
// get correct color based on the state of object, e.g. active or dormant
data->fColor = MHWRender::MGeometryUtilities::wireframeColor(objPath);
return data;
}
int stringToInt(char *string) {
int size = countStringSize(string) - 1;
int sum = 0;
for(int index = 0; size > 0; index++) {
int muptilpier = getMultiplier(--size);
int digit = string[index] - '0';
sum += digit * muptilpier;
}
return sum;
}
MBoundingBox FootPrintDrawOverride::boundingBox(
const MDagPath& objPath,
const MDagPath& cameraPath) const
{
MPoint corner1( -0.17, 0.0, -0.7 );
MPoint corner2( 0.17, 0.0, 0.3 );
float multiplier = getMultiplier(objPath);
corner1 = corner1 * multiplier;
corner2 = corner2 * multiplier;
return MBoundingBox( corner1, corner2 );
}
void VariableCapacitor::sliderValueChanged(const QString &id, int newValue) {
if (id != "slider") return;
/** @todo fix slider so current cap can be set in toolbar and editor and slider updates */
m_currCapacitance = m_minCapacitance + (newValue * m_tickValue);
// Set the new capacitance value.
m_pCapacitance.setCapacitance(m_currCapacitance);
// Update property.
property("currcapacitance")->setValue(m_currCapacitance);
QString display = QString::number(m_currCapacitance / getMultiplier(m_currCapacitance), 'g', 3)
+ getNumberMag(m_currCapacitance) + "F";
setDisplayText("capacitance", display);
}
void drawAttributes(void) {
GLfloat textColor[3] = { 1.0f, 1.0f, 1.0f };
char * string1 = calloc ((strlen ("Range = ") + 4), sizeof(char));
char * string2 = calloc ((strlen ("Multiplier = ") + 4), sizeof(char));
char * string3 = calloc ((strlen ("PixelDist = ") + 4), sizeof(char));
sprintf(string1, "Range = %d", getRange());
sprintf(string2, "Multiplier = %f", getMultiplier());
sprintf(string3, "PixelDist = %d", getPixelDistance());
drawString (0.6, 0.13, textColor, string1);
drawString (0.6, 0.16, textColor, string2);
drawString (0.6, 0.19, textColor, string3);
free (string1);
free (string2);
free (string3);
}
HSPToken *expectInteger32(HSP *sp, HSPToken *tok, uint32_t *arg, uint32_t minVal, uint32_t maxVal)
{
HSPToken *t = tok;
t = t->nxt;
if(t == NULL || !isdigit(t->str[0])) {
parseError(sp, tok, "expected integer", "");
return NULL;
}
char *str = my_strdup(t->str); // take a copy so we can modify it
uint32_t mult = getMultiplier(str);
*arg = (mult * strtol(str, NULL, 0));
my_free(str);
if(*arg < minVal || *arg > maxVal) {
parseError(sp, tok, "range error", "");
return NULL;
}
return t;
}
/*
* Does an action against a target, allows the user to choose which ability is used
*/
void Protagonist::doAction(Character *target) {
string inputAbilityName;
set<string> abilityNames = getAbilityNames();
do {
cout << "Choose an attack (current energy is " << getEnergy() << ")\n";
printAbilities();
cin >> inputAbilityName;
} while (!isStringInSetIgnoreCase(inputAbilityName, abilityNames));
Ability inputAbility = getAbilityFromName(inputAbilityName);
cout << getName() << " used " << inputAbilityName << "\n";
double multiplier = getMultiplier(inputAbility.getType(),
target->getType());
inputAbility.doAbility(this, target, multiplier);
}
static long long trainClient( Competitor& client, std::vector< ObjectiveFn >& p ) {
const long long startTime = system_current_time_millis();
// const long long maxTime = getTrainingTimeInMillis( client.getTrainingCategory() );
const long maxTime = BASE_TIME_PER_INSTANCE_IN_MILLIS * p.size() * getMultiplier( client.getTrainingCategory() );
trainingEndTime() = startTime + maxTime;
try {
client.train( p, maxTime );
}
catch( EvaluationsExceededException& ) {
// Intentionally empty
}
catch( TimeExceededException& ) {
// Intentionally empty
}
const long long endTime = system_current_time_millis();
return endTime - startTime;
}
/**
* Zeichen-Callback.
* Loescht die Buffer, ruft das Zeichnen der Szene auf und tauscht den Front-
* und Backbuffer.
*/
static void
cbDisplay (void)
{
int toX = G_fullScreen ? G_Width : G_Width/2,
toZ = G_fullScreen ? G_Height : G_Height/2;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.0, 1.0, 1.0, 0.0);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (!getHelpStatus()) {
/*==================================================================*/
/* Textur mit Kamera-Perspektive */
/*==================================================================*/
drawSceneToTexture(G_fboCam, getCameraPosition(0), getCameraPosition(1), getCameraPosition(2), 0.0, 0.0, 0.0);
/*==================================================================*/
/* Terrain mit Ambient Occlusion. */
/*==================================================================*/
glUseProgram(G_ShaderID);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport (0, 0, toX, toZ);
setProjection (1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt (getCameraPosition(0), getCameraPosition(1), getCameraPosition(2),
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, G_TexCamera);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, G_TexCameraDepth);
GLfloat mp[16], mv[16];
glGetFloatv(GL_PROJECTION_MATRIX, mp);
glGetFloatv(GL_MODELVIEW_MATRIX, mv);
glUniformMatrix4fv(glGetUniformLocation(G_ShaderID, "projMatrix"), 1, GL_FALSE, &mp[0]);
glUniformMatrix4fv(glGetUniformLocation(G_ShaderID, "viewMatrix"), 1, GL_FALSE, &mv[0]);
glUniform1i(G_sampler2dLoc, 1);
glUniform1i(G_samplerDepth2dLoc, 0);
GLuint showTexture[] = {G_showTexture};
glUniform1iv(glGetUniformLocation(G_ShaderID, "showTexture"), 1, showTexture);
GLuint screenWidth[] = {G_Width};
glUniform1iv(glGetUniformLocation(G_ShaderID, "screenWidth"), 1, screenWidth);
GLuint screenHeight[] = {G_Height};
glUniform1iv(glGetUniformLocation(G_ShaderID, "screenHeight"), 1, screenHeight);
GLfloat nearPlane[] = {G_NearPlane};
glUniform1fv(glGetUniformLocation(G_ShaderID, "nearPlane"), 1, nearPlane);
GLfloat farPlane[] = {G_FarPlane};
glUniform1fv(glGetUniformLocation(G_ShaderID, "farPlane"), 1, farPlane);
GLuint range[] = {getRange()};
glUniform1iv(glGetUniformLocation(G_ShaderID, "range"), 1, range);
GLuint pixelDistance[] = {getPixelDistance()};
glUniform1iv(glGetUniformLocation(G_ShaderID, "pixelDistance"), 1, pixelDistance);
GLfloat multiplier[] = {getMultiplier()};
glUniform1fv(glGetUniformLocation(G_ShaderID, "multiplier"), 1, multiplier);
glBindBuffer (GL_ARRAY_BUFFER, G_WaterBuffer);
glBufferData (GL_ARRAY_BUFFER, sizeof(*getWaterList())*WORLD_SIZE*WORLD_SIZE, getWaterList(), GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(GLfloat)+1*sizeof(GLint), 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, G_WaterBufferIndex);
/* Wasser. */
glDrawElements(GL_TRIANGLES, WORLD_SIZE*WORLD_SIZE*2*3, GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glUseProgram(0);
drawFPS();
drawAttributes();
} else {
printHelp();
}
/* Alles fertig. */
glutSwapBuffers ();
}
int32_t
ScientificPrecision::toScientific(DigitList &value) const {
return value.toScientific(
fMantissa.fMin.getIntDigitCount(), getMultiplier());
}
void Delay::dataChanged()
{
double delay = dataDouble("delay_length");
setCaption( i18n("Delay for %1 sec").arg(QString::number( delay / getMultiplier(delay), 'g', 3 )+getNumberMag(delay)) );
}
int Item::getNumberPre( double num )
{
return (int)(num/getMultiplier(num));
}
MBoundingBox ovalLocatorDrawOverride::boundingBox (const MDagPath &objPath, const MDagPath &cameraPath) const {
float multiplier =getMultiplier (objPath) ;
return (ovalLocator::boundingbox (multiplier)) ;
}
