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; }