<?xml version="1.0"?>
<PropertyList>
<name>demo-mapstructure</name>
<modal>false</modal>
<layout>vbox</layout>

<canvas>
               <name>vor-map</name>
               <valign>fill</valign>
               <halign>fill</halign>
               <stretch>true</stretch>
               <pref-width>600</pref-width>
               <pref-height>400</pref-height>
<nasal>
<!--
     this is the Canvas-specific Nasal section where you can run your own Nasal code
     to access and animate the canvas region
-->
        <load><![CDATA[
        #Variables
        var ElapsedSec        = props.globals.getNode("sim/time/elapsed-sec");


        #Radar object creation

        # Radar engine class
        var radar =
        {
	        #################### creates a new engine object################"
	        new: func(Range)
	        {
	           #Objet Radar
	           var m = { parents : [radar]};

	           #Radar range
	           m.range = Range;


	           #Aircraft Orientation/pitch
	           m.parentAircraftHeading = props.globals.getNode("orientation/heading-deg");
	           m.parentAircraftPitch = props.globals.getNode("orientation/pitch-deg");


	           #Where to find the initial information
	           m.Mp = props.globals.getNode("ai/models",1);

	           #Array needed to get back MP
	           m.tgts_list         = [];


	           #Return the created object
	           return m;
                },
                # creates a Radar update loop (optional)
                init: func
                {
                     me.look_IntoMP();
                },


                ################# Function get/set to adusjt properties once the whole things is runing
                setRange: func(n)
                {
                     me.range = n;
                },
                getRange: func()
                {
                     return me.range;
                },




                ################# Main Update Loop ########################
                look_IntoMP: func
                {
                     #init the array
                     me.tgts_list = [];

                     #Put All the /ai/models into this array
                     var raw_list = me.Mp.getChildren();

                     #Then
                     foreach( var c; raw_list ) {

                        var type = c.getName();
                        if (!c.getNode("valid", 1).getValue()) {
                                continue;
                        }
                        print(type);
                        var HaveRadarNode = c.getNode("radar");
                        if (type == "multiplayer" or (type == "tanker" and HaveRadarNode != nil) or type == "aircraft" or type=="carrier" or type=="ship") {
                                var u = Target.new(c);
                                 if ( u.Range != nil) {
                                     var u_rng = u.get_range();
                                     if (u_rng <  me.range) {
                                        print(u.get_Callsign());
                                     }
                                  }
                        }

                     }

                },

                # Main loop ###############
                rdr_loop: func
                {

                },
        };






        # Target class
        var Target = {
                new : func (c) {
                        var obj = { parents : [Target]};
                        obj.RdrProp = c.getNode("radar");
                        obj.Heading = c.getNode("orientation/true-heading-deg");
                        obj.Alt = c.getNode("position/altitude-ft");
                        obj.AcType = c.getNode("sim/model/ac-type");
                        obj.type = c.getName();
                        obj.index = c.getIndex();
                        obj.string = "ai/models/" ~ obj.type ~ "[" ~ obj.index ~ "]";
                        obj.shortstring = obj.type ~ "[" ~ obj.index ~ "]";
                        obj.InstrTgts = props.globals.getNode("instrumentation/radar2/targets", 1);
                        obj.TgtsFiles = obj.InstrTgts.getNode(obj.shortstring, 1);
                        obj.Callsign       = c.getNode("callsign");

                        obj.Range          = obj.RdrProp.getNode("range-nm");
                        obj.Bearing        = obj.RdrProp.getNode("bearing-deg");
                        obj.Elevation      = obj.RdrProp.getNode("elevation-deg");
                        obj.BBearing       = obj.TgtsFiles.getNode("bearing-deg", 1);
                        obj.BHeading       = obj.TgtsFiles.getNode("true-heading-deg", 1);
                        obj.RangeScore     = obj.TgtsFiles.getNode("range-score", 1);
                        obj.RelBearing     = obj.TgtsFiles.getNode("ddd-relative-bearing", 1);
                        obj.Carrier        = obj.TgtsFiles.getNode("carrier", 1);
                        obj.EcmSignal      = obj.TgtsFiles.getNode("ecm-signal", 1);
                        obj.EcmSignalNorm  = obj.TgtsFiles.getNode("ecm-signal-norm", 1);
                        obj.EcmTypeNum     = obj.TgtsFiles.getNode("ecm_type_num", 1);
                        obj.Display        = obj.TgtsFiles.getNode("display", 1);
                        obj.Fading         = obj.TgtsFiles.getNode("ddd-echo-fading", 1);
                        obj.DddDrawRangeNm = obj.TgtsFiles.getNode("ddd-draw-range-nm", 1);
                        obj.TidDrawRangeNm = obj.TgtsFiles.getNode("tid-draw-range-nm", 1);
                        obj.RoundedAlt     = obj.TgtsFiles.getNode("rounded-alt-ft", 1);
                        obj.TimeLast       = obj.TgtsFiles.getNode("closure-last-time", 1);
                        obj.RangeLast      = obj.TgtsFiles.getNode("closure-last-range-nm", 1);
                        obj.ClosureRate    = obj.TgtsFiles.getNode("closure-rate-kts", 1);

                        obj.TimeLast.setValue(ElapsedSec.getValue());
                        if ( obj.Range != nil) {
                                obj.RangeLast.setValue(obj.Range.getValue());
                        } else {
                                obj.RangeLast.setValue(0);
                        }
                        obj.RadarStandby = c.getNode("sim/multiplay/generic/int[2]");

                        obj.deviation = nil;

                        return obj;
                },
                get_Callsign : func {
                        var n = me.Callsign.getValue();
                        return n;
                },
                get_heading : func {
                        var n = me.Heading.getValue();
                        me.BHeading.setValue(n);
                        return n;
                },
                get_bearing : func {
                        var n = me.Bearing.getValue();
                        me.BBearing.setValue(n);
                        return n;
                },
                set_relative_bearing : func(n) {
                        me.RelBearing.setValue(n);
                },
                get_reciprocal_bearing : func {
                        return geo.normdeg(me.get_bearing() + 180);
                },
                get_deviation : func(true_heading_ref) {
                        me.deviation =  - deviation_normdeg(true_heading_ref, me.get_bearing());
                        return me.deviation;
                },
                get_altitude : func {
                        return me.Alt.getValue();
                },
                get_total_elevation : func(own_pitch) {
                        me.deviation =  - deviation_normdeg(own_pitch, me.Elevation.getValue());
                        return me.deviation;
                },
                get_range : func {
                        return me.Range.getValue();
                },
                get_horizon : func(own_alt) {
                        var tgt_alt = me.get_altitude();
                        if ( tgt_alt != nil ) {
                                if ( own_alt < 0 ) { own_alt = 0.001 }
                                if ( debug.isnan(tgt_alt)) {
                                        return(0);
                                }
                                if ( tgt_alt < 0 ) { tgt_alt = 0.001 }
                                return radardist.radar_horizon( own_alt, tgt_alt );
                        } else {
                                return(0);
                        }
                },
                check_carrier_type : func {
                        var type = "none";
                        var carrier = 0;
                        if ( me.AcType != nil ) { type = me.AcType.getValue() }
                        if ( type == "MP-Nimitz" or type == "MP-Eisenhower"  or type == "MP-Vinson") { carrier = 1 }
                        if ( type == "Nimitz" or type == "Eisenhower"  or type == "Vinson") { carrier = 1 }
                        # This works only after the mp-carrier model has been loaded. Before that it is seen like a common aircraft.
                        me.Carrier.setBoolValue(carrier);
                        return carrier;
                },
                get_rdr_standby : func {
                        var s = 0;
                        if ( me.RadarStandby != nil ) {
                                s = me.RadarStandby.getValue();
                                if (s == nil) { s = 0 } elsif (s != 1) { s = 0 }
                        }
                        return s;
                },
                get_display : func() {
                        return me.Display.getValue();
                },
                set_display : func(n) {
                        me.Display.setBoolValue(n);
                },
                get_fading : func() {
                        var fading = me.Fading.getValue();
                        if ( fading == nil ) { fading = 0 }
                        return fading;
                },
                set_fading : func(n) {
                        me.Fading.setValue(n);
                },
                set_ddd_draw_range_nm : func(n) {
                        me.DddDrawRangeNm.setValue(n);
                },
                set_hud_draw_horiz_dev : func(n) {
                        me.HudDrawHorizDev.setValue(n);
                },
                set_tid_draw_range_nm : func(n) {
                        me.TidDrawRangeNm.setValue(n);
                },
                set_rounded_alt : func(n) {
                        me.RoundedAlt.setValue(n);
                },
                get_closure_rate : func() {
                        var dt = ElapsedSec.getValue() - me.TimeLast.getValue();
                        var rng = me.Range.getValue();
                        var lrng = me.RangeLast.getValue();
                        if ( debug.isnan(rng) or debug.isnan(lrng)) {
                                #print("####### get_closure_rate(): rng or lrng = nan ########");
                                me.ClosureRate.setValue(0);
                                me.RangeLast.setValue(0);
                                return(0);
                        }
                        var t_distance = lrng - rng;
                        var        cr = (dt > 0) ? t_distance/dt*3600 : 0;
                        me.ClosureRate.setValue(cr);
                        me.RangeLast.setValue(rng);
                        return(cr);
                },
                list : [],
        };

#########################################################################
################### RADAR Creation ######################################
#########################################################################

       var myRadar = radar.new(100);
       myRadar.init();


#########################################################################
###########################CANVAS PART ##################################
#########################################################################
        var myCanvas = canvas.get( cmdarg() );
        var TestMap = myCanvas.createGroup().createChild("map");

        foreach(var type; var layer_types = ['VOR',] )
                TestMap.addLayer(factory: canvas.SymbolLayer, type_arg: type);

       # Center the map's origin:
       TestMap.setTranslation(300,200);

       # Initialize a range (TODO: LayeredMap.Controller):
       TestMap.set("range", 100);

       # Little cursor of current position:
       TestMap.createChild("path").rect(-5,-5,10,10).setColorFill(1,1,1).setColor(0,1,0);

       # And make it move with our aircraft:
       TestMap.setController("Aircraft position"); # from aircraftpos.controller

        ]]></load>
<!-- all the code here will be executed once the dialog is closed, so you
should put your cleanup code here.
-->
<unload><![CDATA[
TestMap.del();
]]></unload>

</nasal>
</canvas>

</PropertyList>