//Flags as defined by the cob standard void CUnitScript::Explode(int piece, int flags) { if (!PieceExists(piece)) { ShowUnitScriptError("Invalid piecenumber for explode"); return; } #ifndef _CONSOLE const float3 relPos = GetPiecePos(piece); const float3 absPos = unit->GetObjectSpacePos(relPos); #ifdef TRACE_SYNC tracefile << "Cob explosion: "; tracefile << absPos.x << " " << absPos.y << " " << absPos.z << " " << piece << " " << flags << "\n"; #endif if (!(flags & PF_NoHeatCloud)) { // Do an explosion at the location first new CHeatCloudProjectile(nullptr, absPos, ZeroVector, 30, 30); } // If this is true, no stuff should fly off if (flags & PF_NONE) return; if (pieces[piece]->original == nullptr) return; if (flags & PF_Shatter) { Shatter(piece, absPos, unit->speed); return; } // This means that we are going to do a full fledged piece explosion! float3 baseSpeed = unit->speed; float3 explSpeed((0.5f - gs->randFloat()) * 6.0f, 1.2f + gs->randFloat() * 5.0f, (0.5f - gs->randFloat()) * 6.0f); if (unit->pos.y - CGround::GetApproximateHeight(unit->pos.x, unit->pos.z) > 15) explSpeed.y = (0.5f - gs->randFloat()) * 6.0f; if (baseSpeed.SqLength() > 9.0f) { const float l = baseSpeed.Length(); const float l2 = 3.0f + math::sqrt(l - 3.0f); baseSpeed *= (l2 / l); } explSpeed += baseSpeed; const float partSat = projectileHandler->GetParticleSaturation(); int newFlags = 0; newFlags |= (PF_Explode * ((flags & PF_Explode ) != 0)); newFlags |= (PF_Smoke * ((flags & PF_Smoke ) != 0) && partSat < 0.95f); newFlags |= (PF_Fire * ((flags & PF_Fire ) != 0) && partSat < 0.95f); newFlags |= (PF_NoCEGTrail * ((flags & PF_NoCEGTrail) != 0)); newFlags |= (PF_Recursive * ((flags & PF_Recursive ) != 0)); new CPieceProjectile(unit, pieces[piece], absPos, explSpeed, newFlags, 0.5f); #endif }
int CFile::Read(char *buf, int bufsize, int piece) { SetPos(GetPiecePos(piece), piece); // LOG("Read(%d) bufsize: %d GetPiecePos(): %d GetPieceSize() %d",piece, bufsize, GetPiecePos(piece), GetPieceSize(piece)); clearerr(handle); int items=fread(buf, bufsize, 1, handle); if (items<=0) { if(ferror(handle)) { LOG_DEBUG("read error %s bufsize: %d curpos: %d GetPieceSize: %d", strerror(errno), bufsize, curpos, GetPieceSize()); SetPos(0, piece); return -1; } if(feof(handle)) { LOG_DEBUG("EOF while Read: '%s' items: %d!", strerror(errno), items); LOG_DEBUG("read error %s bufsize: %d curpos: %d GetPieceSize: %d", strerror(errno), bufsize, curpos, GetPieceSize()); return -1; } } SetPos(GetPiecePos(piece)+bufsize, piece); //inc pos return bufsize; }
int CFile::Write(const char*buf, int bufsize, int piece) { SetPos(GetPiecePos(piece), piece); clearerr(handle); // LOG("Write() bufsize %d piece %d handle %d", bufsize, piece, fileno(handle)); int res=fwrite(buf, bufsize, 1, handle); if (res!=1) LOG_ERROR("write error %d", res); // LOG("wrote bufsize %d", bufsize); if(ferror(handle)!=0) { LOG_ERROR("Error in write(): %s", strerror(errno)); abort(); } if(feof(handle)) { LOG_ERROR("EOF in write(): %s", strerror(errno)); } SetPos(GetPiecePos(piece)+bufsize, piece); /* if ((piece>=0) && (GetPiecePos(piece)==GetPieceSize(piece))) { LOG("piece finished: %d", piece); } */ return bufsize; }
void CUnitScript::ShowFlare(int piece) { if (!PieceExists(piece)) { ShowUnitScriptError("Invalid piecenumber for show(flare)"); return; } #ifndef _CONSOLE const float3 relPos = GetPiecePos(piece); const float3 absPos = unit->GetObjectSpacePos(relPos); const float3 dir = unit->lastMuzzleFlameDir; const float size = unit->lastMuzzleFlameSize; new CMuzzleFlame(absPos, unit->speed, dir, size); #endif }
void CUnitScript::ShowFlare(int piece) { if (!PieceExists(piece)) { ShowScriptError("Invalid piecenumber for show(flare)"); return; } #ifndef _CONSOLE const float3 relPos = GetPiecePos(piece); const float3 absPos = unit->pos + unit->frontdir * relPos.z + unit->updir * relPos.y + unit->rightdir * relPos.x; const float3 dir = unit->lastMuzzleFlameDir; const float size = unit->lastMuzzleFlameSize; new CMuzzleFlame(absPos, unit->speed, dir, size); #endif }
bool CFile::Hash(IHash& hash, int piece) { // LOG("Hash() piece %d", piece); char buf[IO_BUF_SIZE]; SetPos(0, piece); hash.Init(); // LOG("piece %d left: %d",piece, GetPieceSize(piece)); long unsigned left=GetPieceSize(piece); //total bytes to hash if (left==0) { LOG_ERROR("tried to hash empty piece %d", piece); return false; } while(left>0) { const int toread=std::min(left, (long unsigned)sizeof(buf)); const int read=Read(buf, toread, piece); if(read<=0) { LOG_DEBUG("EOF or read error on piece %d, left: %d toread: %d size: %d, GetPiecePos %d GetPieceSize(): %d read: %d", piece, left, toread, GetPieceSize(piece), GetPiecePos(piece), GetPieceSize(piece), read); LOG_DEBUG("curpos: %d", curpos); return false; } hash.Update(buf, toread); left=left-toread; } hash.Final(); SetPos(0, piece); // LOG("CFile::Hash(): %s piece:%d", hash.toString().c_str(), piece); return true; }
int CUnitScript::GetUnitVal(int val, int p1, int p2, int p3, int p4) { // may happen in case one uses Spring.GetUnitCOBValue (Lua) on a unit with CNullUnitScript if (!unit) { ShowScriptError("Error: no unit (in GetUnitVal)"); return 0; } #ifndef _CONSOLE switch (val) { case ACTIVATION: if (unit->activated) return 1; else return 0; break; case STANDINGMOVEORDERS: return unit->moveState; break; case STANDINGFIREORDERS: return unit->fireState; break; case HEALTH: { if (p1 <= 0) return int((unit->health / unit->maxHealth) * 100.0f); const CUnit* u = uh->GetUnit(p1); if (u == NULL) return 0; else return int((u->health / u->maxHealth) * 100.0f); } case INBUILDSTANCE: if (unit->inBuildStance) return 1; else return 0; case BUSY: if (busy) return 1; else return 0; break; case PIECE_XZ: { if (!PieceExists(p1)) { ShowScriptError("Invalid piecenumber for get piece_xz"); break; } const float3 relPos = GetPiecePos(p1); const float3 absPos = unit->pos + unit->frontdir * relPos.z + unit->updir * relPos.y + unit->rightdir * relPos.x; return PACKXZ(absPos.x, absPos.z); } case PIECE_Y: { if (!PieceExists(p1)) { ShowScriptError("Invalid piecenumber for get piece_y"); break; } const float3 relPos = GetPiecePos(p1); const float3 absPos = unit->pos + unit->frontdir * relPos.z + unit->updir * relPos.y + unit->rightdir * relPos.x; return int(absPos.y * COBSCALE); } case UNIT_XZ: { if (p1 <= 0) return PACKXZ(unit->pos.x, unit->pos.z); const CUnit* u = uh->GetUnit(p1); if (u == NULL) return PACKXZ(0, 0); else return PACKXZ(u->pos.x, u->pos.z); } case UNIT_Y: { if (p1 <= 0) return int(unit->pos.y * COBSCALE); const CUnit* u = uh->GetUnit(p1); if (u == NULL) return 0; else return int(u->pos.y * COBSCALE); } case UNIT_HEIGHT: { if (p1 <= 0) return int(unit->radius * COBSCALE); const CUnit* u = uh->GetUnit(p1); if (u == NULL) return 0; else return int(u->radius * COBSCALE); } case XZ_ATAN: return int(RAD2TAANG*math::atan2((float)UNPACKX(p1), (float)UNPACKZ(p1)) + 32768 - unit->heading); case XZ_HYPOT: return int(math::hypot((float)UNPACKX(p1), (float)UNPACKZ(p1)) * COBSCALE); case ATAN: return int(RAD2TAANG*math::atan2((float)p1, (float)p2)); case HYPOT: return int(math::hypot((float)p1, (float)p2)); case GROUND_HEIGHT: return int(ground->GetHeightAboveWater(UNPACKX(p1), UNPACKZ(p1)) * COBSCALE); case GROUND_WATER_HEIGHT: return int(ground->GetHeightReal(UNPACKX(p1), UNPACKZ(p1)) * COBSCALE); case BUILD_PERCENT_LEFT: return int((1.0f - unit->buildProgress) * 100); case YARD_OPEN: if (yardOpen) return 1; else return 0; case BUGGER_OFF: break; case ARMORED: if (unit->armoredState) return 1; else return 0; case VETERAN_LEVEL: return int(100 * unit->experience); case CURRENT_SPEED: return int(unit->speed.Length() * COBSCALE); case ON_ROAD: return 0; case IN_WATER: return (unit->pos.y < 0.0f) ? 1 : 0; case MAX_ID: return uh->MaxUnits()-1; case MY_ID: return unit->id; case UNIT_TEAM: { const CUnit* u = uh->GetUnit(p1); return (u != NULL)? unit->team : 0; } case UNIT_ALLIED: { const CUnit* u = uh->GetUnit(p1); if (u != NULL) { return teamHandler->Ally(unit->allyteam, u->allyteam) ? 1 : 0; } return 0; } case UNIT_BUILD_PERCENT_LEFT: { const CUnit* u = uh->GetUnit(p1); if (u != NULL) { return int((1.0f - u->buildProgress) * 100); } return 0; } case MAX_SPEED: { return int(unit->moveType->GetMaxSpeed() * COBSCALE); } break; case REVERSING: { CGroundMoveType* gmt = dynamic_cast<CGroundMoveType*>(unit->moveType); return ((gmt != NULL)? int(gmt->IsReversing()): 0); } break; case CLOAKED: return !!unit->isCloaked; case WANT_CLOAK: return !!unit->wantCloak; case UPRIGHT: return !!unit->upright; case POW: return int(math::pow(((float)p1)/COBSCALE,((float)p2)/COBSCALE)*COBSCALE); case PRINT: LOG("Value 1: %d, 2: %d, 3: %d, 4: %d", p1, p2, p3, p4); break; case HEADING: { if (p1 <= 0) { return unit->heading; } const CUnit* u = uh->GetUnit(p1); if (u != NULL) { return u->heading; } return -1; } case TARGET_ID: { if (unit->weapons[p1 - 1]) { const CWeapon* weapon = unit->weapons[p1 - 1]; const TargetType tType = weapon->targetType; if (tType == Target_Unit) return unit->weapons[p1 - 1]->targetUnit->id; else if (tType == Target_None) return -1; else if (tType == Target_Pos) return -2; else // Target_Intercept return -3; } return -4; // weapon does not exist } case LAST_ATTACKER_ID: return unit->lastAttacker? unit->lastAttacker->id: -1; case LOS_RADIUS: return unit->realLosRadius; case AIR_LOS_RADIUS: return unit->realAirLosRadius; case RADAR_RADIUS: return unit->radarRadius; case JAMMER_RADIUS: return unit->jammerRadius; case SONAR_RADIUS: return unit->sonarRadius; case SONAR_JAM_RADIUS: return unit->sonarJamRadius; case SEISMIC_RADIUS: return unit->seismicRadius; case DO_SEISMIC_PING: float pingSize; if (p1 == 0) { pingSize = unit->seismicSignature; } else { pingSize = p1; } unit->DoSeismicPing(pingSize); break; case CURRENT_FUEL: return int(unit->currentFuel * float(COBSCALE)); case TRANSPORT_ID: return unit->transporter?unit->transporter->id:-1; case SHIELD_POWER: { if (unit->shieldWeapon == NULL) { return -1; } const CPlasmaRepulser* shield = (CPlasmaRepulser*) unit->shieldWeapon; return int(shield->curPower * float(COBSCALE)); } case STEALTH: { return unit->stealth ? 1 : 0; } case SONAR_STEALTH: { return unit->sonarStealth ? 1 : 0; } case CRASHING: return !!unit->crashing; case ALPHA_THRESHOLD: { return int(unit->alphaThreshold * 255); } case COB_ID: { if (p1 <= 0) { return unit->unitDef->cobID; } else { const CUnit* u = uh->GetUnit(p1); return ((u == NULL)? -1 : u->unitDef->cobID); } } case PLAY_SOUND: { // FIXME: this can currently only work for CCobInstance, because Lua can not get sound IDs // (however, for Lua scripts there is already LuaUnsyncedCtrl::PlaySoundFile) CCobInstance* cob = dynamic_cast<CCobInstance*>(this); if (cob == NULL) { return 1; } const CCobFile* script = cob->GetScriptAddr(); if (script == NULL) { return 1; } if ((p1 < 0) || (static_cast<size_t>(p1) >= script->sounds.size())) { return 1; } switch (p3) { //who hears the sound case 0: //ALOS if (!loshandler->InAirLos(unit->pos,gu->myAllyTeam)) { return 0; } break; case 1: //LOS if (!(unit->losStatus[gu->myAllyTeam] & LOS_INLOS)) { return 0; } break; case 2: //ALOS or radar if (!(loshandler->InAirLos(unit->pos,gu->myAllyTeam) || unit->losStatus[gu->myAllyTeam] & (LOS_INRADAR))) { return 0; } break; case 3: //LOS or radar if (!(unit->losStatus[gu->myAllyTeam] & (LOS_INLOS | LOS_INRADAR))) { return 0; } break; case 4: //everyone break; case 5: //allies if (unit->allyteam != gu->myAllyTeam) { return 0; } break; case 6: //team if (unit->team != gu->myTeam) { return 0; } break; case 7: //enemies if (unit->allyteam == gu->myAllyTeam) { return 0; } break; } if (p4 == 0) { Channels::General.PlaySample(script->sounds[p1], unit->pos, unit->speed, float(p2) / COBSCALE); } else { Channels::General.PlaySample(script->sounds[p1], float(p2) / COBSCALE); } return 0; } case SET_WEAPON_UNIT_TARGET: { const unsigned int weaponID = p1 - 1; const unsigned int targetID = p2; const bool userTarget = !!p3; if (weaponID >= unit->weapons.size()) { return 0; } CWeapon* weapon = unit->weapons[weaponID]; if (weapon == NULL) { return 0; } //! if targetID is 0, just sets weapon->haveUserTarget //! to false (and targetType to None) without attacking CUnit* target = (targetID > 0)? uh->GetUnit(targetID): NULL; return (weapon->AttackUnit(target, userTarget) ? 1 : 0); } case SET_WEAPON_GROUND_TARGET: { const int weaponID = p1 - 1; const float3 pos = float3(float(UNPACKX(p2)), float(p3) / float(COBSCALE), float(UNPACKZ(p2))); const bool userTarget = !!p4; if ((weaponID < 0) || (static_cast<size_t>(weaponID) >= unit->weapons.size())) { return 0; } CWeapon* weapon = unit->weapons[weaponID]; if (weapon == NULL) { return 0; } return weapon->AttackGround(pos, userTarget) ? 1 : 0; } case MIN: return std::min(p1, p2); case MAX: return std::max(p1, p2); case ABS: return abs(p1); case KSIN: return int(1024*math::sinf(TAANG2RAD*(float)p1)); case KCOS: return int(1024*math::cosf(TAANG2RAD*(float)p1)); case KTAN: return int(1024*math::tanf(TAANG2RAD*(float)p1)); case SQRT: return int(math::sqrt((float)p1)); case FLANK_B_MODE: return unit->flankingBonusMode; case FLANK_B_DIR: switch (p1) { case 1: return int(unit->flankingBonusDir.x * COBSCALE); case 2: return int(unit->flankingBonusDir.y * COBSCALE); case 3: return int(unit->flankingBonusDir.z * COBSCALE); case 4: unit->flankingBonusDir.x = (p2/(float)COBSCALE); return 0; case 5: unit->flankingBonusDir.y = (p2/(float)COBSCALE); return 0; case 6: unit->flankingBonusDir.z = (p2/(float)COBSCALE); return 0; case 7: unit->flankingBonusDir = float3(p2/(float)COBSCALE, p3/(float)COBSCALE, p4/(float)COBSCALE).Normalize(); return 0; default: return(-1); } case FLANK_B_MOBILITY_ADD: return int(unit->flankingBonusMobilityAdd * COBSCALE); case FLANK_B_MAX_DAMAGE: return int((unit->flankingBonusAvgDamage + unit->flankingBonusDifDamage) * COBSCALE); case FLANK_B_MIN_DAMAGE: return int((unit->flankingBonusAvgDamage - unit->flankingBonusDifDamage) * COBSCALE); case KILL_UNIT: { //! ID 0 is reserved for the script's owner CUnit* u = (p1 > 0)? uh->GetUnit(p1): this->unit; if (u == NULL) { return 0; } if (u->beingBuilt) { // no explosions and no corpse for units under construction u->KillUnit(false, true, NULL); } else { u->KillUnit(p2 != 0, p3 != 0, NULL); } return 1; } case WEAPON_RELOADSTATE: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return unit->weapons[p1-1]->reloadStatus; } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->reloadStatus; unit->weapons[np1 - 1]->reloadStatus = p2; return old; } else { return -1; } } case WEAPON_RELOADTIME: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return unit->weapons[p1-1]->reloadTime; } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->reloadTime; unit->weapons[np1 - 1]->reloadTime = p2; return old; } else { return -1; } } case WEAPON_ACCURACY: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return int(unit->weapons[p1-1]->accuracy * COBSCALE); } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->accuracy * COBSCALE; unit->weapons[np1 - 1]->accuracy = float(p2) / COBSCALE; return old; } else { return -1; } } case WEAPON_SPRAY: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return int(unit->weapons[p1-1]->sprayAngle * COBSCALE); } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->sprayAngle * COBSCALE; unit->weapons[np1 - 1]->sprayAngle = float(p2) / COBSCALE; return old; } else { return -1; } } case WEAPON_RANGE: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return int(unit->weapons[p1 - 1]->range * COBSCALE); } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->range * COBSCALE; unit->weapons[np1 - 1]->range = float(p2) / COBSCALE; return old; } else { return -1; } } case WEAPON_PROJECTILE_SPEED: { const int np1 = -p1; if (p1 > 0 && static_cast<size_t>(p1) <= unit->weapons.size()) { return int(unit->weapons[p1-1]->projectileSpeed * COBSCALE); } else if (np1 > 0 && static_cast<size_t>(np1) <= unit->weapons.size()) { const int old = unit->weapons[np1 - 1]->projectileSpeed * COBSCALE; unit->weapons[np1 - 1]->projectileSpeed = float(p2) / COBSCALE; return old; } else { return -1; } } case GAME_FRAME: { return gs->frameNum; } default: if ((val >= GLOBAL_VAR_START) && (val <= GLOBAL_VAR_END)) { return globalVars[val - GLOBAL_VAR_START]; } else if ((val >= TEAM_VAR_START) && (val <= TEAM_VAR_END)) { return teamVars[unit->team][val - TEAM_VAR_START]; } else if ((val >= ALLY_VAR_START) && (val <= ALLY_VAR_END)) { return allyVars[unit->allyteam][val - ALLY_VAR_START]; } else if ((val >= UNIT_VAR_START) && (val <= UNIT_VAR_END)) { const int varID = val - UNIT_VAR_START; if (p1 == 0) { return unitVars[varID]; } else if (p1 > 0) { // get the unit var for another unit const CUnit* u = uh->GetUnit(p1); if (u != NULL && u->script != NULL) { return u->script->unitVars[varID]; } } else { // set the unit var for another unit p1 = -p1; CUnit* u = uh->GetUnit(p1); if (u != NULL && u->script != NULL) { u->script->unitVars[varID] = p2; return 1; } } return 0; } else { LOG_L(L_ERROR, "CobError: Unknown get constant %d (params = %d %d %d %d)", val, p1, p2, p3, p4); } } #endif return 0; }
//Flags as defined by the cob standard void CUnitScript::Explode(int piece, int flags) { if (!PieceExists(piece)) { ShowScriptError("Invalid piecenumber for explode"); return; } #ifndef _CONSOLE const float3 relPos = GetPiecePos(piece); const float3 absPos = unit->pos + unit->frontdir * relPos.z + unit->updir * relPos.y + unit->rightdir * relPos.x; #ifdef TRACE_SYNC tracefile << "Cob explosion: "; tracefile << absPos.x << " " << absPos.y << " " << absPos.z << " " << piece << " " << flags << "\n"; #endif if (!(flags & PF_NoHeatCloud)) { // Do an explosion at the location first new CHeatCloudProjectile(absPos, float3(0, 0, 0), 30, 30, NULL); } // If this is true, no stuff should fly off if (flags & PF_NONE) return; // This means that we are going to do a full fledged piece explosion! float3 baseSpeed = unit->speed + unit->residualImpulse * 0.5f; float sql = baseSpeed.SqLength(); if (sql > 9) { const float l = math::sqrt(sql); const float l2 = 3 + math::sqrt(l - 3); baseSpeed *= (l2 / l); } float3 speed((0.5f-gs->randFloat()) * 6.0f, 1.2f + gs->randFloat() * 5.0f, (0.5f - gs->randFloat()) * 6.0f); if (unit->pos.y - ground->GetApproximateHeight(unit->pos.x, unit->pos.z) > 15) { speed.y = (0.5f - gs->randFloat()) * 6.0f; } speed += baseSpeed; if (speed.SqLength() > 12*12) { speed.Normalize(); speed *= 12; } /* TODO Push this back. Don't forget to pass the team (color). */ if (flags & PF_Shatter) { Shatter(piece, absPos, speed); } else { LocalModelPiece* pieceData = pieces[piece]; if (pieceData->original != NULL) { int newflags = PF_Fall; // if they don't fall they could live forever if (flags & PF_Explode) { newflags |= PF_Explode; } //if (flags & PF_Fall) { newflags |= PF_Fall; } if ((flags & PF_Smoke) && ph->particleSaturation < 1) { newflags |= PF_Smoke; } if ((flags & PF_Fire) && ph->particleSaturation < 0.95f) { newflags |= PF_Fire; } if (flags & PF_NoCEGTrail) { newflags |= PF_NoCEGTrail; } //LOG_L(L_DEBUG, "Exploding %s as %d", script.pieceNames[piece].c_str(), dl); new CPieceProjectile(absPos, speed, pieceData, newflags,unit,0.5f); } } #endif }
//Flags as defined by the cob standard void CUnitScript::Explode(int piece, int flags) { if (!PieceExists(piece)) { ShowUnitScriptError("Invalid piecenumber for explode"); return; } #ifndef _CONSOLE const float3 relPos = GetPiecePos(piece); const float3 absPos = unit->GetObjectSpacePos(relPos); #ifdef TRACE_SYNC tracefile << "Cob explosion: "; tracefile << absPos.x << " " << absPos.y << " " << absPos.z << " " << piece << " " << flags << "\n"; #endif if (!(flags & PF_NoHeatCloud)) { // Do an explosion at the location first new CHeatCloudProjectile(NULL, absPos, ZeroVector, 30, 30); } // If this is true, no stuff should fly off if (flags & PF_NONE) return; // This means that we are going to do a full fledged piece explosion! float3 baseSpeed = unit->speed; float3 explSpeed((0.5f - gs->randFloat()) * 6.0f, 1.2f + gs->randFloat() * 5.0f, (0.5f - gs->randFloat()) * 6.0f); if (baseSpeed.SqLength() > 9) { const float l = baseSpeed.Length(); const float l2 = 3 + math::sqrt(l - 3); baseSpeed *= (l2 / l); } if (unit->pos.y - CGround::GetApproximateHeight(unit->pos.x, unit->pos.z) > 15) { explSpeed.y = (0.5f - gs->randFloat()) * 6.0f; } explSpeed += baseSpeed; // limit projectile speed to 12 elmos/frame (why?) if (false && explSpeed.SqLength() > (12.0f*12.0f)) { explSpeed = (explSpeed.Normalize() * 12.0f); } if (flags & PF_Shatter) { Shatter(piece, absPos, explSpeed); return; } if (pieces[piece]->original == NULL) return; // projectiles that don't fall could live forever int newflags = PF_Fall; const float partSat = projectileHandler->GetParticleSaturation(); if (flags & PF_Explode) { newflags |= PF_Explode; } // if (flags & PF_Fall) { newflags |= PF_Fall; } if ((flags & PF_Smoke) && partSat < 1.0f) { newflags |= PF_Smoke; } if ((flags & PF_Fire) && partSat < 0.95f) { newflags |= PF_Fire; } if (flags & PF_NoCEGTrail) { newflags |= PF_NoCEGTrail; } if (flags & PF_Recursive) { newflags |= PF_Recursive; } new CPieceProjectile(unit, pieces[piece], absPos, explSpeed, newflags, 0.5f); #endif }