System Smooth Unit Modification

[kingkingyyk3]

You can include the Zinc as long as vJass still there.

 

[Komaqtion]

Well, doesn't really matter, as I don't have time to learn Zinc atm...

 

[Uberplayer]

If it compiles, ship it.

library SmoothUnitMod requires T32, UnitAppearance

//===========================================================================

    private function interface ModificationFunction takes unit whichUnit, real increment returns nothing

    private function SetScale takes unit whichUnit, real increment returns nothing
        call ModifyUnitScale(whichUnit, increment)
    endfunction
    
    private function SetA takes unit whichUnit, real increment returns nothing
        call ModifyUnitVertexColor(whichUnit, increment, 0.00, 0.00, 0.00)
    endfunction
    
    private function SetR takes unit whichUnit, real increment returns nothing
        call ModifyUnitVertexColor(whichUnit, 0.00, increment, 0.00, 0.00)
    endfunction
    
    private function SetG takes unit whichUnit, real increment returns nothing
        call ModifyUnitVertexColor(whichUnit, 0.00, 0.00, increment, 0.00)
    endfunction
    
    private function SetB takes unit whichUnit, real increment returns nothing
        call ModifyUnitVertexColor(whichUnit, 0.00, 0.00, 0.00, increment)
    endfunction
    
//===========================================================================

    struct SmoothMod
        
        private unit whichUnit
        private real increment
        private ModificationFunction modFunc
        
        //===========================================================================
    
        static method scale takes unit whichUnit, real duration, real value returns nothing
            local SmoothMod sm = SmoothMod.allocate()
            
            set sm.whichUnit = whichUnit
            set sm.increment = value / duration * T32_PERIOD
            set sm.modFunc = SetScale
            
            set sm.ticks = R2I(duration / T32_PERIOD)
            call sm.startPeriodic()
        endmethod
        
        static method alpha takes unit whichUnit, real duration, real value returns nothing
            local SmoothMod sm = SmoothMod.allocate()
            
            set sm.whichUnit = whichUnit
            set sm.increment = value / duration * T32_PERIOD
            set sm.modFunc = SetA
            
            set sm.ticks = R2I(duration / T32_PERIOD)
            call sm.startPeriodic()
        endmethod
        
        
        static method red takes unit whichUnit, real duration, real value returns nothing
            local SmoothMod sm = SmoothMod.allocate()
            
            set sm.whichUnit = whichUnit
            set sm.increment = value / duration * T32_PERIOD
            set sm.modFunc = SetR
            
            set sm.ticks = R2I(duration / T32_PERIOD)
            call sm.startPeriodic()
        endmethod
        
        
        static method green takes unit whichUnit, real duration, real value returns nothing
            local SmoothMod sm = SmoothMod.allocate()
            
            set sm.whichUnit = whichUnit
            set sm.increment = value / duration * T32_PERIOD
            set sm.modFunc = SetG
            
            set sm.ticks = R2I(duration / T32_PERIOD)
            call sm.startPeriodic()
        endmethod
        
        
        static method blue takes unit whichUnit, real duration, real value returns nothing
            local SmoothMod sm = SmoothMod.allocate()
            
            set sm.whichUnit = whichUnit
            set sm.increment = value / duration * T32_PERIOD
            set sm.modFunc = SetB
            
            set sm.ticks = R2I(duration / T32_PERIOD)
            call sm.startPeriodic()
        endmethod
        
        //===========================================================================
        
        implement T32
        
        private integer ticks
        
        private method periodic takes nothing returns boolean
            set this.ticks = this.ticks - 1
            if this.ticks <= 0 then
                call this.destroy()
                return true
            else
                call this.modFunc.execute(this.whichUnit, this.increment)
                return false
            endif
        endmethod
    
    endstruct

endlibrary

There you go. Did not test, but in theory it should work since it's the same as my Zinc version.

 

[Komaqtion]

Ok, well I'd rather get some more thought on it before I completely redo that library XD

Any1 else who thinks Uberplayer's approach is better ? :S

 

[Immolation]

Me
That's why I asked help to him...

I'm sorry

 

[Komaqtion]

Is every1 sure I should just C&P Uberplayer's version ? :S
(In a way I really don't wanna do this, since then it isn't really my library )

 

[Jesus4Lyf]

I am sure you should not. Why do you want to do this?

Edit: You should just change your struct to use reals, since it is used with a periodic effect in small increments:

            set this.alpha = 255
            set this.red = 255
            set this.green = 255
            set this.blue = 255

Nice thought using the ints with 255, but a nicer interface and better accuracy may come with using reals between 0 and 1.0.

 

[Komaqtion]

Yeah, I know...
I thought so too XD

EDIT: Nah, wait a minute...
I don't really like that at all, maybe I can do a different function which uses it ? :S

Since the native takes integers, and wouldn't that just slow it down ? :S

 

[Viikuna]

Yep.

But thats not really a problem, so you can just ignore it.

Using reals when doing that smooth modification stuff is a good idea.

 

[Komaqtion]

But then would you (When you use the "GetUnitColor" stuff) would you get 255, or 1.0 for full ? :S

And also, where should I then do the R2I conversion for maximum speed ? :S

 

[Jesus4Lyf]

Priorities:

1. Things actually working.
2. Maximum speed.

And there is a large gap between them. Integers will round incorrectly, for example, changing a unit's colour by 30 over 1 second will probably not work at all since dividing by 32 would cause it to round down to 0 change per tick.

So I say convert to integer right where you call the native.

 

[Komaqtion]

Ok, will change that then !

Any other suggestions, or can this be approved soon ? :S

 

[Komaqtion]

I'm actually becoming pretty irritated about these two submissions I've got here !
I've recieved a lot of help, and both of these have gotten updated [a lot] !!!
I just don't see why it can't be approved ?!

 

[Jesus4Lyf]

Ok, will change that then !

When?

        integer alpha
        integer red
        integer green
        integer blue

>I just don't see why it can't be approved ?!
It's a matter of moderator time, not a comment on the quality of your resource.

 

[Komaqtion]

Ok, sorry XD Changed now

 

[Executor]

What about letting the structs share "unit u" and "real incremet" via interface, the current way you have 6 for 2 arrays.

 

[Komaqtion]

Well, I don't really know what interface is, or at least not how to use it XD

 

[Weep]

It's broken, trying to return integers from reals without R2I. The members of Appearance are reals, yet GetUnitAlpha, etc. return integer.



[edit] Also, calling FadeUnitRGB twice in a row seems to crash the thread?

 

[Laiev]

It's broken, trying to return integers from reals without R2I. The members of Appearance are reals, yet GetUnitAlpha, etc. return integer.



[edit] Also, calling FadeUnitRGB twice in a row seems to crash the thread?

This system is too old... of course today he can do better things maybe can update it?

with better things

 

[Komaqtion]

Where is this broken, Weep ?! :S
I always use [ljass]R2I()[/ljass] where it's needed...

Show me where, please ?