Clan SliD Forum Index
Clan SliD Forum IndexFAQSearchRegisterLog in

[vjass] sinusoïdale moving version path

 
Post new topic   Reply to topic    Clan SliD Forum Index -> Worldedit -> Fonctions Jass
Previous topic :: Next topic  
Author Message
fulldragon
Membres
Membres

Offline

Joined: 16 Dec 2010
Posts: 1,294
Point(s): 50
Niveau de slide:

PostPosted: 05/11/2012, 23:31    Post subject: [vjass] sinusoïdale moving version path Reply with quote

Nom de la fonction : SinusoidalePathMoving
Créateur : Fulldragon
Fonctions requises : qu'dalle

Code:
library SinusoidalePathMoving
    globals
        private timer T = CreateTimer()
        private integer L = 0
        private Snake_path array Sp
        private constant real CASE_SIZE = 128
    endglobals
   
    private struct Path
        integer type_path
        integer size_case
        real x
        real y
       
        static method CreatePath takes real x, real y, integer type_path, integer size_case returns Path
            local Path pa = Path.create()
           
            set pa.type_path = type_path
            set pa.x = x
            set pa.y = y
            set pa.size_case = size_case
           
            call SetTerrainType(x, y, type_path, 0, size_case, 1)
                       
            return pa
        endmethod
    endstruct
   
    struct Snake_path
        integer init_type_path
        integer nb_case
        real amplitude
        real speed
        real angle
        real coef
        //if you want more than 200 units, change all theese array.
        real array compteur[200]
        Path array path[200]
       
        static method MovingSnakePath takes nothing returns nothing
            local integer i = 0
            local integer j
            local Snake_path s
            local real x
            local real X
            local real y
            local real Y
           
            loop
                exitwhen i == L
               
                set s = Sp[i]
                set j = 0
               
                loop
                    exitwhen j > s.nb_case
                   
                    set y = s.amplitude * SinBJ(s.coef * s.compteur[j])
                    set X = 0 * CosBJ(s.angle) - y * SinBJ(s.angle)
                    set Y = 0 * SinBJ(s.angle) + y * CosBJ(s.angle)
                   
                    call SetTerrainType(s.path[j].x + X, s.path[j].y + Y, s.init_type_path, 0, s.path[j].size_case, 1)

                    set j = j + 1
                endloop
               
                set j = 0
               
                loop
                    exitwhen j > s.nb_case
                   
                    set s.compteur[j] = s.compteur[j] + s.speed
                    set y = s.amplitude * SinBJ(s.coef * s.compteur[j])
                    set X = 0 * CosBJ(s.angle) - y * SinBJ(s.angle)
                    set Y = 0 * SinBJ(s.angle) + y * CosBJ(s.angle)
                   
                    call SetTerrainType(s.path[j].x + X, s.path[j].y + Y, s.path[j].type_path, 0, s.path[j].size_case, 1)
                   
                    set j = j + 1
                endloop
               
                set i = i + 1
            endloop
           
        endmethod
    endstruct
   
    function CreateSinusoidalePathSnake takes integer init_type_path, integer type_path, integer size_case, rect a, rect b, real amplitude, real nb_oscillation, real period_time returns Snake
        local integer i = 1
        local real angle = bj_RADTODEG * Atan2(GetRectCenterY(b) - GetRectCenterY(a), GetRectCenterX(b) - GetRectCenterX(a))
        local real dx = GetRectCenterX(b) - GetRectCenterX(a)
        local real dy = GetRectCenterY(b) - GetRectCenterY(a)
        local real lenght = SquareRoot(dx * dx + dy * dy)
        local real longueur_onde = lenght / (nb_oscillation - 1)
        local integer nb_case = R2I(lenght / (CASE_SIZE))
        local Snake_path s = Snake_path.create()
        local real x = 0
        local real X
        local real y
        local real Y
        local real coef = (7 * CASE_SIZE) / longueur_onde
       
        set Sp[L] = s
        set Sp[L].init_type_path = init_type_path
        set Sp[L].nb_case = nb_case
        set Sp[L].amplitude = amplitude
        set Sp[L].speed = period_time
        set Sp[L].coef = coef
        set Sp[L].angle = angle
        set Sp[L].path[0] = Path.CreatePath(GetRectCenterX(a), GetRectCenterY(a), type_path, size_case)
       
        loop
            exitwhen i > nb_case

            set x = x + CASE_SIZE
            set y = 0
            set X = x * CosBJ(angle) - y * SinBJ(angle)
            set Y = x * SinBJ(angle) + y * CosBJ(angle)
           
            set Sp[L].path[i] = Path.CreatePath(Sp[L].path[0].x + X, Sp[L].path[0].y + Y, type_path, size_case)
            set Sp[L].compteur[i] = i * CASE_SIZE
           
            set i = i + 1
        endloop
       
        set L = L + 1
       
        if L == 1 then
            call TimerStart(T, 0.1, true, function Snake_path.MovingSnakePath)
        endif
       
        return Sp[L-1]
    endfunction
endlibrary

Utilisation : Permet de créer un path en zig zag movible sur de longes distances.
Copyright : c'est libre de droit
Remarques : on ne peut pas dépasser 200 itérations, sauf en modifiant l'endroit marqué dans la structure du snake. de toute façon je doute que vous en créiez autant.


vous l'aurez remarqué, pas d'API ni de fonction de remove. j'en ai pas l'utilité dans ma map et j'ai la flemme de vous le faire gratis.


Back to top
Publicité






PostPosted: 05/11/2012, 23:31    Post subject: Publicité

PublicitéSupprimer les publicités ?
Back to top
Display posts from previous:   
Post new topic   Reply to topic    Clan SliD Forum Index -> Worldedit -> Fonctions Jass All times are GMT + 2 Hours
Page 1 of 1

 
Jump to:  

Index | Have own forum | Free support forum | Free forums directory | Report a violation | Conditions générales d'utilisation
darkages Template © larme d'ange
Powered by phpBB © 2001, 2005 phpBB Group