Mms 4d

[T. D. W.]

I did not understand anything OO
Or maybe cuz i'm at skl.. I'll try to see them at home..

 

[Malhorne]

We will use polymorphism.
Put every variables needed in every MMS.
Then put every specifics variables for each MMS
Then I'll start the coding

 

[T. D. W.]

I still have no idea of how this thing works.. But I'll do as requested.. Just a couple of minutes needed

 

[Malhorne]

No problem we're not in a rush AFAIK

 

[Malhorne]

I made this structure atm :

library MMS4D
    globals
        private constant real FPS = 0.0312500
    endglobals
    
    private struct MMS_Core extends array
        real x
        real y
        private thistype rn
        private static integer count
        private static thistype r
        
        method destroy takes nothing returns nothing
            set r = rn
            set r = this
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this
            if r==0 then
                set count = count + 1
                set this = count
            else
                set this = r
                set r = r.rn
            endif
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set count = 0
            set r = 0
        endmethod
    endstruct
    
    struct MMS_2D extends array
        delegate MMS_Core deleg
        private static integer dindex
        private static thistype array data
        
        method destroy takes nothing returns nothing
            call this.deleg.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.deleg = this
            return this
        endmethod
        
        method doSomething takes real x, real y returns nothing
            set this.x = x
            set this.y = y
        endmethod
        
        private static method onInit takes nothing returns nothing
            set dindex = -1
        endmethod
    endstruct
    
    struct MMS_3D extends array
        delegate MMS_Core core
        private static integer dindex
        private static thistype array data
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set dindex = -1
        endmethod
    endstruct
    
    struct MMS_4D extends array
        delegate MMS_Core core
        private static integer dindex
        private static thistype array data
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set dindex = -1
        endmethod
    endstruct
endlibrary

The code looks pretty ^^
The biggest bad point of this type is that we will have a maximum of 8190 KB from all different dimensions.

EDIT 1 : Implemented dynamic indexing, I think linked list will be a bit brain destruction in such code.

 

[T. D. W.]

What is this 8190KB about??!

 

[Vinz]

Op limit.

 

[Malhorne]

Jass array size = 8191

 

[T. D. W.]

oh ok, but what is the KB thing has to do in it

 

[Malhorne]

Struct use array behind

 

[T. D. W.]

In basic (All) i think you may add them to 2D since i guess 2D is the root of 3D and 4D

• KBed Unit
• Targeted Unit
• Damager
• EndFx
• AoEEndFx
• Fx
• Attach
• BounceFx
• LineFx
• Instances on unit
• BounceGroup
• LineDamageGroup
• DamageType
• AttackType
• IsUnitBeingKBed
• DisableUnit
• DestroyTrees
• IsSpeedPositive
• SpeedChanger
• HasBeenImpactDamaged
• KillWhenHit
• EndWhenHit
• FaceAngle
• KillIfOutsider
• AllowOutSiding
• EndWhenDead
• KBTarget
• AoEKB
• iKB
• KillatEnd
• D_STRUCTURE
• D_MECHANICAL
• D_MAGIC_IMMINUE
• D_ALLY
• D_ENEMEY
• D_RESISTANT
• D_FLYING
• DestroyDestructable
• BounceUnit
• BounceTarget
• EndOnObstacle
• EndOnTargetBounce
• UnitPropWindow
• ImpactDamage
• LoopDamage
• TargetDamage
• LineDamage
• AoE
• ArcAngle
• AoEDamage
• KillAtTime
• StopTime
• AiEEndDamage
• AoEEndDamage
• AoEKBPower
• BouncePower

• Range
• Speed
• Acceleration
• Angle
• Time

• IsZNotNull
• GroundDamage
• JumpOverCliff
• Zoffset
• ZSpeed
• ZAccel
• LastTerrainZ
• InitialTerrainZ
• UnitInitialHeight

