forked from Simnation/Main
746 lines
26 KiB
Lua
746 lines
26 KiB
Lua
local QBCore = exports['qb-core']:GetCoreObject()
|
|
local fireworkTime = 0
|
|
local fireworkLoc = nil
|
|
|
|
-- Modelle für Feuerwerks-Batterien und Raketen
|
|
local fireworkModels = {
|
|
["firework1"] = "ind_prop_firework_01", -- Rakete für firework1
|
|
["firework2"] = "ind_prop_firework_04", -- Standard-Batterie für firework2
|
|
["firework3"] = "ind_prop_firework_03", -- Große Batterie für firework3
|
|
["firework4"] = "prop_firework_03" -- Alternative Batterie für firework4 (Fontäne)
|
|
}
|
|
|
|
-- Verbesserte Feuerwerkseffekte ohne Flammen
|
|
local fireworkEffects = {
|
|
-- Bunte Explosionseffekte
|
|
"scr_indep_firework_starburst",
|
|
"scr_indep_firework_shotburst",
|
|
"scr_indep_firework_trailburst",
|
|
"scr_xmas_firework_burst_fizzle",
|
|
"scr_firework_indep_burst_rwb",
|
|
"scr_firework_indep_spiral_burst_rwb",
|
|
"scr_firework_indep_ring_burst_rwb",
|
|
-- Konfetti und Funken
|
|
"scr_indep_firework_sparkle_spawn",
|
|
"scr_xmas_firework_sparkle_spawn",
|
|
-- Trails
|
|
"proj_indep_flare_trail",
|
|
"scr_indep_firework_trail_spawn"
|
|
}
|
|
|
|
-- Funktion zum Starten einer Feuerwerksrakete
|
|
local function launchFireworkRocket(coords)
|
|
-- Lade das Raketenmodell
|
|
local rocketModel = "ind_prop_firework_01"
|
|
RequestModel(GetHashKey(rocketModel))
|
|
while not HasModelLoaded(GetHashKey(rocketModel)) do
|
|
Wait(10)
|
|
end
|
|
|
|
-- Erstelle die Rakete
|
|
local rocket = CreateObject(GetHashKey(rocketModel),
|
|
coords.x, coords.y, coords.z - 0.5,
|
|
true, true, false)
|
|
|
|
-- Stelle die Rakete richtig auf den Boden
|
|
PlaceObjectOnGroundProperly(rocket)
|
|
FreezeEntityPosition(rocket, true)
|
|
|
|
-- Warte kurz, damit die Rakete sichtbar ist
|
|
Wait(500)
|
|
|
|
-- Lade die Feuerwerkseffekte
|
|
local ptfxAssets = {
|
|
"scr_indep_fireworks",
|
|
"proj_xmas_firework",
|
|
"proj_indep_firework_v2",
|
|
"proj_indep_firework"
|
|
}
|
|
|
|
for _, asset in ipairs(ptfxAssets) do
|
|
RequestNamedPtfxAsset(asset)
|
|
while not HasNamedPtfxAssetLoaded(asset) do
|
|
Wait(10)
|
|
end
|
|
end
|
|
|
|
-- Füge einen Zündungseffekt hinzu (kleiner Funke statt Flamme)
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local ignitionEffect = StartParticleFxLoopedOnEntity("scr_indep_firework_sparkle_spawn",
|
|
rocket, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.5, false, false, false)
|
|
|
|
-- Zündungsgeräusch
|
|
PlaySoundFromEntity(-1, "DISTANT_FIREWORK_LAUNCH_01", rocket, "dlc_sum20_beach_party_sounds", true, 20)
|
|
|
|
-- Warte kurz für den Zündungseffekt
|
|
Wait(1000)
|
|
|
|
-- Stoppe den Zündungseffekt
|
|
StopParticleFxLooped(ignitionEffect, 0)
|
|
|
|
-- Löse die Rakete vom Boden
|
|
FreezeEntityPosition(rocket, false)
|
|
|
|
-- Füge einen Aufstiegseffekt hinzu
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local trailEffect = StartParticleFxLoopedOnEntity("scr_indep_firework_trail_spawn",
|
|
rocket, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, false, false, false)
|
|
|
|
-- Bewege die Rakete nach oben
|
|
local startTime = GetGameTimer()
|
|
local duration = 3000 -- 3 Sekunden Aufstieg
|
|
local height = math.random(40, 60)
|
|
local startZ = GetEntityCoords(rocket).z
|
|
|
|
-- Aufstiegsschleife mit leichter Schwankung
|
|
while GetGameTimer() - startTime < duration do
|
|
local progress = (GetGameTimer() - startTime) / duration
|
|
local newZ = startZ + (height * progress)
|
|
|
|
-- Leichte Schwankung für realistischen Flug
|
|
local wobbleX = math.sin(GetGameTimer() * 0.01) * 0.3 * progress
|
|
local wobbleY = math.cos(GetGameTimer() * 0.01) * 0.3 * progress
|
|
|
|
SetEntityCoords(rocket,
|
|
coords.x + wobbleX,
|
|
coords.y + wobbleY,
|
|
newZ)
|
|
Wait(0)
|
|
end
|
|
|
|
-- Stoppe den Aufstiegseffekt
|
|
StopParticleFxLooped(trailEffect, 0)
|
|
|
|
-- Verstecke die Rakete
|
|
SetEntityVisible(rocket, false, 0)
|
|
|
|
-- Explosionseffekt in der Luft
|
|
local explosionHeight = startZ + height
|
|
|
|
-- Wähle mehrere zufällige Effekte für die Explosion
|
|
for i = 1, 5 do
|
|
-- Wähle einen zufälligen Effekt aus der Liste
|
|
local effectIndex = math.random(1, #fireworkEffects)
|
|
local effect = fireworkEffects[effectIndex]
|
|
|
|
-- Bestimme das richtige Asset für diesen Effekt
|
|
local effectAsset = "scr_indep_fireworks" -- Standard
|
|
|
|
if effect:find("xmas") then
|
|
effectAsset = "proj_xmas_firework"
|
|
elseif effect:find("indep_burst") or effect:find("indep_spiral") or effect:find("indep_ring") then
|
|
effectAsset = "proj_indep_firework_v2"
|
|
elseif effect:find("flare") then
|
|
effectAsset = "proj_indep_firework"
|
|
end
|
|
|
|
-- Leichte Variation in der Position
|
|
local offsetX = math.random(-5, 5)
|
|
local offsetY = math.random(-5, 5)
|
|
local offsetZ = math.random(-5, 5)
|
|
|
|
-- Starte den Effekt
|
|
UseParticleFxAssetNextCall(effectAsset)
|
|
StartParticleFxNonLoopedAtCoord(
|
|
effect,
|
|
coords.x + offsetX, coords.y + offsetY, explosionHeight + offsetZ,
|
|
0.0, 0.0, 0.0,
|
|
math.random(20, 30) / 10, -- Größere Skalierung für bessere Sichtbarkeit
|
|
false, false, false
|
|
)
|
|
|
|
-- Explosionsgeräusch
|
|
PlaySoundFromCoord(-1, "DISTANT_FIREWORK_BURST_0" .. math.random(1, 3),
|
|
coords.x + offsetX, coords.y + offsetY, explosionHeight + offsetZ,
|
|
"dlc_sum20_beach_party_sounds", true, 50, false)
|
|
|
|
Wait(math.random(100, 300))
|
|
end
|
|
|
|
-- Lösche die Rakete nach einer Weile
|
|
Wait(5000)
|
|
DeleteEntity(rocket)
|
|
end
|
|
|
|
-- Funktion für eine kreischende Fontäne (firework4)
|
|
local function launchFireworkFountain(coords)
|
|
-- Lade das Fontänenmodell
|
|
local fountainModel = "prop_firework_03"
|
|
RequestModel(GetHashKey(fountainModel))
|
|
while not HasModelLoaded(GetHashKey(fountainModel)) do
|
|
Wait(10)
|
|
end
|
|
|
|
-- Erstelle die Fontäne
|
|
local fountain = CreateObject(GetHashKey(fountainModel),
|
|
coords.x, coords.y, coords.z - 0.5,
|
|
true, true, false)
|
|
|
|
-- Stelle die Fontäne richtig auf den Boden
|
|
PlaceObjectOnGroundProperly(fountain)
|
|
FreezeEntityPosition(fountain, true)
|
|
|
|
-- Warte kurz, damit die Fontäne sichtbar ist
|
|
Wait(500)
|
|
|
|
-- Lade die Feuerwerkseffekte
|
|
local ptfxAssets = {
|
|
"scr_indep_fireworks",
|
|
"core"
|
|
}
|
|
|
|
for _, asset in ipairs(ptfxAssets) do
|
|
RequestNamedPtfxAsset(asset)
|
|
while not HasNamedPtfxAssetLoaded(asset) do
|
|
Wait(10)
|
|
end
|
|
end
|
|
|
|
-- Füge einen Zündungseffekt hinzu
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local ignitionEffect = StartParticleFxLoopedOnEntity("scr_indep_firework_sparkle_spawn",
|
|
fountain, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.5, false, false, false)
|
|
|
|
-- Zündungsgeräusch
|
|
PlaySoundFromEntity(-1, "DISTANT_FIREWORK_LAUNCH_01", fountain, "dlc_sum20_beach_party_sounds", true, 20)
|
|
|
|
-- Warte kurz für den Zündungseffekt
|
|
Wait(1000)
|
|
|
|
-- Stoppe den Zündungseffekt
|
|
StopParticleFxLooped(ignitionEffect, 0)
|
|
|
|
-- Starte die Fontäne
|
|
print("Starte kreischende Fontäne")
|
|
|
|
-- Dauer der Fontäne
|
|
local fountainDuration = 15000 -- 15 Sekunden
|
|
local startTime = GetGameTimer()
|
|
|
|
-- Haupteffekt der Fontäne (kontinuierlich)
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local mainEffect = StartParticleFxLoopedOnEntity("scr_indep_firework_fountain",
|
|
fountain, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 2.0, false, false, false)
|
|
|
|
-- Kreischendes Geräusch in Schleife
|
|
local lastSoundTime = 0
|
|
|
|
-- Fontänen-Schleife
|
|
while GetGameTimer() - startTime < fountainDuration do
|
|
-- Füge zusätzliche Funkeneffekte hinzu
|
|
if math.random(1, 100) > 70 then -- 30% Chance pro Frame
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
StartParticleFxNonLoopedOnEntity(
|
|
"scr_indep_firework_sparkle_spawn",
|
|
fountain,
|
|
math.random(-10, 10) / 10, math.random(-10, 10) / 10, math.random(5, 15) / 10,
|
|
0.0, 0.0, 0.0,
|
|
math.random(10, 20) / 10,
|
|
false, false, false
|
|
)
|
|
end
|
|
|
|
-- Kreischendes Geräusch alle 500-1500ms
|
|
if GetGameTimer() - lastSoundTime > math.random(500, 1500) then
|
|
-- Wähle zufällig zwischen verschiedenen Geräuschen
|
|
local sounds = {
|
|
"POLICE_SIREN_WAIL", -- Kreischendes Geräusch
|
|
"CAR_BOMB_TICK", -- Tickendes Geräusch
|
|
"DISTANT_FIREWORK_LAUNCH_01" -- Startgeräusch
|
|
}
|
|
local sound = sounds[math.random(1, #sounds)]
|
|
|
|
PlaySoundFromEntity(-1, sound, fountain, "dlc_sum20_beach_party_sounds", true, math.random(10, 30))
|
|
lastSoundTime = GetGameTimer()
|
|
end
|
|
|
|
-- Intensivere Effekte gegen Ende
|
|
local progress = (GetGameTimer() - startTime) / fountainDuration
|
|
if progress > 0.7 and math.random(1, 100) > 50 then -- 50% Chance in der letzten Phase
|
|
-- Zusätzliche Funken in verschiedenen Höhen
|
|
UseParticleFxAssetNextCall("core")
|
|
StartParticleFxNonLoopedOnEntity(
|
|
"ent_sht_electrical_box_sp",
|
|
fountain,
|
|
0.0, 0.0, math.random(5, 20) / 10,
|
|
0.0, 0.0, 0.0,
|
|
math.random(15, 25) / 10,
|
|
false, false, false
|
|
)
|
|
end
|
|
|
|
Wait(0)
|
|
end
|
|
|
|
-- Stoppe den Haupteffekt
|
|
StopParticleFxLooped(mainEffect, 0)
|
|
|
|
-- Finale der Fontäne
|
|
print("Fontänen-Finale")
|
|
|
|
-- Mehrere intensive Funkeneffekte für das Finale
|
|
for i = 1, 10 do
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
StartParticleFxNonLoopedOnEntity(
|
|
"scr_indep_firework_starburst",
|
|
fountain,
|
|
0.0, 0.0, math.random(5, 15) / 10,
|
|
0.0, 0.0, 0.0,
|
|
math.random(15, 25) / 10,
|
|
false, false, false
|
|
)
|
|
|
|
-- Finale-Geräusch
|
|
PlaySoundFromEntity(-1, "DISTANT_FIREWORK_BURST_0" .. math.random(1, 3),
|
|
fountain, "dlc_sum20_beach_party_sounds", true, 40)
|
|
|
|
Wait(math.random(100, 300))
|
|
end
|
|
|
|
-- Lösche die Fontäne nach einer Weile
|
|
Wait(2000)
|
|
DeleteEntity(fountain)
|
|
end
|
|
|
|
-- Funktion zum Starten einer Feuerwerks-Batterie ohne Flammeneffekte
|
|
local function startFireworkBattery(coords, itemName)
|
|
-- Wähle ein Batteriemodell basierend auf dem Item
|
|
local batteryModel = fireworkModels[itemName] or "ind_prop_firework_04" -- Standard, falls nicht definiert
|
|
|
|
print("Verwende Batteriemodell: " .. batteryModel)
|
|
|
|
-- Lade das Modell
|
|
RequestModel(GetHashKey(batteryModel))
|
|
while not HasModelLoaded(GetHashKey(batteryModel)) do
|
|
Wait(10)
|
|
end
|
|
|
|
-- Erstelle die Batterie
|
|
local battery = CreateObject(GetHashKey(batteryModel),
|
|
coords.x, coords.y, coords.z - 0.5, -- Leicht in den Boden eingelassen
|
|
true, true, false)
|
|
|
|
-- Stelle die Batterie richtig auf den Boden
|
|
PlaceObjectOnGroundProperly(battery)
|
|
FreezeEntityPosition(battery, true)
|
|
|
|
-- Warte kurz, damit die Batterie sichtbar ist
|
|
Wait(500)
|
|
|
|
-- Lade die Feuerwerkseffekte
|
|
local ptfxAssets = {
|
|
"scr_indep_fireworks",
|
|
"proj_xmas_firework",
|
|
"proj_indep_firework_v2",
|
|
"proj_indep_firework"
|
|
}
|
|
|
|
for _, asset in ipairs(ptfxAssets) do
|
|
RequestNamedPtfxAsset(asset)
|
|
while not HasNamedPtfxAssetLoaded(asset) do
|
|
Wait(10)
|
|
end
|
|
end
|
|
|
|
-- Füge einen Zündungseffekt hinzu (kleiner Funke statt Flamme)
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local ignitionEffect = StartParticleFxLoopedOnEntity("scr_indep_firework_sparkle_spawn",
|
|
battery, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.5, false, false, false)
|
|
|
|
-- Zündungsgeräusch
|
|
PlaySoundFromEntity(-1, "DISTANT_FIREWORK_LAUNCH_01", battery, "dlc_sum20_beach_party_sounds", true, 20)
|
|
|
|
-- Warte kurz für den Zündungseffekt
|
|
Wait(1000)
|
|
|
|
-- Stoppe den Zündungseffekt
|
|
StopParticleFxLooped(ignitionEffect, 0)
|
|
|
|
-- Bestimme die Anzahl der Schüsse basierend auf dem Item
|
|
local numShots = 15 -- Standard
|
|
|
|
if itemName == "firework3" then
|
|
numShots = 30 -- Mehr Schüsse für firework3 (große Batterie)
|
|
elseif itemName == "firework2" then
|
|
numShots = 15 -- Standard für firework2
|
|
end
|
|
|
|
print("Starte Feuerwerks-Batterie mit " .. numShots .. " Schüssen")
|
|
|
|
-- Starte die Feuerwerksschüsse
|
|
for i = 1, numShots do
|
|
-- Bestimme die Höhe und Position des Schusses
|
|
local height = math.random(30, 50)
|
|
local offsetX = math.random(-10, 10) * (i / numShots) -- Größere Streuung bei späteren Schüssen
|
|
local offsetY = math.random(-10, 10) * (i / numShots)
|
|
|
|
-- Starteffekt (kleiner Funke statt Flamme)
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
StartParticleFxNonLoopedAtCoord("scr_indep_firework_sparkle_spawn",
|
|
coords.x, coords.y, coords.z + 0.5,
|
|
0.0, 0.0, 0.0,
|
|
0.8, false, false, false)
|
|
|
|
-- Abschussgeräusch
|
|
PlaySoundFromEntity(-1, "DISTANT_FIREWORK_LAUNCH_01", battery, "dlc_sum20_beach_party_sounds", true, 20)
|
|
|
|
-- Warte kurz für den visuellen Effekt des Aufstiegs
|
|
Wait(math.random(100, 200))
|
|
|
|
-- Explosionseffekt in der Luft (nur Partikel, keine echte Explosion)
|
|
local explosionHeight = coords.z + height
|
|
|
|
-- Wähle einen zufälligen Effekt aus der Liste
|
|
local effectIndex = math.random(1, #fireworkEffects)
|
|
local effect = fireworkEffects[effectIndex]
|
|
|
|
-- Bestimme das richtige Asset für diesen Effekt
|
|
local effectAsset = "scr_indep_fireworks" -- Standard
|
|
|
|
if effect:find("xmas") then
|
|
effectAsset = "proj_xmas_firework"
|
|
elseif effect:find("indep_burst") or effect:find("indep_spiral") or effect:find("indep_ring") then
|
|
effectAsset = "proj_indep_firework_v2"
|
|
elseif effect:find("flare") then
|
|
effectAsset = "proj_indep_firework"
|
|
end
|
|
|
|
-- Starte den Haupteffekt
|
|
UseParticleFxAssetNextCall(effectAsset)
|
|
StartParticleFxNonLoopedAtCoord(
|
|
effect,
|
|
coords.x + offsetX, coords.y + offsetY, explosionHeight,
|
|
0.0, 0.0, 0.0,
|
|
math.random(20, 30) / 10, -- Größere Skalierung für bessere Sichtbarkeit
|
|
false, false, false
|
|
)
|
|
|
|
-- Füge zusätzliche Effekte für mehr Volumen hinzu
|
|
for j = 1, 2 do
|
|
local subOffsetX = math.random(-3, 3)
|
|
local subOffsetY = math.random(-3, 3)
|
|
local subOffsetZ = math.random(-3, 3)
|
|
|
|
-- Wähle einen anderen zufälligen Effekt
|
|
local subEffectIndex = math.random(1, #fireworkEffects)
|
|
local subEffect = fireworkEffects[subEffectIndex]
|
|
|
|
-- Bestimme das richtige Asset für diesen Effekt
|
|
local subEffectAsset = "scr_indep_fireworks" -- Standard
|
|
|
|
if subEffect:find("xmas") then
|
|
subEffectAsset = "proj_xmas_firework"
|
|
elseif subEffect:find("indep_burst") or subEffect:find("indep_spiral") or subEffect:find("indep_ring") then
|
|
subEffectAsset = "proj_indep_firework_v2"
|
|
elseif subEffect:find("flare") then
|
|
subEffectAsset = "proj_indep_firework"
|
|
end
|
|
|
|
UseParticleFxAssetNextCall(subEffectAsset)
|
|
StartParticleFxNonLoopedAtCoord(
|
|
subEffect,
|
|
coords.x + offsetX + subOffsetX,
|
|
coords.y + offsetY + subOffsetY,
|
|
explosionHeight + subOffsetZ,
|
|
0.0, 0.0, 0.0,
|
|
math.random(15, 25) / 10,
|
|
false, false, false
|
|
)
|
|
end
|
|
|
|
-- Explosionsgeräusch
|
|
PlaySoundFromCoord(-1, "DISTANT_FIREWORK_BURST_0" .. math.random(1, 3),
|
|
coords.x + offsetX, coords.y + offsetY, explosionHeight,
|
|
"dlc_sum20_beach_party_sounds", true, 50, false)
|
|
|
|
-- Warte zwischen den Schüssen
|
|
-- Schnellere Abfolge gegen Ende für ein Finale
|
|
local waitTime = 0
|
|
if i < numShots * 0.7 then
|
|
waitTime = math.random(300, 800)
|
|
else
|
|
waitTime = math.random(100, 300)
|
|
end
|
|
Wait(waitTime)
|
|
end
|
|
|
|
-- Warte nach dem letzten Schuss
|
|
Wait(2000)
|
|
|
|
-- Finale mit mehreren gleichzeitigen Effekten
|
|
for i = 1, 8 do
|
|
local finalOffsetX = math.random(-15, 15)
|
|
local finalOffsetY = math.random(-15, 15)
|
|
local finalHeight = math.random(30, 50)
|
|
|
|
-- Wähle einen zufälligen Effekt für das Finale
|
|
local finalEffectIndex = math.random(1, #fireworkEffects)
|
|
local finalEffect = fireworkEffects[finalEffectIndex]
|
|
|
|
-- Bestimme das richtige Asset für diesen Effekt
|
|
local finalEffectAsset = "scr_indep_fireworks" -- Standard
|
|
|
|
if finalEffect:find("xmas") then
|
|
finalEffectAsset = "proj_xmas_firework"
|
|
elseif finalEffect:find("indep_burst") or finalEffect:find("indep_spiral") or finalEffect:find("indep_ring") then
|
|
finalEffectAsset = "proj_indep_firework_v2"
|
|
elseif finalEffect:find("flare") then
|
|
finalEffectAsset = "proj_indep_firework"
|
|
end
|
|
|
|
UseParticleFxAssetNextCall(finalEffectAsset)
|
|
StartParticleFxNonLoopedAtCoord(
|
|
finalEffect,
|
|
coords.x + finalOffsetX,
|
|
coords.y + finalOffsetY,
|
|
coords.z + finalHeight,
|
|
0.0, 0.0, 0.0,
|
|
math.random(25, 35) / 10, -- Größere Skalierung für das Finale
|
|
false, false, false
|
|
)
|
|
|
|
-- Finale-Geräusch
|
|
PlaySoundFromCoord(-1, "DISTANT_FIREWORK_BURST_0" .. math.random(1, 3),
|
|
coords.x + finalOffsetX, coords.y + finalOffsetY, coords.z + finalHeight,
|
|
"dlc_sum20_beach_party_sounds", true, 50, false)
|
|
|
|
Wait(100)
|
|
end
|
|
|
|
-- Lösche die Batterie nach einer Weile
|
|
Wait(5000)
|
|
DeleteEntity(battery)
|
|
end
|
|
|
|
local function DrawText3D(x, y, z, text)
|
|
SetTextScale(0.35, 0.35)
|
|
SetTextFont(4)
|
|
SetTextProportional(true)
|
|
SetTextColour(255, 255, 255, 215)
|
|
BeginTextCommandDisplayText('STRING')
|
|
SetTextCentre(true)
|
|
AddTextComponentSubstringPlayerName(text)
|
|
SetDrawOrigin(x, y, z, 0)
|
|
EndTextCommandDisplayText(0.0, 0.0)
|
|
local factor = (string.len(text)) / 370
|
|
DrawRect(0.0, 0.0 + 0.0125, 0.017 + factor, 0.03, 0, 0, 0, 75)
|
|
ClearDrawOrigin()
|
|
end
|
|
|
|
local function fireworkText()
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(0)
|
|
if fireworkTime > 0 and fireworkLoc then
|
|
DrawText3D(fireworkLoc.x, fireworkLoc.y, fireworkLoc.z, Lang:t('firework.time_left') .. fireworkTime)
|
|
end
|
|
if fireworkTime <= 0 then break end
|
|
end
|
|
end)
|
|
end
|
|
|
|
-- Verbesserte Feuerwerk-Startfunktion
|
|
local function startFirework(asset, coords, itemName)
|
|
fireworkTime = Config.Fireworks.delay
|
|
fireworkLoc = { x = coords.x, y = coords.y, z = coords.z }
|
|
|
|
CreateThread(function()
|
|
fireworkText()
|
|
while fireworkTime > 0 do
|
|
Wait(1000)
|
|
fireworkTime = fireworkTime - 1
|
|
end
|
|
|
|
print("Countdown beendet, starte Feuerwerk: " .. itemName)
|
|
|
|
-- Wähle die richtige Feuerwerksart basierend auf dem Item
|
|
if itemName == "firework1" then
|
|
-- Rakete für firework1
|
|
launchFireworkRocket(coords)
|
|
elseif itemName == "firework4" then
|
|
-- Kreischende Fontäne für firework4
|
|
launchFireworkFountain(coords)
|
|
else
|
|
-- Batterie für alle anderen
|
|
startFireworkBattery(coords, itemName)
|
|
end
|
|
|
|
fireworkLoc = nil
|
|
end)
|
|
end
|
|
|
|
-- Animation für das Anzünden mit Feuerzeug
|
|
local function playLighterAnimation()
|
|
local ped = PlayerPedId()
|
|
|
|
-- Lade die Animation
|
|
RequestAnimDict("anim@mp_player_intmenu@key_fob@")
|
|
while not HasAnimDictLoaded("anim@mp_player_intmenu@key_fob@") do
|
|
Wait(10)
|
|
end
|
|
|
|
-- Spiele die Animation ab
|
|
TaskPlayAnim(ped, "anim@mp_player_intmenu@key_fob@", "fob_click", 3.0, 3.0, -1, 49, 0, false, false, false)
|
|
|
|
-- Erstelle ein Feuerzeug-Objekt in der Hand
|
|
local coords = GetEntityCoords(ped)
|
|
local lighter = CreateObject(GetHashKey("prop_cs_lighter_01"), coords.x, coords.y, coords.z, true, true, true)
|
|
AttachEntityToEntity(lighter, ped, GetPedBoneIndex(ped, 57005), 0.1, 0.05, 0.0, -60.0, 0.0, 0.0, true, true, false, true, 1, true)
|
|
|
|
-- Füge einen kleinen Funkeneffekt statt Flamme hinzu
|
|
RequestNamedPtfxAsset("scr_indep_fireworks")
|
|
while not HasNamedPtfxAssetLoaded("scr_indep_fireworks") do
|
|
Wait(10)
|
|
end
|
|
|
|
UseParticleFxAssetNextCall("scr_indep_fireworks")
|
|
local spark = StartParticleFxLoopedOnEntity("scr_indep_firework_sparkle_spawn", lighter, 0.0, 0.0, 0.15, 0.0, 0.0, 0.0, 0.15, false, false, false)
|
|
|
|
-- Warte 2 Sekunden
|
|
Wait(2000)
|
|
|
|
-- Stoppe die Animation und lösche das Feuerzeug
|
|
StopAnimTask(ped, "anim@mp_player_intmenu@key_fob@", "fob_click", 1.0)
|
|
StopParticleFxLooped(spark, 0)
|
|
DeleteEntity(lighter)
|
|
end
|
|
|
|
-- Überprüfe, ob der Spieler ein Feuerzeug hat
|
|
local function hasLighter()
|
|
local hasItem = QBCore.Functions.HasItem("lighter")
|
|
return hasItem
|
|
end
|
|
|
|
RegisterNetEvent('fireworks:client:UseFirework', function(itemName, assetName)
|
|
print("Feuerwerk-Event ausgelöst mit Item: " .. itemName)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
QBCore.Functions.Progressbar('spawn_object', Lang:t('firework.place_progress'), 3000, false, true, {
|
|
disableMovement = true,
|
|
disableCarMovement = true,
|
|
disableMouse = false,
|
|
disableCombat = true,
|
|
}, {
|
|
animDict = 'anim@narcotics@trash',
|
|
anim = 'drop_front',
|
|
flags = 16,
|
|
}, {}, {}, function() -- Done
|
|
StopAnimTask(PlayerPedId(), 'anim@narcotics@trash', 'drop_front', 1.0)
|
|
TriggerServerEvent('consumables:server:UseFirework', itemName)
|
|
TriggerEvent('qb-inventory:client:ItemBox', QBCore.Shared.Items[itemName], 'remove')
|
|
local pos = GetEntityCoords(PlayerPedId())
|
|
|
|
print("Feuerwerk platziert, beginne Anzündung")
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte das Feuerwerk mit dem Itemnamen
|
|
startFirework(assetName, pos, itemName)
|
|
end, function() -- Cancel
|
|
StopAnimTask(PlayerPedId(), 'anim@narcotics@trash', 'drop_front', 1.0)
|
|
QBCore.Functions.Notify(Lang:t('firework.canceled'), 'error')
|
|
end)
|
|
end)
|
|
|
|
-- Test-Befehl für verschiedene Feuerwerkstypen
|
|
RegisterCommand('feuerwerk', function(source, args)
|
|
local playerPed = PlayerPedId()
|
|
local coords = GetEntityCoords(playerPed)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
-- Item-Name als Argument
|
|
local itemName = args[1] or "firework1"
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte das passende Feuerwerk
|
|
if itemName == "firework1" then
|
|
launchFireworkRocket(coords)
|
|
elseif itemName == "firework4" then
|
|
launchFireworkFountain(coords)
|
|
else
|
|
startFireworkBattery(coords, itemName)
|
|
end
|
|
end)
|
|
|
|
-- Spezielle Test-Befehle für die verschiedenen Feuerwerkstypen
|
|
RegisterCommand('rakete', function()
|
|
local playerPed = PlayerPedId()
|
|
local coords = GetEntityCoords(playerPed)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte die Rakete (firework1)
|
|
launchFireworkRocket(coords)
|
|
end)
|
|
|
|
RegisterCommand('batterie', function()
|
|
local playerPed = PlayerPedId()
|
|
local coords = GetEntityCoords(playerPed)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte die Standard-Batterie (firework2)
|
|
startFireworkBattery(coords, "firework2")
|
|
end)
|
|
|
|
RegisterCommand('grossebatterie', function()
|
|
local playerPed = PlayerPedId()
|
|
local coords = GetEntityCoords(playerPed)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte die große Batterie (firework3)
|
|
startFireworkBattery(coords, "firework3")
|
|
end)
|
|
|
|
RegisterCommand('fontaene', function()
|
|
local playerPed = PlayerPedId()
|
|
local coords = GetEntityCoords(playerPed)
|
|
|
|
-- Überprüfe zuerst, ob der Spieler ein Feuerzeug hat
|
|
if not hasLighter() then
|
|
QBCore.Functions.Notify(Lang:t('firework.no_lighter'), 'error')
|
|
return
|
|
end
|
|
|
|
-- Spiele die Feuerzeug-Animation ab
|
|
playLighterAnimation()
|
|
|
|
-- Starte die kreischende Fontäne (firework4)
|
|
launchFireworkFountain(coords)
|
|
end)
|
|
|