void Base_Effect1_base_event3(PARTICLE* p) {
if(p.lifespan <= 40.000 || (p.skill_a & 1)) {
p.skill_a |= 1;
p.vel_z = -8.000;
p.skill_z = p.vel_z;
}
if(p.alpha < 0 || p.size < 0) p.lifespan = 0;
p.vel_x = sinv(p.skill_d*3.6+180)*p.skill_x;
p.vel_y = cosv(p.skill_d*3.6)*p.skill_y;
p.vel_z = p.skill_z;
if(p.creator)vec_rotate(p.vel_x,p.creator.pan);
p.skill_d = (p.skill_d + time_step*(var)11.000)%100;
}
void item_loop()
{
my->emask |= ENABLE_TRIGGER;
my->trigger_range = 30;
set (me, PASSABLE);
my->pan = random(360);
var vZ = my->z;
var vOffset = random(500);
var vParticles = 0;
if (c_trace(&my->x, vector(my->x, my->y, my->z - 1000), IGNORE_ME | IGNORE_PASSABLE) > 0)
{
my->z = hit->z + ITEM_HEIGHT;
}
while(player == NULL)
{
wait(1);
}
while(!is(me, is_collected))
{
if (dayOrNight == DAY && vec_dist(&player->x, &my->x) < 1000)
{
vParticles += time_step;
while (vParticles > 1)
{
effect(item_particle, 1, &my->x, nullvector);
vParticles -= 1;
}
my->z = vZ + 10 * sinv(total_ticks * 20 + vOffset);
my->pan -= 5 * time_step;
reset(my, INVISIBLE);
my->emask |= ENABLE_TRIGGER;
}
else
{
set(my, INVISIBLE);
my->emask &= ~ENABLE_TRIGGER;
}
wait(1);
}
item_fade();
}
void WahbaRotM(float acc[3], float gyr[3], float mag[3], WahbaRotMStruct *WStruct) {
static float a, g, ga, gm, m, A[3][3], dt;
real (*RotM)[3];
a = WStruct->sun_sensor_gain;
m = 1;
g = 0.0;
ga = 1 - a;
gm = 1 - m;
static float AccErr, *w_a, *w_g, *w_m, *g_va, *g_vm; //,*g_vg;
w_a = WStruct->w_a;
w_g = WStruct->w_g;
w_m = WStruct->w_m;
RotM = WStruct->RotM;
g_va = WStruct->g_va;
//g_vg=WStruct->g_vg;
g_vm = WStruct->g_vm;
dt = WStruct->dt;
static real Rbe[3][3];
real accn[3], magn[3], An, Mn;
An = normV(acc);
if (An == 0) { An = 1; }
Mn = normV(mag);
if (Mn == 0) { Mn = 1; }
for (int i = 0; i < 3; i++) {
accn[i] = acc[i] / An;
magn[i] = mag[i] / Mn;
}
for (int i = 0; i < 3; i++) {
A[i][0] = a * accn[0] * w_a[i] + m * magn[0] * w_m[i]
+ ga * g_va[0] * w_a[i] + gm * g_vm[0] * w_m[i];
A[i][1] = a * accn[1] * w_a[i] + m * magn[1] * w_m[i]
+ ga * g_va[1] * w_a[i] + gm * g_vm[1] * w_m[i];
A[i][2] = a * accn[2] * w_a[i] + m * magn[2] * w_m[i]
+ ga * g_va[2] * w_a[i] + gm * g_vm[2] * w_m[i];
}
// for(int i=0;i<3;i++){
// A[i][0]=a*accn[0]*w_a[i] + m*magn[0]*w_m[i];
// A[i][1]=a*accn[1]*w_a[i] + m*magn[1]*w_m[i];
// A[i][2]=a*accn[2]*w_a[i] + m*magn[2]*w_m[i];
// }
// real A1[3][3]={{1.21,3.214,0.1},{0,0,0},{2.12,0.120,0.43}};
//real A1[3][3]={{1.001,2,3},{0,0,0},{2,4,6}}; //check svd
WahbaJacobiSVDRotM(A, RotM);
dRpropagat(Rbe, RotM, gyr, dt);
// mulMatrTrVec(w_m,Rbe,magn);
// w_m[0]=sqrtv(w_m[0]*w_m[0]+w_m[1]*w_m[1]);
// w_m[1]=0;
mulMatrVec(g_va, Rbe, w_a);
mulMatrVec(g_vm, Rbe, w_m);
//mulMatr(Rr,RtM,Rbe);
//Conversion to euler takes 7-8us...
rotmtx2euler((const float *) RotM, (float *) WStruct->Euler);
rotmtx2quat((const float *) RotM, (Quat4 *) WStruct->q);
// Calculate W from dR
static real tmp;
static real tr;
mulMatrMatrTr(WStruct->dR, RotM, WStruct->RotM_prev);
tr = ((WStruct->dR[0][0] + WStruct->dR[1][1] + WStruct->dR[2][2]) - 1.0) / 2.0;
tr = SATUR(tr, 1);
tmp = acosv(tr);
WStruct->dth = tmp;
if (fabsv(tmp) < TOL) {
tmp = 0.5 / dt; // x/sin(x)|x->0
} else {
tmp = 0.5 / dt * tmp / sinv(tmp);
}
WStruct->W[0] = tmp * (WStruct->dR[2][1] - WStruct->dR[1][2]);
WStruct->W[1] = tmp * (WStruct->dR[0][2] - WStruct->dR[2][0]);
WStruct->W[2] = tmp * (WStruct->dR[1][0] - WStruct->dR[0][1]);
for (int i = 0; i < 3; i++) {
WStruct->RotM_prev[0][i] = RotM[0][i];
WStruct->RotM_prev[1][i] = RotM[1][i];
WStruct->RotM_prev[2][i] = RotM[2][i];
}
}
////////////////////////////////////////////////////////////
// Spiral
////////////////////////////////////////////////////////////
void New_Base_Effect_base_event(PARTICLE* p) {
p.vel_x = sinv(p.skill_d*3.6+180)*p.skill_x;
p.vel_y = cosv(p.skill_d*3.6)*p.skill_y;
p.vel_z = p.skill_z;
p.skill_d = (p.skill_d + time_step*(var)6.000)%100;
}
void startGame()
{
reset_hints();
endMenu();
wait(1);
level_load("mainLevel.wmb");
// level_load("menuLevel2.wmb");
//wait(1); // wait until last_error becomes valid
on_esc = NULL;
gameCameraInit();
startIngameGUI();
playMusicGameDay();
startSnow();
// Start a new day
dayOrNight = DAY;
dayTime = 28800;
hut_restart();
item_restart();
show_dayhint();
set(mtl_model, PASS_SOLID);
random_seed(8);
VECTOR tempVector;
int i;
for(i = 0; i < 100; i++)
{
vec_set(tempVector, vector(random(6400)-3200, random(6400)-3200, 0));
if(vec_length(tempVector) < 800)
{
i--;
continue;
}
tempVector.z = 5000;
tempVector.z -= c_trace(tempVector, vector(tempVector.x, tempVector.y, -5000), SCAN_TEXTURE|IGNORE_PASSABLE|IGNORE_FLAG2);
if(hit.nz < 0.5)
{
i--;
continue;
}
// ENTITY *tree = ent_create("pine_3.mdl", tempVector, 0);
ENTITY *tree = ent_create("pine_3_reduced.mdl", tempVector, 0);
set(tree, PASSABLE|SHADOW);
vec_scale(tree.scale_x, random(0.5) + 0.5);
tree.pan = random(360);
tree->emask &= ~DYNAMIC;
}
random_seed(0);
pssm_run(4);
wait(1); // f*****g wait(1) seems to fix something which breaks everything
var sunlightFactor = 0;
var dayCounter = 0;
while(isGameOver < 2)
{
if (isGameOver == 0)
{
updateGui();
goblin_loop();
item_spawn_loop();
dayTime += DAY_TIME_SPEED * time_step * 1;
if(dayTime >= 86400)
{
dayTime -= 86400;
dayCounter += 1;
goblinSpawnDelay = maxv(16.0*3.0-dayCounter*2, 1);
}
hours = integer(dayTime/60.0/60.0);
minutes = (integer(dayTime)-hours*60.0*60.0)/60.0;
sunlightFactor = sinv((dayTime-28800.0)/(60.0*60.0*12.0)*180.0);
// Day start
if(dayTime >= 28800 && dayOrNight == NIGHT && dayTime < 72000)
{
dayOrNight = 3;
fadeWithBlack(startDay);
}
// Day
if(sunlightFactor > 0.0)
{
sun_light = sunlightFactor*60;
}
// Night start
if(dayTime >= 72000 && dayOrNight == DAY)
{
dayOrNight = 3;
fadeWithBlack(startNight);
}
// Night
if(sunlightFactor <= 0.0)
{
sun_light = -sunlightFactor*30;
}
sun_angle.pan = (dayTime-28800.0)/(60.0*60.0*12.0)*180.0;
sun_angle.tilt = abs(ang(asinv(sunlightFactor)))*70.0/180.0+10.0;
d3d_fogcolor1.red = sun_light*255.0/100.0;
d3d_fogcolor1.green = sun_light*255.0/100.0;
d3d_fogcolor1.blue = sun_light*255.0/100.0;
}
/*if (key_l) {
while(key_l) wait(1);
shake();
}*/
if (key_esc) {
while(key_esc) wait(1);
break;
}
wait(1);
}
isGameOver = 0;
backToMenu();
}
int main(int argc, char *argv[])
{
int pitch = 48; // Middle C
FrqValue duration = 1;
AmpValue peakAmp = 1;
if (argc > 1)
duration = atof(argv[1]);
if (argc > 2)
pitch = atoi(argv[2]);
if (argc > 3)
peakAmp = atof(argv[3]);
InitSynthesizer();
FrqValue frequency = synthParams.GetFrequency(pitch);
PhsAccum phaseIncr = synthParams.frqRad * frequency;
PhsAccum phase = 0;
long silence = (long) (synthParams.sampleRate * 0.1);
long totalSamples = (long) ((synthParams.sampleRate * duration) + 0.5);
long attackTime = (long) (0.2 * synthParams.sampleRate);
long decayTime = (long) (0.4 * synthParams.sampleRate);
long sustainTime = totalSamples - (attackTime + decayTime);
long decayStart = totalSamples - decayTime;
AmpValue envInc = peakAmp / (float) attackTime;
AmpValue volume = 0;
long n;
WaveFile wf;
if (wf.OpenWaveFile("example02.wav", 1))
{
printf("Cannot open wavefile for output\n");
exit(1);
}
/////////////////////////////////////////////////
// Method 1 - simple integration, linear
/////////////////////////////////////////////////
long sampleNumber = 0;
for (n = 0; n < totalSamples; n++)
{
if (n < attackTime || n > decayStart)
volume += envInc;
else if (n == attackTime)
volume = peakAmp;
else if (n == decayStart)
envInc = -volume / (float) decayTime;
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 1 - convex exponential (n^2)
/////////////////////////////////////////////////
sampleNumber = 0;
volume = 0;
phase = 0;
envInc = peakAmp / (float) attackTime;
for (n = 0; n < totalSamples; n++)
{
if (n < attackTime || n > decayStart)
volume += envInc;
else if (n == attackTime)
volume = peakAmp;
else if (n == decayStart)
envInc = -volume / (float) decayTime;
wf.Output1(volume * volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 1 - variable exponential
/////////////////////////////////////////////////
phase = 0;
volume = 0;
float expMin = 0.2;
float expMax = 1.0+expMin;
float expNow = expMin;
float expMul = pow(expMax/expMin, 1.0f / (float) attackTime);
for (n = 0; n < totalSamples; n++)
{
if (n < attackTime || n > decayStart)
{
expNow *= expMul;
volume = (expNow - expMin) * peakAmp;
}
else if (n == attackTime)
{
volume = peakAmp;
expNow = expMax;
}
else if (n == decayStart)
{
expMul = pow(expMin/expMax, 1.0f / (float) decayTime);
}
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0.0);
/////////////////////////////////////////////////
// Method 1 - log
/////////////////////////////////////////////////
phase = 0;
volume = 0;
expNow = expMax;
expMul = pow(expMin/expMax, 1.0f / (float) attackTime);
for (n = 0; n < totalSamples; n++)
{
if (n < attackTime || n > decayStart)
{
expNow *= expMul;
volume = (1.0f - (expNow - expMin)) * peakAmp;
}
else if (n == attackTime)
{
volume = peakAmp;
expNow = expMin;
}
else if (n == decayStart)
expMul = pow(expMax/expMin, 1.0f / (float) decayTime);
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 1 - dB
/////////////////////////////////////////////////
phase = 0;
volume = 0;
float dbLevel = -96;
float dbIncr = 96.0 / attackTime;
for (n = 0; n < totalSamples; n++)
{
if (n < attackTime || n > decayStart)
{
dbLevel += dbIncr;
volume = pow(10.0, dbLevel / 20.0);
}
else if (n == attackTime)
{
volume = 1.0;
dbLevel = 0.0;
}
else if (n == decayStart)
{
dbIncr = -96.0 / decayTime;
}
wf.Output1(peakAmp * volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 2 - simple state machine
/////////////////////////////////////////////////
long envCount = attackTime;
int envState = 0;
envInc = peakAmp / (float) attackTime;
phase = 0;
volume = 0;
for (n = 0; n < totalSamples; n++)
{
switch (envState)
{
case 0:
if (envCount > 0)
{
volume += envInc;
envCount--;
}
else
{
volume = peakAmp;
envCount = sustainTime;
envState = 1;
}
break;
case 1:
if (envCount > 0)
envCount--;
else
{
envCount = decayTime;
envInc = volume / (float) decayTime;
envState = 2;
}
break;
case 2:
if (envCount > 0)
{
volume -= envInc;
envCount--;
}
else
{
volume = 0;
envState = 3;
}
break;
case 3:
break;
}
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 3 - multiple segments (ADSR)
/////////////////////////////////////////////////
float envPeak;
float envStep;
float envLevel[4];
float envIncr[4];
long envTime[4];
int maxEnvIndex = 4;
int envIndex = -1;
envLevel[0] = 1.0 * peakAmp;
envLevel[1] = 0.7 * peakAmp;
envLevel[2] = 0.7 * peakAmp;
envLevel[3] = 0.0;
envTime[0] = (long) (0.1 * synthParams.sampleRate);
envTime[1] = (long) (0.2 * synthParams.sampleRate);
envTime[2] = (long) (0.5 * synthParams.sampleRate);
envTime[3] = (long) (0.2 * synthParams.sampleRate);
// pre-calculate increments
envIncr[0] = envLevel[0] / envTime[0];
for (n = 1; n < maxEnvIndex; n++)
{
if (envTime[n] > 0)
envIncr[n] = (envLevel[n] - envLevel[n-1]) / envTime[n];
else
envIncr[n] = (envLevel[n] - envLevel[n-1]);
}
phase = 0;
volume = 0;
envCount = 0;
envPeak = 0;
envStep = 0;
for (n = 0; n < totalSamples; n++)
{
if (--envCount <= 0)
{
volume = envPeak;
if (++envIndex < maxEnvIndex)
{
envCount = envTime[envIndex];
envStep = envIncr[envIndex];
envPeak = envLevel[envIndex];
}
else
envStep = 0;
}
else
{
volume += envStep;
}
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 4 - multiple segments state machine
/////////////////////////////////////////////////
float atkLevel[2];
float decLevel[2];
long atkTime[2];
long decTime[2];
long atkMaxIndex = 2;
long decMaxIndex = 2;
atkLevel[0] = 1.0 * peakAmp;
atkLevel[1] = 0.7 * peakAmp;
decLevel[0] = 0.2 * peakAmp;
decLevel[1] = 0.0;
atkTime[0] = (long) (0.1 * synthParams.sampleRate);
atkTime[1] = (long) (0.2 * synthParams.sampleRate);
decTime[0] = (long) (0.1 * synthParams.sampleRate);
decTime[1] = (long) (0.2 * synthParams.sampleRate);
sustainTime = totalSamples - (atkTime[0] + atkTime[1] + decTime[0] + decTime[1]);
phase = 0;
volume = 0;
envCount = 0;
envIndex = -1;
envState = 0;
envPeak = 0;
for (n = 0; n < totalSamples; n++)
{
switch (envState)
{
case 0: // attack
if (--envCount <= 0)
{
volume = envPeak;
if (++envIndex < atkMaxIndex)
{
envPeak = atkLevel[envIndex];
envCount = atkTime[envIndex];
if (envCount < 1)
envCount = 1;
envStep = (envPeak - volume) / envCount;
}
else
{
envCount = sustainTime;
envStep = 0.0;
envState = 1;
}
}
else
volume += envStep;
break;
case 1: // sustain
if (--envCount <= 0)
{
envIndex = -1;
envState = 2;
}
break;
case 2: // release
if (--envCount <= 0)
{
volume = envPeak;
if (++envIndex < decMaxIndex)
{
envPeak = decLevel[envIndex];
envCount = decTime[envIndex];
if (envCount < 1)
envCount = 1;
envStep = (envPeak - volume) / envCount;
}
else
{
envCount = 0;
envStep = 0.0;
volume = 0.0;
envState = 3;
}
}
else
volume += envStep;
break;
case 3:
break;
}
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 5 - constant rate ADSR
/////////////////////////////////////////////////
phase = 0;
volume = 0;
envState = 0;
float sustainAmpCR = 0.8;
float atkTimeCR = 0.1;
float decTimeCR = 0.5;
float relTimeCR = 0.5;
float atkIncrCR = 1.0 / (atkTimeCR * synthParams.sampleRate);
float decIncrCR = 1.0 / (decTimeCR * synthParams.sampleRate);
float relIncrCR = 1.0 / (relTimeCR * synthParams.sampleRate);
float susTimeCR = 0;
for (n = 0; n < totalSamples; n++)
{
switch (envState)
{
case 0:
if ((volume += atkIncrCR) >= 1.0)
{
volume = 1.0;
envState = 1;
}
break;
case 1:
if ((volume -= decIncrCR) <= sustainAmpCR)
{
volume = sustainAmpCR;
envState = 2;
// for testing. This type envelope would normally sustain until release signal.
susTimeCR = totalSamples - n - ((relTimeCR * synthParams.sampleRate) * sustainAmpCR);
}
break;
case 2:
if (--susTimeCR <= 0)
envState = 3;
break;
case 3:
if ((volume -= decIncrCR) <= 0)
{
volume = 0;
envState = 4;
}
break;
}
wf.Output1(volume * volume * sinv(phase)); // convex curve
//wf.Output1(volume * sinv(phase)); // linear
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
/////////////////////////////////////////////////
// Method 5 - constant rate ADSR, transformed
/////////////////////////////////////////////////
float envTblLen = 960; // 96 dB range
float envTblNdx = 0;
float atkTblCR[960];
float decTblCR[960];
atkTblCR[0] = 0.0;
decTblCR[0] = 0.0;
for (n = 1; n < envTblLen; n++)
{
volume = pow(10, (double)(959 - n) / -200.0);
atkTblCR[n] = volume;
decTblCR[n] = volume;
}
sustainAmpCR = 0.5;
atkIncrCR = 960.0 / (atkTimeCR * synthParams.sampleRate);
decIncrCR = 960.0 / (decTimeCR * synthParams.sampleRate);
relIncrCR = 960.0 / (relTimeCR * synthParams.sampleRate);
susTimeCR = totalSamples - ((relTimeCR * synthParams.sampleRate) * sustainAmpCR);
phase = 0;
volume = 0;
envState = 0;
for (n = 0; n < totalSamples; n++)
{
switch (envState)
{
case 0:
if ((envTblNdx += atkIncrCR) >= envTblLen)
{
envTblNdx = envTblLen-1;
envState = 1;
}
volume = atkTblCR[(int)envTblNdx];
break;
case 1:
if ((envTblNdx -= decIncrCR) < 0)
envTblNdx = 0;
volume = decTblCR[(int)envTblNdx];
if (volume <= sustainAmpCR)
{
volume = sustainAmpCR;
envState = 2;
susTimeCR = totalSamples - n - ((relTimeCR * synthParams.sampleRate) * sustainAmpCR);
}
break;
case 2:
if (--susTimeCR <= 0)
envState = 3;
break;
case 3:
if ((envTblNdx -= decIncrCR) <= 0)
{
envTblNdx = 0;
envState = 4;
}
volume = decTblCR[(int)envTblNdx];
break;
}
wf.Output1(volume * sinv(phase));
if ((phase += phaseIncr) >= twoPI)
phase -= twoPI;
}
for (n = 0; n < silence; n++)
wf.Output1(0);
wf.CloseWaveFile();
int oor = wf.GetOOR();
if (oor)
printf("%d Samples out of range...\n", oor);
return 0;
}