• 4DEnabled (Boolean)
• 4DLapseTime (Real)
• 4DWasHidden (Boolean)
• 4DRippOff (Boolean)
• 4DBlackHole (Boolean)
• 4DAoE_3D (Real)
• 4D_RippOffDamage (Real)
• 4D_BlackHoleDPS (Real)
• 4D_RippOffSpeed (Real)
• 4D_BlackHoleSpeed (Real)
  

For more info on the variable types, see here

 

[Malhorne]

So maybe I'm merging core and 2D into 2D ?

EDIT : Nope. There is difference between 2D and core ^^

EDIT 2 : What means KBed unit ?

 

[T. D. W.]

Yes, if you use 2D as root Dimension (base)
Edit 1: oh ok
Edit 2: the unit that is being KBed xD

 

[Malhorne]

So what the difference with targeted unit ?

 

[T. D. W.]

The KBed unit moves forward to the Targeted unit, also the targeted unit is the target for some actions like Target Damage

 

[Vinz]

I don't know if this is the right place, probably not. If I use target KB from a high Z area, the Z remains and I have to fix it in the end trigger. Jad. GetLocationZ.

 

[T. D. W.]

1.9 supports terrain Z, I am not sure what you meant, but there shouldn't be any problem

 

[Malhorne]

I was reading -> No need to do 4D enable in member since in in globals we will put constant boolean and static if ^^

 

[Vinz]

But Jad, there is a problem everywhere. It's really discouraging. Let me upload a video.

 

[Malhorne]

I think we need the current system to work fully before doing the 4d xD

 

[T. D. W.]

1: malhone, the 4D enabled is the option that adds 4D to the Instance, like any other feature, not a global one
2: waitin the vid
3: I think the current system is fully working, but wrathion's problem is specific, not major to all the users, but anyway since we are making it from scratch, I think waiting for the first to work with wrathion is useless, working on MMS4D is better

 

[Malhorne]

OK I'll do the structure of the code this week-end I think.
Anyway I think the 4D enabled var is useless xD Because if the user don't want a 4D he will not instanciate a 4D X)

 

[Malhorne]

library MMS4D
    globals
        private constant real FPS = 0.0312500
        private constant boolean NEED_3D = true
        private constant boolean NEED_4D = true
        //Don't forget to implement other static if boolean :)
        
        private integer dindex = -1
        //Don't worry structs are integer. Store in this array :)
        private integer array data
    endglobals
    
    private struct MMS_Core extends array
        unit KBed_unit
        unit target
        unit damager
        string endFx
        string aoeEndFx
        string Fx
        string attach
        string bounceFx
        string lineFx
        //Wtf this one xD ? Can't we disable kb for an already existing kbed unit ?
        integer instanceOnUnit
        group bounceGroup
        group lineDamageGroup
        damagetype damageType
        attacktype attackType
        //Same there
        boolean isUnitKbed
        boolean disable
        boolean destroyTrees
        boolean isSpeedPositive
        boolean speedChanger
        boolean hasBeenImpactDamaged
        boolean killWhenHit
        boolean endWhenHit
        boolean faceAngle
        boolean killIfOutsider
        boolean allowOutSiding
        boolean endWhenDead
        boolean KBTarget
        boolean aoeKB
        boolean iKB
        boolean killAtEnd
        boolean D_Structure
        boolean D_Mechanical
        boolean D_MagicImmune
        boolean D_Ally
        boolean D_Enemy
        boolean D_Resistant
        boolean D_Flying
        boolean D_Destructable
        boolean bounceUnit
        boolean bounceTarget
        boolean endOnObstacle
        boolean endOnTargetBounce
        //No need to store unitpropwindow there is a solution :)
        //Btw the solution is GetUnitDefaultPropWindow(unit)*bj_RADTODEG
        real impactDamage
        real loopDamage
        real targetDamage
        real lineDamage
        real aoe
        real arcAngle
        real aoeDamage
        real killAtTimer
        real stopTime
        real aiEndDamage
        real aoeEndDamage
        real aoeKBDamage
        real aoeKBPower
        real bouncePower
        private thistype rn
        private static integer count
        private static thistype r
        
        method destroy takes nothing returns nothing
            set this.rn = r
            set r = this
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this
            if r==0 then
                set count = count + 1
                set this = count
            else
                set this = r
                set r = r.rn
            endif
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set count = 0
            set r = 0
        endmethod
    endstruct
    
    struct MMS_2D extends array
        real range
        real speed
        real accel
        real angle
        real time
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
    endstruct
    
    static if NEED_3D then
    //Now the code of the 3D
    struct MMS_3D extends array
        boolean isZNotNull
        real groundDamage
        boolean jumpOverCliff
        real zOffset
        real zSpeed
        real zAccel
        real lastTerrainZ
        real initTerrainZ
        real unitInitialHeight
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
    endstruct
    //End of the code of the 3D
    endif
    
    static if NEED_4D then
    //Now the code of the 4D
    struct MMS_4D extends array
        //What's the use of this one ?
        boolean enabled
        boolean lapseTime
        boolean wasHidden
        boolean rippOff
        boolean blackHole
        real aoe3D
        real rippOffDamage
        real blackHoleDamage
        real rippOffSpeed
        real blackHoleSpeed
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set dindex = -1
        endmethod
    endstruct
    //End of the code of the 4D
    endif
