Elle est bien pratique cette fonction, je commence à comprendre les timers
Si ça peut servir à quelqu'un, j'ai rajouté des options à cette fonction (pour m'entraîner): on peut maintenant choisir un facteur appelé imp, en appelant la fonction. Si il est supérieur à 0.00, l'unité sera projetée dans les airs.
J'ai également rajouté des effets spéciaux en fonction du terrain et de ce facteur (en gros si l'unité est projetée en l'air ou non, et si non, si elle est sur le sol ou dans l'eau).
library systeme needs TimerUtils
globals
private constant real TIMEOUT = 0.02
private constant integer TYPE = 'hpea'
private unit TEST = null
//ajouts=================
private constant integer RAVEN = 'Amrf' //Code de base de la compétence forme de corbeau
//Les effets en fonction du type de sol (eau/sol) et si l'unité est projetée (air)
private constant string fx_eau = "Objects\\Spawnmodels\\Naga\\NagaDeath\\NagaDeath.mdl"
private constant string fx_air = "Abilities\\Weapons\\PhoenixMissile\\Phoenix_Missile_mini.mdl"
private constant string fx_sol = "Objects\\Spawnmodels\\Undead\\ImpaleTargetDust\\ImpaleTargetDust.mdl"
//=================
// TIMEOUT = l'intervalle de temps entre chaque déplacement, augmentez-le si ça lag
// TEST = unité qui va nous servir pour déterminer si le prochain déplacement est possible
// TYPE = le type d'unité qui sera utilisée pour déterminer si le prochain déplacement est possible
// plus la valeur de sa Taille Collision est faible, plus c'est joli, là c'est le paysan qui a une taille de 16.0
// le mieux est de mettre une unité personnalisée avec une taille de 8.0
endglobals
//==========================================================================================
// Permet de savoir si le prochain déplacement de l'unité est possible ou pas
private function IsPointPathableForUnit takes real x, real y, unit whichUnit returns boolean
local real tx = 0
local real ty = 0
call ShowUnit(whichUnit, false)
if TEST == null then
set TEST = CreateUnit(Player(15), TYPE, 0.0, 0.0, 0.0)
else
call ShowUnit(TEST, true)
endif
call SetUnitPosition(TEST, x, y)
set tx = GetUnitX(TEST)
set ty = GetUnitY(TEST)
call ShowUnit(TEST, false)
call ShowUnit(whichUnit,true)
return (x == tx and y == ty)
endfunction
//==========================================================================================
// Déclaration d'une struct, une sorte de "super" variable.
// On peut stocker plusieurs variables de plusieurs types dans une struct, puis l'utiliser comme n'importe quel autre type de variable.
struct recul_st
unit target
real angle
integer distance
integer vit
integer i
real imp
effect fx = null
endstruct
// dans un trigger les membres d'une struct (les variables qui y sont stockées) sont désignées par nomdelastruct.nomdelavariable
// par exemple pour la variable target stockée dans la struct st ce serait st.target
// fonction appelée à chaque fois que le timer de la fonction Recul expire
private function Action takes nothing returns nothing
local timer t = GetExpiredTimer() // on récupère le timer de la fonction Recul qui a expiré
local recul_st st = GetTimerData(t) // on récupère la struct attaché au timer qu'on vient de récupérer (via TimerUtils)
local real newX = GetUnitX(st.target) + st.vit*Cos(st.angle)
local real newY = GetUnitY(st.target) + st.vit*Sin(st.angle)
//ajouts=================
local real z = GetUnitFlyHeight(st.target) //La hauteur de l'unité au moment du knockback
local real newz = 0.00
local string fx //Le futur effet spécial
//=================
// tant que le nombre de déplacement ne dépasse le nombre fixé et si le pathing du terrain lui permet, on déplace l'unité
if (st.i < st.distance) and IsPointPathableForUnit(newX, newY, st.target) then
set st.i = st.i + 1 // on incrémente le compteur du nombre de déplacement
call SetUnitPosition(st.target, newX, newY) // on déplace l'unité
//ajouts=================
//Toujours tant que le temps de déplacement ne dépasse pas le nombre fixé et si le pathing du terrain lui permet
if st.imp > 0.00 then //Si le facteur d'impulsion est positif, c-à-d on veut que l'unité soit projetée
if (st.i < (st.distance * 0.5)) then //Si le temps du knockback est inférieur à la moitié
set newz = z + (st.distance * st.imp)//On augmente la hauteur en fonction de l'impulsion
else
set newz = z - (st.distance * st.imp)//Sinon on la diminue
endif
call SetUnitFlyHeight(st.target, newz, 0.00)
else
endif
//Fonction qui attribue l'effet spécial en fonction du terrain et de imp>0 ou pas
if newz > 0.00 then
set fx = fx_air
call DestroyEffect(AddSpecialEffectTarget(fx, st.target, "origin"))
else
if not (IsTerrainPathable(newX,newY,PATHING_TYPE_FLOATABILITY)) then
set fx = fx_eau
call DestroyEffect(AddSpecialEffectTarget(fx, st.target, "origin"))//Attribue l'effet créé en fonction du retour
else
endif
if not (IsTerrainPathable(newX,newY,PATHING_TYPE_WALKABILITY)) then
set fx = fx_sol
call DestroyEffect(AddSpecialEffectTarget(fx, st.target, "origin"))//Attribue l'effet créé en fonction du retour
else
endif
endif
//=================
else // actions à effectuer dés que la distance de recul a été atteinte
call SetUnitPathing( st.target, true)
//ajouts=================
call UnitRemoveAbility( st.target, RAVEN) //On enlève forme de corbeau
//=================
call ReleaseTimer(t) // correspond à la "libération" du timer, à son recyclage pour une utilisation ultérieure
call st.destroy() // on détruit la struct
endif
endfunction
//==========================================================================================
// la fonction que vous appellerez dans vos déclencheurs sous la forme
// call Recul(x, y, target, distance, vit)
// x et y = coordonnée X et Y du point d'origine du recul
// target = la cible visée par le recul
// distance = la distance de recul
// vit = la vitesse de recul (~20 pour un bon effet)
//ajouts=================
//imp =Le facteur de hauteur. Quand égal 0, il n'y a pas de projection de l'unité en l'air. A 0.50, l'unité effectue un saut elevé.
//=================
function Recul takes real x, real y, unit target, integer distance, integer vit, real imp returns nothing
local timer t = NewTimer() // création d'un nouveau timer
local recul_st st = recul_st.create() // création d'une struct du type recul_st déclarée plus haut
call SetUnitPathing( target, false)
set st.target = target // la cible du recul
set st.angle = Atan2(GetUnitY(target) - y, GetUnitX(target) - x) // l'angle selon lequel elle sera déplacée
set st.distance = distance/vit // le nombre de fois qu'elle sera déplacée
set st.vit = vit // la vitesse de ce déplacement
set st.i = 0 // on initialise le compteur du nombre de déplacement
//ajouts=================
set st.imp = imp //Le facteur de hauteur
//=================
call SetTimerData(t, st) // on stocke la struct en l'attachant au timer créé (via TimerUtils)
call TimerStart (t, TIMEOUT, true, function Action ) // on démarre le timer périodique qui lancera le déplacement autant de fois que prévu
//ajouts=================
call UnitAddAbility(st.target, RAVEN) //On donne forme de corbeau à l'unité pour qu'elle puisse voler
//=================
Brissou de Mourièssou Créateur de sorts, depuis 1936.
Inscrit le: 30 Aoû 2007 Messages: 1510 Sujets: 26 Spécialité en worldedit: Développer des jeux vidéos pour le fun, donc world edit c'est comme faire une addition. Médailles: 2 (En savoir plus...)
Posté le: 12/02/09 13:31 Sujet du message:
Il vaut mieux diviser le vol de l'unité en 4 parties pour avoir une allure plus proche d'une courbe et des calculs minimales, bizarrement tu changes la hauteur à chaque itération pour une augmentation constante. Ca serait plus simple et naturel dans ce cas de modifier la hauteur selon une durée et non pas instantanément.
Pas bête les effets spéciaux en fonction du type de sol. _________________
Les effets: l'idée ne vient pas de moi, mais d'un système de recul sur le site thehelpers.net =) Je n'ai fait que récupérer cette idée, adapter au système de Rhadamante. Et rajouter la notion de saut du saut en Gui de Rommstein.
Effectivement une vrai parabole serait plus jolie. Seulement dans les cas où je m'en sers, la vitesse de recul permet de se passer de cette notion. Je regarderais si je peux faire mieux. _________________
Ce n'est que mon avis personnel, mais je préfère avoir deux fonctions, une pour le recul, une pour le saut. C'est beaucoup plus pratique, même si un peu plus lourd. _________________
Brissou de Mourièssou Créateur de sorts, depuis 1936.
Inscrit le: 30 Aoû 2007 Messages: 1510 Sujets: 26 Spécialité en worldedit: Développer des jeux vidéos pour le fun, donc world edit c'est comme faire une addition. Médailles: 2 (En savoir plus...)
Posté le: 16/02/09 15:36 Sujet du message:
Perso je fait comme Apocalypse, c'est plus pratique de combiner les 2. Juste un paramètre à ajouter lorsqu'on appelle la fonction. Par contre ça laisse moins de possibilité, si on veut des sauts plus étranges... _________________
Waip. Du coup je prend ce système et je le modifie selon l'effet désiré. Exemple pour mon gravity gun dans RC601. Il utilise deux mélanges de ce système et d'un troisième pour les lightnings. _________________
Toutes les heures sont au format GMT + 1 Heure Aller à la page Précédente1, 2, 3
Page 3 sur 3
Vous ne pouvez pas poster de nouveaux sujets dans ce forum Vous ne pouvez pas répondre aux sujets dans ce forum Vous ne pouvez pas éditer vos messages dans ce forum Vous ne pouvez pas supprimer vos messages dans ce forum Vous ne pouvez pas voter dans les sondages de ce forum