//returns true if ready to be removed
PRIVATE bool _fxSmokeUpdate(fxSmoke *mainDat, fxSmoke_par *theSmoke)
{
double t = TimeGetTime(&theSmoke->delayTimer)/TimeGetDelay(&theSmoke->delayTimer);
//moving
if(!theSmoke->bFading)
{
if(t <= 1)
{
theSmoke->loc[eX] = theSmoke->sLoc[eX] + t*(theSmoke->eLoc[eX]-theSmoke->sLoc[eX]);
theSmoke->loc[eY] = theSmoke->sLoc[eY] + t*(theSmoke->eLoc[eY]-theSmoke->sLoc[eY]);
theSmoke->loc[eZ] = theSmoke->sLoc[eZ] + t*(theSmoke->eLoc[eZ]-theSmoke->sLoc[eZ]);
theSmoke->clr[eA] = t;
}
else
{
//initialize fading
theSmoke->bFading = true;
TimeInit(&theSmoke->delayTimer, mainDat->fadeDelay);
TimeReset(&theSmoke->delayTimer);
}
}
//fading
else
{
if(t <= 1)
theSmoke->clr[eA] = 1.0f - t;
else //we are done
return true;
}
return false;
}
RETCODE StatusInvulnerable::Update()
{
RETCODE ret = RETCODE_SUCCESS;
Creature *pCre = (Creature *)IDPageQuery(m_owner);
if(pCre)
{
hOBJ obj = pCre->GetOBJ(); assert(obj);
double t = TimeGetTime(&m_fadeDelay)/TimeGetDelay(&m_fadeDelay);
if(t >= 1)
{
t = 1;
TimeReset(&m_fadeDelay);
m_bFading = !m_bFading;
}
OBJSetAlpha(obj, m_bFading ? 1-t : t);
//invulnerable over?
if(TimeElapse(&m_invulDelay))
{
OBJSetAlpha(obj, 1);
ret = RETCODE_STATUS_DONE;
}
}
else
ret = RETCODE_STATUS_DONE;
return ret;
}
void watchNotAus(void) //Notaus wenn Taste gedrückt oder Fernsteueung ausgefallen
{
if((PIND & (1<<IxNotAus)) || ((RemoteSignalTest(RemoteStatus) & (1<<Fail))) || ((RemoteValue[5] < 140) && (RemoteValue[2] > 240)))
{
PORTB &= ~(1<<Qx_GenEin); //Fremderregung am Generator ausschalten
PORTB &= ~(1<<Qx_MLP_GenOK); //Generatorlampe ausschalten
OCR1AL = 0x00; //Traktion ausschalten links
OCR1BL = 0x00; //Traktion ausschalten rechts
while((PIND & (1<<IxNotAus)) || ((RemoteSignalTest(RemoteStatus) & (1<<Fail))) || ((RemoteValue[5] < 140) && (RemoteValue[2] > 235))) //Wenn und Solange Notaus betätigt oder Fernst aus
{
PORTD |= (1<<Qx_MLP_Stoer); //Störlampe einschalten
PORTD &= ~(1<<Qx_BenzMotEin); //Benzinmotor ausschalten
startRemoteIn();
}
while(!(PINB & (1<<IxEntpan))) //Wenn NotAus normalisiert warten bis Enpannen gedrückt
{
if(TimeCheck(halfsnd) >= 0b00000001) //Störlampe blinken lassen mit ca. 1Hz
{
TimeReset(halfsnd);
PORTD ^= (1<<Qx_MLP_Stoer);
}
}
PORTD &= ~(1<<Qx_MLP_Stoer); //Störlampe ausschalten falls noch brennt
if(operatingstates & (1<<warmstart)) //Wenn der Motor schonmal gelaufen
{
engineStart(); //Motorstart einleiten
} //Beim Kaltstart wird die Prozedur von Main-Loop aufgerufen
}
}
void engineStart(void)
{
stopFahrmot(); //Fahrmotoren abschalten
PORTD |= (1<<Qx_BenzMotEin); //Zündung freigeben
while(!(PINB & (1<<IxGenStart))) //Warten bis Motor läuft
{
watchNotAus(); //Schauen ob Notaus anliegt
if(TimeCheck(halfsnd) >= 0b00000001) //Generatorlampe blinken lassen mit ca. 1Hz
{
TimeReset(halfsnd); //Halbsekundenverzögerung auf Null setzen
PORTB ^= (1<<Qx_MLP_GenOK);
}
}
PORTB |= (1<<Qx_GenEin); //Fremderregung am Generator einschalten
PORTB |= (1<<Qx_MLP_GenOK); //Generatorlampe dauernd einschalten
TimeReset(fullsnd); //Sekundenverzögerung Null setzen
while(!(TimeCheck(fullsnd) >= 0b00000010)) //1 Sekunde warten
{
watchNotAus(); //Währenddessen NotAus kontrollieren
}
//Ab hier geändert dass ständig erregung... 11.01.2014
//Normalisieren: Auskommentiertes rausnehmen, nächste if bedingnung wegnehmen und lampe immer löschen lassen!!!
/*while(!(PINB & (1<<IxLadekon))) //Wenn Generator bis dahin nicht angesprungen weiter warten
{
watchNotAus(); //Währenddessen NotAus kontrollieren
}
*/PORTB &= ~(1<<Qx_GenEin); //Fremderregung am Generator ausschalten
if(!(PINB & (1<<IxLadekon)))
{
PORTB &= ~(1<<Qx_MLP_GenOK); //Generatorlampe dauernd ausschalten
}
}
void lamptest(void)
{
TimeReset(doublesnd); //Zweisekundenverzögerung Null setzen
while(!(TimeCheck(doublesnd) >= 0b00000100))
{
PORTB |= (1<<Qx_MLP_GenOK); //Generatorlampe einschalten
PORTD |= (1<<Qx_MLP_Stoer); //Störungslampe einschalten
}
PORTB &= ~(1<<Qx_MLP_GenOK); //Generatorlampe ausschalten
PORTD &= ~(1<<Qx_MLP_Stoer); //Störungslampe ausschalten
}
RETCODE StatusTeleport::Update()
{
RETCODE ret = RETCODE_SUCCESS;
Creature *pCre = (Creature *)IDPageQuery(m_owner);
if(m_bGO)
{
if(pCre)
{
hOBJ obj = pCre->GetOBJ(); assert(obj);
double t = TimeGetTime(&m_delay)/TimeGetDelay(&m_delay);
if(t >= 1)
{
t = 1;
TimeReset(&m_delay);
}
OBJSetAlpha(obj, m_bFading ? 1-t : t);
//are we done?
if(t == 1 && !m_bFading)
ret = RETCODE_STATUS_DONE;
else if(t == 1 && m_bFading)
{
m_bFading = false;
//set to new location
pCre->SetLoc(m_dest);
D3DXVECTOR3 zeroVel(0,0,0);
pCre->SetVel(zeroVel);
pCre->CREPlaySound(38);
}
}
else
ret = RETCODE_STATUS_DONE;
}
return ret;
}
PROTECTED RETCODE fxLightningYFunc(hPARFX thisPARFX, DWORD message, LPARAM dumbParam, WPARAM otherParam)
{
fxLightningY *thisData = (fxLightningY *)thisPARFX->data;
switch(message)
{
case PARFXM_UPDATE:
{
double t = TimeGetTime(&thisData->onTimer)/TimeGetDelay(&thisData->onTimer);
if(t > 1){ t = 1; TimeReset(&thisData->onTimer); }
//update alpha
if(thisData->clr[eA] < 1
&& dumbParam != PARFX_UPDATE_DEAD)
{
thisData->clr[eA] = t;
if(thisData->clr[eA] == 1)
{
TimeReset(&thisData->onTimer);
}
}
else if(thisData->clr[eA] > 0
&& dumbParam == PARFX_UPDATE_DEAD)
{
thisData->clr[eA] = 1.0f - t;
if(thisData->clr[eA] == 0)
{
TimeReset(&thisData->onTimer);
}
}
/////////////////////////////////////////////////////////////////
//update nodes
float trans[eMaxPt] = {0};
hOBJ obj = PARFXGetOBJ(thisPARFX);
if(obj)
{
PARFXGetOBJLoc(thisPARFX, obj, trans);
}
for(int i = 0; i < thisData->numNodes; i++)
{
t = TimeGetTime(&thisData->Nodes[i].timeMove)/TimeGetDelay(&thisData->Nodes[i].timeMove);
if(t > 1) t = 1;
thisData->Nodes[i].curLoc[eX] = thisData->Nodes[i].sLoc[eX] + t*(thisData->Nodes[i].eLoc[eX] - thisData->Nodes[i].sLoc[eX]);
thisData->Nodes[i].curLoc[eZ] = thisData->Nodes[i].sLoc[eZ] + t*(thisData->Nodes[i].eLoc[eZ] - thisData->Nodes[i].sLoc[eZ]);
if(t == 1)
{
TimeReset(&thisData->Nodes[i].timeMove);
//our new start
memcpy(thisData->Nodes[i].sLoc, thisData->Nodes[i].curLoc, sizeof(thisData->Nodes[i].sLoc));
//our new end
thisData->Nodes[i].eLoc[eX] = _GFXMathRand(thisData->min[eX], thisData->max[eX]) + trans[eX];
thisData->Nodes[i].eLoc[eY] = thisData->min[eY] + ((float)i/(float)thisData->numNodes)*(thisData->max[eY] - thisData->min[eY]) + trans[eY];
thisData->Nodes[i].eLoc[eZ] = _GFXMathRand(thisData->min[eZ], thisData->max[eZ]) + trans[eZ];
}
}
if(thisData->clr[eA] == 0 && dumbParam == PARFX_UPDATE_DEAD)
{
return RETCODE_BREAK;
}
}
break;
case PARFXM_DISPLAY:
if(FrustrumCheckBox(
thisData->min[eX], thisData->min[eY], thisData->min[eZ],
thisData->max[eX], thisData->max[eY], thisData->max[eZ]))
{
float t = 0, max=thisData->maxParticle;
D3DXVECTOR3 ptOut, pt0, pt1, pt2, pt3;
float particleCount=0;
int prevInd=0, ind=0, nextInd=1, next2Ind=2;
do
{
memcpy((float*)pt0, thisData->Nodes[prevInd].curLoc, sizeof(thisData->Nodes[prevInd].curLoc));
memcpy((float*)pt1, thisData->Nodes[ind].curLoc, sizeof(thisData->Nodes[ind].curLoc));
memcpy((float*)pt2, thisData->Nodes[nextInd].curLoc, sizeof(thisData->Nodes[nextInd].curLoc));
memcpy((float*)pt3, thisData->Nodes[next2Ind].curLoc, sizeof(thisData->Nodes[next2Ind].curLoc));
//cat-mull-rom curve magic
D3DXVec3CatmullRom(&ptOut, &pt0, &pt1, &pt2, &pt3, t);
//draw the darn thing
TextureBltBillboard(thisData->lightningTxt, (float*)ptOut, thisData->scale, thisData->clr);
particleCount++;
t = particleCount/max;
if(t > 1)
{
ind++;
particleCount = 0;
t = 0;
}
prevInd = ind - 1; if(prevInd < 0) prevInd = 0;
nextInd = ind + 1; if(nextInd >= thisData->numNodes) nextInd = thisData->numNodes-1;
next2Ind = ind + 2; if(next2Ind >= thisData->numNodes) next2Ind = thisData->numNodes-1;
} while(ind < thisData->numNodes);
}
break;
case PARFXM_CREATE:
{
fxLightningY_init *initDat = (fxLightningY_init *)dumbParam;
fxLightningY *newData = (fxLightningY *)GFX_MALLOC(sizeof(fxLightningY));
if(!newData)
return RETCODE_FAILURE;
newData->lightningTxt = initDat->lightningTxt; TextureAddRef(newData->lightningTxt);
newData->clr[eR] = initDat->r/255.0f;
newData->clr[eG] = initDat->g/255.0f;
newData->clr[eB] = initDat->b/255.0f;
newData->clr[eA] = 0;
newData->scale = initDat->scale;
memcpy(newData->min, initDat->min, sizeof(newData->min));
memcpy(newData->max, initDat->max, sizeof(newData->max));
newData->maxParticle = 20;//initDat->maxParticle;
TimeInit(&newData->onTimer, initDat->delayOn);
TimeReset(&newData->onTimer);
newData->delayMove = initDat->delayMove;
newData->numNodes = initDat->maxPoint;
newData->Nodes = (lightningNode *)GFX_MALLOC(sizeof(lightningNode)*newData->numNodes);
if(!newData->Nodes)
return RETCODE_FAILURE;
////////////////////////////////////////////////////////////////
//initialize the nodes
float trans[eMaxPt] = {0};
hOBJ obj = PARFXGetOBJ(thisPARFX);
if(obj)
{
PARFXGetOBJLoc(thisPARFX, obj, trans);
}
for(int i = 0; i < newData->numNodes; i++)
{
newData->Nodes[i].sLoc[eX] = _GFXMathRand(newData->min[eX], newData->max[eX]) + trans[eX];
newData->Nodes[i].sLoc[eY] = newData->min[eY] + ((float)i/(float)newData->numNodes)*(newData->max[eY] - newData->min[eY]) + trans[eY];
newData->Nodes[i].sLoc[eZ] = _GFXMathRand(newData->min[eZ], newData->max[eZ]) + trans[eZ];
memcpy(newData->Nodes[i].curLoc, newData->Nodes[i].sLoc, sizeof(newData->Nodes[i].curLoc));
newData->Nodes[i].eLoc[eX] = _GFXMathRand(newData->min[eX], newData->max[eX]) + trans[eX];
newData->Nodes[i].eLoc[eY] = newData->min[eY] + ((float)i/(float)newData->numNodes)*(newData->max[eY] - newData->min[eY]) + trans[eY];
newData->Nodes[i].eLoc[eZ] = _GFXMathRand(newData->min[eZ], newData->max[eZ]) + trans[eZ];
TimeInit(&newData->Nodes[i].timeMove, newData->delayMove);
}
thisPARFX->data = newData;
}
break;
case PARFXM_DESTROY:
{
if(thisData)
{
if(thisData->Nodes)
GFX_FREE(thisData->Nodes);
if(thisData->lightningTxt)
TextureDestroy(&thisData->lightningTxt);
}
}
break;
}
return RETCODE_SUCCESS;
}
int MTButton3D::Callback(unsigned int msg, unsigned int wParam, int lParam)
{
switch(msg)
{
case MENU_ITM_MSG_UPDATE:
{
bool bDone = false;
D3DXVECTOR3 curLoc; OBJGetLoc(m_btnOBJ, (float*)curLoc);
switch(wParam)
{
case MITM_UPDATE_NORMAL:
break;
case MITM_UPDATE_ENTERING:
{
float alpha;
double t = TimeGetTime(&m_delay)/TimeGetDelay(&m_delay);
if(t >= 1)
{
t = 1;
bDone = true;
}
D3DXVec3Lerp(&curLoc, &m_startLoc, &m_endLoc, t);
alpha = m_startAlpha + t*(m_endAlpha - m_startAlpha);
OBJTranslate(m_btnOBJ, (float*)curLoc, false);
OBJSetAlpha(m_btnOBJ, alpha);
}
break;
case MITM_UPDATE_EXITING:
{
float alpha;
double t = TimeGetTime(&m_delay)/TimeGetDelay(&m_delay);
if(t >= 1)
{
t = 1;
bDone = true;
}
D3DXVec3Lerp(&curLoc, &m_endLoc, &m_startLoc, t);
alpha = m_endAlpha + t*(m_startAlpha - m_endAlpha);
OBJTranslate(m_btnOBJ, (float*)curLoc, false);
OBJSetAlpha(m_btnOBJ, alpha);
}
break;
}
OBJUpdateFrame(m_btnOBJ);
if(bDone)
return RETCODE_BREAK;
}
break;
case MENU_ITM_MSG_DRAW:
OBJDisplay(m_btnOBJ);
break;
case MENU_ITM_MSG_SELECT:
if(wParam)
{
OBJSetState(m_btnOBJ, BUTTON3D_ANIM_SELECT);
}
else
{
OBJSetState(m_btnOBJ, BUTTON3D_ANIM_UNSELECT);
}
break;
case MENU_ITM_MSG_ACTIVATE:
break;
case MENU_ITM_MSG_STATECHANGE:
TimeReset(&m_delay);
break;
}
return RETCODE_SUCCESS;
}
/////////////////////////////////////
// Name:
// Purpose:
// Output:
// Return:
/////////////////////////////////////
PUBLIC RETCODE OBJUpdateFrame(hOBJ obj)
{
//create the world matrix
_GFXCreateWrld(&obj->wrldMtx);
if(!TESTFLAGS(obj->status, OBJ_PAUSE))
{
if(obj->states)
{
//there can either be keyframes or joints,
//we cannot have both!
//if there are key frames...
if(TESTFLAGS(obj->theMdl->status, MDL_FRAME))
{
double time = TimeGetTime(&obj->ticker)*obj->animeScale;
if(obj->states[obj->curState].delay > 0)
time /= obj->states[obj->curState].delay;
else
time = 0;
//time *= obj->animeScale;
//advance to next frame if we reach 1
while(time >= 1)
{
TimeReset(&obj->ticker);
obj->prevFrame = obj->curFrame;
obj->curFrame++;
if(obj->curFrame > obj->states[obj->curState].endFrame)
{
if(TESTFLAGS(obj->status, OBJ_PAUSE_ON_END))
{ OBJPause(obj, true); obj->curFrame = obj->states[obj->curState].endFrame; }
else
obj->curFrame = obj->states[obj->curState].startFrame;
}
time -= 1;
}
MeshInterpolate(&obj->theMdl->frames[obj->prevFrame].frameMesh,
&obj->theMdl->frames[obj->curFrame].frameMesh,
time, obj->curMesh);
}
//otherwise, if there are joints...
else if(TESTFLAGS(obj->theMdl->status, MDL_JOINT))
{
double time = TimeGetTime(&obj->ticker)*obj->animeScale;
if(obj->states[obj->curState].delay > 0)
time /= obj->states[obj->curState].delay;
else
time = 0;
//time *= obj->animeScale;
//advance to next frame if we reach 1
while(time >= 1)
{
TimeReset(&obj->ticker);
obj->prevFrame = obj->curFrame;
obj->curFrame++;
if(obj->curFrame > obj->states[obj->curState].endFrame)
{
if(TESTFLAGS(obj->status, OBJ_PAUSE_ON_END))
{
SETFLAG(obj->status, OBJ_PAUSE);
obj->curFrame = obj->states[obj->curState].endFrame;
time=0;
break;
}
else
{
obj->curFrame = obj->states[obj->curState].startFrame;
}
}
time -= 1;
}
//interpolate joint
if(TESTFLAGS(obj->status, OBJ_CHILD))
{
hOBJ parent = OBJQuery(&obj->parentKey);
JointInterpolate(obj->joints,
obj->theMdl->joints,
obj->theMdl->numJoints, time,
obj->theMdl->numFrames, obj->prevFrame, obj->curFrame,
parent ? parent->joints : 0, obj->parentJointInd);
}
else
{
JointInterpolate(obj->joints,
obj->theMdl->joints,
obj->theMdl->numJoints, time,
obj->theMdl->numFrames, obj->prevFrame, obj->curFrame);
}
//MeshTranslateVtxJoint(obj->curMesh, obj->joints);
}
}
//go through the children and update them...
for(LISTPTR::iterator i = obj->objNode->begin(); i != obj->objNode->end(); ++i)
OBJUpdateFrame((hOBJ)(*i));
}
return RETCODE_SUCCESS;
}
int Geyser::Callback(unsigned int msg, unsigned int wParam, int lParam)
{
switch(msg)
{
case ENTITYMSG_UPDATE:
{
EntityCommon *pEntity;
D3DXVECTOR3 v;
float spd = m_upSpd.MoveUpdate(g_timeElapse);
for(list<Id>::iterator i = m_entities.begin(); i != m_entities.end(); i++)
{
pEntity = (EntityCommon*)IDPageQuery(*i);
if(pEntity)
{
v = pEntity->GetVel();
v.y = spd;
pEntity->SetVel(v);
}
}
m_entities.clear();
if(!m_bAlwaysActive)
{
if(m_bInActive)
{
if(TimeElapse(&m_deactiveDelay))
{
m_bInActive = false;
TimeReset(&m_activeDelay);
if(m_particle)
PARFXActivate(m_particle, true);
}
}
else
{
if(TimeElapse(&m_activeDelay))
{
m_bInActive = true;
TimeReset(&m_deactiveDelay);
if(m_particle)
PARFXActivate(m_particle, false);
}
}
}
}
break;
case ENTITYMSG_ENTITYCOLLIDE:
{
if(!m_bInActive)
{
EntityCommon *pEntity = (EntityCommon *)wParam;
//check to see if already in list
bool bAdd = true;
for(list<Id>::iterator i = m_entities.begin(); i != m_entities.end(); i++)
{
if(GAME_IDISEQUAL(*i, pEntity->GetID()))
{
bAdd = false;
break;
}
}
if(bAdd)
m_entities.push_back(pEntity->GetID());
}
}
break;
case ENTITYMSG_ALLOWGRAVITY:
//simply don't allow gravity
return 0;
}
return RETCODE_SUCCESS;
}