endlibrary

 

[T. D. W.]

What does delegate mean :?

And where to instance an instance xD (register it)
And if you can show a small example in the 2D section so i know how to work on this

 

[Malhorne]

Ah yes forgot to say that this is pure madness coding ^^
Even if the code looks pretty it is pure madness behind xD !

To instanciate a 2d :

local MMS_2D m = MMS_2D.create()
set m.KBed_unit = ..
set m.target = ...
set m.damager = ...
...
set m.range = ...
set m.speed = ...

For the moment you can just create and destroy struct ^^'
There is nothing more


EDIT : To be clear -> Delegate is a better version of extends.

 

[T. D. W.]

2 more questions:
1. If, for example, a member of 3D is used in 2D, what will happen? Compile error?
2. If 'I' want to code on this, do my work, where and how should i work

 

[Malhorne]

1. You can't use a member specific to 3D in a 2D one !
2. What do you mean ?
- Just don't touch to the members I privated.
- You can only add things to create/destroy don't remove/change anything.
- The delegate thingy means that every member (member and method) that are not private can be access from the struct.

 

[T. D. W.]

1. k lol
2. No not what i meant, if for example i wanted to add the blackhole feature to the 4D member, where to put it, and how to make it? I mean show me a small example or something

 

[Malhorne]

The blackhole is a special feature of the MMS_4D so you put it into the 4d
You add the method and everything.

Btw, members dindex and data are here for dynamic indexing.
Anyway I'm not really sure for the indexing, we will use it but I don't think we need so much things.
Since there is a limit of 8190 index.
Oh I got an idea. I'll make dindex and data globals in the library.

EDIT : I updated the code.

 

[T. D. W.]

Ok, just show me an example where you kill the unit in the 4D member
And 4D enabled is a feature, like for example:
The user has 2 KBs in his map, one that uses the 4D and one not, 4D enabled is to disable the 4D for on instance and not ALL

 

[Malhorne]

    static if NEED_4D then
    //Now the code of the 4D
    struct MMS_4D extends array
        //What's the use of this one ?
        boolean enabled
        boolean lapseTime
        boolean wasHidden
        boolean rippOff
        boolean blackHole
        real aoe3D
        real rippOffDamage
        real blackHoleDamage
        real rippOffSpeed
        real blackHoleSpeed
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            return this
        endmethod
        
        method test takes nothing returns nothing
            if this.KBed_unit != null then
                call KillUnit(this.KBed_unit)
            endif
        endmethod
    endstruct
    //End of the code of the 4D
    endif

 

[Malhorne]

Again updated the code reference in page 13 btw ^^

 

[T. D. W.]

Okay so, every fps seconds, the 4D member will run, and run this 'test' method? Like it runs by itself or i have to call it

 

[Malhorne]

Ah no !
I did nothing for the loop or for anything.

You have to call it like this :

local MMS_4D m = MMS_4D.create()
set m.KBed_unit = u
call m.test()
//DO NOT FORGET
call m.destroy()

 

[T. D. W.]

May i ask you to do the loop then (and the registration area [where the system changes the variables given to values for the KB] )

 

[Malhorne]

I don't really know how to do it atm because I don't know what methods we will use.
We will need first to do the func that every MMS will use

 

[T. D. W.]

Oh, it's easy, at least the part that i want you to do xD :
A method ( ? ) or something i don't know, like call m.apply , which will run a function/method/whatsoever in the system that will add an instance, just create this part and make it add an instance

^ that was the registration

And make a method ( ?) that runs on every FPS, just create it and i will do the rest

 

[Malhorne]

A method is a function that automatically takes a struct instance as parameters. Like m.apply will automatically take m as parameter. Static method are basic functions xD
But before we really need to know everything we'll put in every func more than before since we'll use the less code possible.

 

[T. D. W.]

Ok ok, if i'll have time tonight or tomorrow i'll see what to do, see ya for now, going back to study

 

[Malhorne]

Ok no problem
If you have questions I'll be up until 8pm (it is 6pm now) otherwise see ya tomorrow

 

[T. D. W.]

i'm trying to add some methods, but i have a question
there are some methods, that run in 2D, but will have more stuff in 3D, for instance, AoEEndKB will KB all units, if 3D is disabled, it will KB on the ground, if it is not, they will go flying, another one: Fx, which creates periodically an effect on the KBed unit, if the unit was flying, the effect will be created on him, if not, it will be created on it's location (well, this one doesn't really count but you got the idea of it)

SO, for those "core" methods, we will use static ifs in the areas that will need 3D, or something else?

PS: i changed the member name (KBed_unit) to Unit (since it will be used A LOT, and it is pain to write it like 100 times)

 

[T. D. W.]

And we will need:

a (New? if needed) Pathability system, collision system, and we will see if we will need anything else

 

[Malhorne]

IsTerrainPathable by Vex is good afaik ^^

Create a method for the 2d and one for the 3d is there difference.
Oh we can create a member in mms_core which hold the dimension and in the loop do in function of this member.

 

[T. D. W.]

IsTerrainPathable by Vex is good afaik ^^

link?

Create a method for the 2d and one for the 3d is there difference.

useless code

Oh we can create a member in mms_core which hold the dimension and in the loop do in function of this member.

wat!?

Create a method for the 2d and one for the 3d is there difference.
Oh we can create a member in mms_core which hold the dimension and in the loop do in function of this member.

i think it would be better if we do it like this:

method move_dimensionally takes nothing returns nothing
    call blablabla.. 2D stuff
    static if WANT_3D then
        call blachblach 3D stuff
    endif
endmethod

 

[Malhorne]

Static if will make the code unusable after the compile time.

In mms_core struct add a member called dim like this :

library MMS4D
    globals
        private constant real FPS = 0.0312500
        private constant boolean NEED_3D = true
        private constant boolean NEED_4D = true
        //Don't forget to implement other static if boolean :)
        
        private integer dindex = -1
        //Don't worry structs are integer. Store in this array :)
        private integer array data
    endglobals
    
    private struct MMS_Core extends array
        unit KBed_unit
        unit target
        unit damager
        string endFx
        string aoeEndFx
        string Fx
        string attach
        string bounceFx
        string lineFx
        //Wtf this one xD ? Can't we disable kb for an already existing kbed unit ?
        integer instanceOnUnit
        group bounceGroup
        group lineDamageGroup
        damagetype damageType
        attacktype attackType
        //Same there
        boolean isUnitKbed
        boolean disable
        boolean destroyTrees
        boolean isSpeedPositive
        boolean speedChanger
        boolean hasBeenImpactDamaged
        boolean killWhenHit
        boolean endWhenHit
        boolean faceAngle
        boolean killIfOutsider
        boolean allowOutSiding
        boolean endWhenDead
        boolean KBTarget
        boolean aoeKB
        boolean iKB
        boolean killAtEnd
        boolean D_Structure
        boolean D_Mechanical
        boolean D_MagicImmune
        boolean D_Ally
        boolean D_Enemy
        boolean D_Resistant
        boolean D_Flying
        boolean D_Destructable
        boolean bounceUnit
        boolean bounceTarget
        boolean endOnObstacle
        boolean endOnTargetBounce
        //No need to store unitpropwindow there is a solution :)
        //Btw the solution is GetUnitDefaultPropWindow(unit)*bj_RADTODEG
        real impactDamage
        real loopDamage
        real targetDamage
        real lineDamage
        real aoe
        real arcAngle
        real aoeDamage
        real killAtTimer
        real stopTime
        real aiEndDamage
        real aoeEndDamage
        real aoeKBDamage
        real aoeKBPower
        real bouncePower
        integer dim
        private thistype rn
        private static integer count
        private static thistype r
        
        method destroy takes nothing returns nothing
            set this.rn = r
            set r = this
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this
            if r==0 then
                set count = count + 1
                set this = count
            else
                set this = r
                set r = r.rn
            endif
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set count = 0
            set r = 0
        endmethod
    endstruct
    
    struct MMS_2D extends array
        real range
        real speed
        real accel
        real angle
        real time
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            set this.dim = 2
            return this
        endmethod
    endstruct
    
    static if NEED_3D then
    //Now the code of the 3D
    struct MMS_3D extends array
        boolean isZNotNull
        real groundDamage
        boolean jumpOverCliff
        real zOffset
        real zSpeed
        real zAccel
        real lastTerrainZ
        real initTerrainZ
        real unitInitialHeight
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            set this.dim = 3
            return this
        endmethod
    endstruct
    //End of the code of the 3D
    endif
    
    static if NEED_4D then
    //Now the code of the 4D
    struct MMS_4D extends array
        //What's the use of this one ?
        boolean enabled
        boolean lapseTime
        boolean wasHidden
        boolean rippOff
        boolean blackHole
        real aoe3D
        real rippOffDamage
        real blackHoleDamage
        real rippOffSpeed
        real blackHoleSpeed
        delegate MMS_Core core
        
        method destroy takes nothing returns nothing
            call this.core.destroy()
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = MMS_Core.create()
            set this.core = this
            set this.dim = 4
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            set dindex = -1
        endmethod
    endstruct
    //End of the code of the 4D
    endif
endlibrary

And then in loop check this memer.
Ofc you can wrap this into a static if WANT_3D but this will say that even the struct 3D will not be there.

http://www.wc3c.net/showthread.php?t=103862 for the path

 

[T. D. W.]

Static if will make the code unusable after the compile time.

ummm, what code? if you are talking about the call blachblach 3D stuff, then yes, it is intended

In mms_core struct add a member called dim like this :

what does it do?

And then in loop check this memer.

what

Ofc you can wrap this into a static if WANT_3D but this will say that even the struct 3D will not be there.

yes, duh? what you mean

 

[Malhorne]

Everything specific to a 3D will be wrapped inside a 3D static if.
But if the user want a 2D and a 3D in his map.
He will maybe cast a 2D and a 3D at the same time.
So we put a member dim for each struct.
Then in the loop check this member :

if this.dim == 3 then
    //Perform 3D code
elseif this.dim == 4 then
    //Perform 4D code
endif

 

[T. D. W.]

in that case, there HAS to be something like this:

static if WANT_3D
if this.dim == 3 then
    //Perform 3D code
endif
endif
static if WANT_4D
if this.dim == 4 then
    //Perform 4D code
endif
endif

 

[Malhorne]

Yep you got it
Was just lazy to wrap them

 

[T. D. W.]

oh ok