//
// Copyright2005
// Institut für Systemtheorie und Regelungstechnik
// an der Universität Stuttgart
//
// Version 0.8

// Masse
variable M, g

// Zustände
variable x_spl, x_reg

// Stellgrößen
variable u_spl, u_reg

// Ausgang
variable y_spl, y_reg

// Zeit
variable t, delta_t_spl, delta_t_reg, delta_t_old


// die y-Werte der Kurve
variable x_werte

variable y_rand


// akkumulierte  Regelabweichung
variable e_spl_tot, e_reg_tot, e_reg_old, e_spl_old

// PID regler
variable z_old_1, z_old_2


// pfade
variable pfad_spl, pfad_reg
variable pfad_u_spl, pfad_u_reg

// Menü parameter
variable is_started, is_paused, is_done;
variable kurve, regler1, regler2;
variable level;


// PID-Regler parameter
//variable K_r, T_n, T_v;
variable param1, param2;

// Punkte
variable fehler_ges_spl, fehler_ges_reg;
variable punkte_spl, punkte_reg;


variable slider_pos;

// Massenänderung
variable is_heavy, g_change;
variable M_log, g_log;


// Werte initialisieren
init (M, g, M_log, g_log, x_werte, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, e_spl_tot, e_reg_tot, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, regler1, regler2, param1, param2, slider_pos, kurve, is_heavy, g_change, level, punkte_spl, punkte_reg, y_rand, z_old_1, z_old_2) = init

// idle handler setzen
idle (t, delta_t_spl, delta_t_reg, delta_t_old, _idlerate, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, e_reg_old, e_spl_old, is_done, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, slider_pos, M, g, M_log, g_log, is_heavy, g_change, punkte_spl, punkte_reg, z_old_1, z_old_2) = idle(is_started, is_paused, is_done, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, e_reg_old, e_spl_old, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, param1, param2, M, g, M_log, g_log, regler1, regler2, slider_pos, kurve, is_heavy, g_change, level, punkte_spl, punkte_reg, y_rand, z_old_1, z_old_2)

// Figuren definieren
figure "Game"
  draw draw(x_werte, t, delta_t_spl, delta_t_reg, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, M, g, M_log, g_log, slider_pos, is_done, kurve, is_heavy, g_change, punkte_spl, punkte_reg, level, is_started, is_paused, y_rand)
  mousedrag (slider_pos) = dragSlider(slider_pos, _id, _y1, M)
  mouseover (_cursor) = overSlider(_id)
  mousedown downSlider()

menu "Neues Spiel" (t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, slider_pos, M, g, M_log, g_log, is_heavy, g_change, punkte_spl, punkte_reg, level, y_rand) = menuNewGame()
separator
menu "Spiel starten" _enable(~is_started) (is_started, is_paused) = menuStartGame()
menu "Pause" _enable(is_started && ~is_done) _checkmark(is_paused) is_paused = not(is_paused)
separator
menu "Kurve - Sinus 1"    _checkmark(kurve==1) kurve = kurve_waehlen(1)
menu "Kurve - Sinus 2"    _checkmark(kurve==2) kurve = kurve_waehlen(2)
menu "Kurve - Rechteck 1" _checkmark(kurve==3) kurve = kurve_waehlen(3)
menu "Kurve - Rechteck 2" _checkmark(kurve==4) kurve = kurve_waehlen(4)
menu "Kurve - Zufall" _checkmark(kurve==5) kurve = kurve_waehlen(5)

separator
menu "(i) Menschlicher Spieler" _checkmark(regler1==0) regler1 = regler1_waehlen(0);
menu "(i) Regler 1 - P"     	_checkmark(regler1==1) regler1 = regler1_waehlen(1);
menu "(i) Regler 2 - PI"        _checkmark(regler1==2) regler1 = regler1_waehlen(2);
menu "(i) Regler 3 - PD"        _checkmark(regler1==3) regler1 = regler1_waehlen(3);
menu "(i) Regler 4 - PID"       _checkmark(regler1==4) regler1 = regler1_waehlen(4);
menu "(i) Parameter"	        _enable(regler1>0) param1 = set_param1(param1);	
separator
menu "(ii) Regler aus"       	_checkmark(regler2==0) regler2 = regler2_waehlen(0);
menu "(ii) Regler 1 - P"     	_checkmark(regler2==1) regler2 = regler2_waehlen(1);
menu "(ii) Regler 2 - PI"    	_checkmark(regler2==2) regler2 = regler2_waehlen(2);
menu "(ii) Regler 3 - PD"    	_checkmark(regler2==3) regler2 = regler2_waehlen(3);
menu "(ii) Regler 4 - PID"   	_checkmark(regler2==4) regler2 = regler2_waehlen(4);
menu "(ii) Parameter"		_enable(regler2>0) param2 = set_param2(param2);
separator
menu "Level 1"			_checkmark(level==1) level = level_waehlen(1);
menu "Level 2"			_checkmark(level==2) level = level_waehlen(2);
menu "Level 3"			_checkmark(level==3) level = level_waehlen(3);
menu "Level 4"			_checkmark(level==4) level = level_waehlen(4);
menu "Level 5"			_checkmark(level==5) level = level_waehlen(5);

keydown (level, M, g, slider_pos, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, M_log, g_log, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, is_heavy, g_change, y_rand) = keydownHandler(level, M, g, slider_pos, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, M_log, g_log, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, is_heavy, g_change, y_rand, _key)

functions
{@

function kurve = kurve_waehlen(k)
    kurve = k;

function regler1 = regler1_waehlen(r)
    regler1 = r;

function regler2 = regler2_waehlen(r)
    regler2 = r;

function param1 = set_param1(param1) 
    (ok, param1) = dialog('Regelparameter (i): [K_r, T_n, T_v]', param1);


function param2 = set_param2(param2) 
    (ok, param2) = dialog('Regelparameter (ii): [K_r, T_n, T_v]', param2);

function level = level_waehlen(l)
    level = l;
  
  

// Werte initialisieren
function (M, g, M_log, g_log, x_werte, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, e_spl_tot, e_reg_tot, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, regler1, regler2, param1, param2, slider_pos, kurve, is_heavy, g_change, level, punkte_spl, punkte_reg, y_rand, z_old_1, z_old_2) = init

    // Masse und Gravitation definieren
    M = 10;
    g = 0;

    // Kurve definieren
    x_werte = 2*pi*0.01*(-25:500);

    slider_pos = 0;

    // Werte initialisieren
    t = 0;
    delta_t_spl = 0;
    delta_t_reg = 0;
    delta_t_old = 0;
    x_spl = [0; 0];
    x_reg = [0; 0];
    u_spl = 0;
    u_reg = 0;
    y_spl = 0;
    y_reg = 0;

    e_spl_tot = 0;
    e_reg_tot = 0;
    z_old_1 = [0; 0];
    z_old_2 = [0; 0];
    
    pfad_spl = [0;0];
    pfad_reg = [0;0];
    pfad_u_spl = [0;0];
    pfad_u_reg = [0;0];
    M_log = [0;0];
    g_log = [0;0];

    fehler_ges_spl = 0;
    fehler_ges_reg = 0;

    punkte_spl = 0;
    punkte_reg = 0;

    // spiel läuft noch nicht.
    is_started = 0;
    is_paused = 0;
    is_done = 0;

    // Sinuskurve
    kurve = 1;

    // Menschlicher Spieler gegen PD-Regler.
    regler1 = 0;
    regler2 = 4;

    param1 = [30,100,1];
    param2 = [30,100,1];

    is_heavy = 0;
    g_change = 0;

    // seed random generator
    c = clock();
    rand('seed', c(6));

    // Level 1
    level = 1;
    
    // zufallskurve bestimmen
    y_rand = init_zufalls_kurve((-25:500));


function (t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, slider_pos, M, g, M_log, g_log, is_heavy, g_change, punkte_spl, punkte_reg, level, y_rand) = menuNewGame()

    // Masse und Gravitation zurücksetzen
    M = 10;
    g = 0;

    slider_pos = 0;

    // Werte initialisieren
    t = 0;
    delta_t_spl = 0;
    delta_t_reg = 0;
    delta_t_old = 0;
    x_spl = [0; 0];
    x_reg = [0; 0];
    u_spl = 0;
    u_reg = 0;
    y_spl = 0;
    y_reg = 0;

    e_spl_tot = 0;
    e_reg_tot = 0;
    pfad_spl = [0;0];
    pfad_reg = [0;0];
    pfad_u_spl = [0;0];
    pfad_u_reg = [0;0];
    M_log = [0;0];
    g_log = [0;0];

    fehler_ges_spl = 0;
    fehler_ges_reg = 0;
    punkte_spl = 0;
    punkte_reg = 0;

    // spiel läuft noch nicht.
    is_started = 0;
    is_paused = 0;
    is_done = 0;

    is_heavy = 0;
    g_change = 0;

    level = 1;
    
    // zufallskurve bestimmen
    y_rand = init_zufalls_kurve((-25:500));    

function (is_started, is_paused) = menuStartGame()

    // spiel läuft!
    is_started = 1;
    is_paused = 0;


function (level, M, g, slider_pos, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, M_log, g_log, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, is_heavy, g_change, y_rand) = keydownHandler(level, M, g, slider_pos, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, M_log, g_log, fehler_ges_spl, fehler_ges_reg, is_started, is_paused, is_done, is_heavy, g_change, y_rand, key)
  
  if is_done && key==' ' && level<5

	// NÄCHSTES LEVEL.
	level = level + 1;

	// Masse und Gravitation zurücksetzen
	M = 10;
	g = 0;

	slider_pos = 0;

	// Werte initialisieren
	t = 0;
	delta_t_spl = 0;
	delta_t_reg = 0;
	delta_t_old = 0;
	x_spl = [0; 0];
	x_reg = [0; 0];
	u_spl = 0;
	u_reg = 0;
	y_spl = 0;
	y_reg = 0;

	e_spl_tot = 0;
	e_reg_tot = 0;
	pfad_spl = [0;0];
	pfad_reg = [0;0];
	pfad_u_spl = [0;0];
	pfad_u_reg = [0;0];
	M_log = [0;0];
	g_log = [0;0];

	fehler_ges_spl = 0;
	fehler_ges_reg = 0;

	// spiel läuft noch nicht.
	is_started = 0;
	is_paused = 0;
	is_done = 0;
	is_heavy = 0;
	g_change = 0; 
	
	y_rand = init_zufalls_kurve((-25:500));


  else 
	  switch key
	    case ' '
	      if is_started==1 && is_paused==1
		is_paused = 0
	      elseif is_started==1 && is_paused==0
		is_paused = 1
	      elseif is_started==0
		is_started = 1
		is_paused = 0
	      end
	    otherwise
	      cancel;
	  end
  end

function y = func(x, kurve, y_rand, t)

    if kurve==1
      y = sin(1.5*x);
    elseif kurve==2
      y = sin(x);
    elseif kurve==3
      y = sign(sin(0.2*x));
    elseif kurve==4
      y = sign(sin(0.3*x));
    elseif kurve==5
      if length(x)>1
         a = round(t*20)+1;
         y = y_rand(a:length(x)+a-1);
      else
         y = func_rand(x, y_rand);
      end;
    end

    length(y);



function y = func_rand(t, y_rand)

    a = round(t*20);
    y = y_rand(a);


function y_rand = init_zufalls_kurve(x)

   dy = rand()*0.1-0.05;
   y_rand = [];
   current = rand()*5-2.5;

   for i=1:length(x)*10
   	y_rand = [y_rand, current];
   	
   	r = rand();
   	if r>0.9
   	    dy = rand()*0.1-0.05;
   	end
   	
   	current = current + dy;
   	if abs(current)>2.5 
   	    current = sign(current)*2.495; 
   	end;
   	
   end;
   



// idle handler
function (t, delta_t_spl, delta_t_reg, delta_t_old, idlerate, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, e_reg_old, e_spl_old, is_done, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, slider_pos, M, g, M_log, g_log, is_heavy, g_change, punkte_spl, punkte_reg, z_old_1, z_old_2) = idle(is_started, is_paused, is_done, t, delta_t_spl, delta_t_reg, delta_t_old, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, e_spl_tot, e_reg_tot, e_reg_old, e_spl_old, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, param1, param2, M, g, M_log, g_log, regler1, regler2, slider_pos, kurve, is_heavy, g_change, level, punkte_spl, punkte_reg, y_rand, z_old_1, z_old_2)

    // idlerate setzen
    idlerate = 0.05;


    // bei t=20s aufhören!
    if t>20 || abs(fehler_ges_reg-fehler_ges_spl) > 1000

	if is_done==0
            is_done = 1;
            punkte_spl = punkte_spl + fehler_ges_spl;
            punkte_reg = punkte_reg + fehler_ges_reg;
        end
	

    else

        // läuft das Spiel?
        if is_started && ~is_paused

            // Massenänderung
            (is_heavy,M) = do_mass_change(is_heavy,M,level);
			// Gewichtskraftänderung
            (g_change, g) = do_g_change(g_change, g,level);

            // Zeit incrementieren
            t = t + 0.05;

            // Offset berechnen
            if fehler_ges_spl > fehler_ges_reg
                delta_t_spl = 0;
                delta_t_reg = (fehler_ges_spl-fehler_ges_reg)/100;
            else
                delta_t_spl = (fehler_ges_reg-fehler_ges_spl)/100;
                delta_t_reg = 0;
            end

            // Neuen Vorsprung berechnen
            delta_t_new = delta_t_reg - delta_t_spl;

            // dt berechnen
            if delta_t_spl==0
            	dt_reg = 0.05 + (delta_t_new - delta_t_old);
            	dt_spl = 0.05;
            else
            	dt_reg = 0.05;
            	dt_spl = 0.05 - (delta_t_new - delta_t_old);
            end

            // Alten Vorsprung speichern
            delta_t_old = delta_t_new;

            // Fehler ausrechnen.
            e_spl = func(t+delta_t_spl, kurve, y_rand, t+delta_t_spl) - y_spl;
            e_reg = func(t+delta_t_reg, kurve, y_rand, t+delta_t_spl) - y_reg;

            // Akkumulierten Fehler bestimmen.
            e_spl_tot = e_spl_tot + e_spl;
            e_reg_tot = e_reg_tot + e_reg;

            // Fehlerableitung bestimmen.
            e_reg_p = (e_reg - e_reg_old) / dt_reg;
            e_reg_old = e_reg;

            e_spl_p = (e_spl - e_spl_old) / dt_spl;
            e_spl_old = e_spl;

	   
            // Neue Stellgröße u_reg bestimmen!
            if regler1==0
            	u_spl = slider_pos*25;
            elseif regler1==1
                u_spl = regler_1(e_spl, e_spl_tot, e_spl_p, param1);
            elseif regler1==2
                u_spl = regler_2(e_spl, e_spl_tot, e_spl_p, param1);
            elseif regler1==3
                u_spl = regler_3(e_spl, e_spl_tot, e_spl_p, param1);
            elseif regler1==4
                (u_reg, z_old_1) = regler_4(e_spl, z_old_1, param1);
            else
                u_spl = 0;
            end

	    if regler2==0
	    	u_reg = 0;
            elseif regler2==1
                u_reg = regler_1(e_reg, e_reg_tot, e_reg_p, param2);
            elseif regler2==2
                u_reg = regler_2(e_reg, e_reg_tot, e_reg_p, param2);
            elseif regler2==3
                u_reg = regler_3(e_reg, e_reg_tot, e_reg_p, param2);
            elseif regler2==4
                (u_reg, z_old_2) = regler_4(e_reg, z_old_2, param2);
            else
                u_reg = 0;
            end


            // Stellgrößenbeschränkung
            if abs(u_spl) > 50
                u_spl = sign(u_spl)*50;
            else
            	ok = 1;
            end
            if abs(u_reg) > 50
                u_reg = sign(u_reg)*50;
            else
            	ok = 1;
            end

            // zum Pfad hinzufügen.
            if t==0.05
            	u_spl = 0;
            	u_reg = 0;
            end
            pfad_u_spl = [pfad_u_spl, [t+delta_t_spl; u_spl/25]];
            pfad_u_reg = [pfad_u_reg, [t+delta_t_reg; u_reg/25]];

            // UPDATE SLIDERPOS
            slider_pos = u_spl/25;

            // Neuen Systemzustand berechnen.
            x_spl = int_sys(x_spl, u_spl, M, g);
            x_reg = int_sys(x_reg, u_reg, M, g);

            // Ausgänge berechnen
            y_spl = sys_output(x_spl);
            y_reg = sys_output(x_reg);


            // zum Pfad hinzufügen.
            pfad_spl =   [pfad_spl,   [t+delta_t_spl; y_spl]];
            pfad_reg =   [pfad_reg,   [t+delta_t_reg; y_reg]];

            M_log = [M_log, [t; is_heavy]];
            g_log = [g_log, [t; g_change]];


            // Gesamtfehler bestimmen
            fehler_ges_spl = fehler_ges_spl + abs(e_spl);
            fehler_ges_reg = fehler_ges_reg + abs(e_reg);



        end

    end



function (is_heavy, M) = do_mass_change(is_heavy, M, level)

    r = rand();
 
    if level==1
    	prob1 = 1;
    	prob2 = 1;
    elseif level==2
        prob1 = 0.995;
        prob2 = 0.995;
    elseif level==3
    	prob1 = 0.985;
    	prob2 = 0.985;
    elseif level==4
    	prob1 = 0.975;
    	prob2 = 0.98;
    elseif level==5
        prob1 = 0.965;
        prob2 = 0.97;
    end

    if is_heavy==1 && r>prob1
       is_heavy = 0;
       M = 10
    elseif is_heavy==0 && r>prob2
       is_heavy = 1;
       M = 20
    end



function (g_change, g) = do_g_change(g_change, g, level)

    r = rand();

    if level==1
    	prob1 = 1;
    	prob2 = 1;
    elseif level==2
        prob1 = 1;
        prob2 = 1;
    elseif level==3
    	prob1 = 1;
    	prob2 = 1;
    elseif level==4
    	prob1 = 0.98;
    	prob2 = 0.98;
    elseif level==5
        prob1 = 0.96;
        prob2 = 0.97;
    end


    if abs(g_change)>0 && r>prob1
       g_change = 0
       g = 0;

    elseif g_change==0 && r>prob2

       r = rand();
       if r<0.5
       	g_change = -1
        g = -1;
       else
       	g_change = 1
        g = 1
       end
    end


function x = int_sys(x_old, u, M, g)

    (sim_t,sim_y) = ode45(@f,[0,0.05],x_old,[],u,M,g);
    x = [sim_y(size(sim_y,1),1);sim_y(size(sim_y,1),2)];


function y = sys_output(x)

    y = x(1);


function x_p = f(t,x,u,M,g)

    x_p = [x(2); u/M - g];


function u = regler_1(e, e_tot, e_p, params)
    K_r = params(1);
    u = K_r*e;

function u = regler_2(e, e_tot, e_p, params)
    K_r = params(1);
    T_n = params(2);
    u = K_r*(e + 1/T_n*e_tot);

function u = regler_3(e, e_tot, e_p, params)
    K_r = params(1);
    T_v = params(3); 
    u = K_r*(e + T_v*e_p);
    
function (u, z) = regler_4(e, z_old, params)
    //K_r = params(1);
    //T_n = params(2);
    //T_v = params(3);
    //u = K_r*(e + 1/T_n*e_tot + T_v*e_p);

    K_r = params(1);
    T_n = params(2);
    T_v = params(3);
    
    v = 10;//params(4);
    w = 0.2;//params(5);
    
    (sim_t,sim_y) = ode45(@f_PID,[0,0.05],z_old,[], e,K_r,T_n,v,w);
    z = [sim_y(size(sim_y,1),1);sim_y(size(sim_y,1),2)]

    u = z(2) + K_r*v*(e + z(1));


//function z_lead_p = f_lead(t, z_lead, e, v,w)

//    z_lead_p = -v*w*z_lead + w*(1-v)*e;



//function z_I_p = f_I(t, z_I, z_lead, e, K_r, T_n, v)

//    z_I_p = K_r/T_n*v*(e+z_lead);



function z_p = f_PID(t, z,  e,K_r,T_n,v,w)

    z_p = [-v*w*z(1) + w*(1-v)*e; K_r/T_n*v*(e+z(1))];






function draw(x_werte, t, delta_t_spl, delta_t_reg, x_spl, x_reg, u_spl, u_reg, y_spl, y_reg, pfad_spl, pfad_reg, pfad_u_spl, pfad_u_reg, fehler_ges_spl, fehler_ges_reg, M, g, M_log, g_log, slider_pos, is_done, kurve, is_heavy, g_change, punkte_spl, punkte_reg, level, is_started, is_paused, y_rand)

    if is_done
    
        ///////////////////////////////////////////////////////////////////////
        ////////////////////////// SPIEL BEENDET //////////////////////////////
        ///////////////////////////////////////////////////////////////////////


        x_werte_tmp = 0.05*(1:size(pfad_spl(1,:),2));

        // Achsen definieren
        scale([0, size(pfad_spl(1,:),2)*0.05, -6, 6]);
        label('', '');
        settabs('SCORE:XXXX\tSpieler (1): XXXXXX\tSpieler(2): XXXXXX');


	// Score ausgeben
	text(0, 5.9, sprintf('SCORE (dieses Spiel): Spieler (1): %d  Spieler (2): %d', fehler_ges_spl, fehler_ges_reg), 'tl');
	text(size(pfad_spl(1,:),2)*0.05*0.5, 5.9, sprintf('SCORE (gesamt): Spieler (1): %d  Spieler (2): %d', punkte_spl, punkte_reg), 'tl');
	
	
	// Label ausgeben
	text(0, 5, 'Verlauf y:', 'tl');

        // Nulllinie zeichnen
        line([0,1],2.5,'b:');

        // Kurve zeichen
        plot(x_werte_tmp, func(x_werte_tmp, kurve, y_rand, 0)+2.5, ':');

        // Pfade zeichnen
        plot(pfad_spl(1,:), pfad_spl(2,:)+2.5, 'r');
        plot(pfad_reg(1,:), pfad_reg(2,:)+2.5, 'g');


	// Label ausgeben
	text(0, 1, 'Eingang u:', 'tl');

        // Nulllinie zeichnen
        line([0,1],-2,'b');

        // Kurve zeichen
        plot(x_werte_tmp, func(x_werte_tmp, kurve, y_rand, 0)-2);

        // Pfade zeichnen
        plot(pfad_u_spl(1,:), pfad_u_spl(2,:)-2, 'r:');
        plot(pfad_u_reg(1,:), pfad_u_reg(2,:)-2, 'g:');


        // Massenänderung / Sonnenwind
        text(0, -4, 'Massenänderung (rot) / Sonnenwind (grün)', 'tl');
        line([0,1],-5,'b.');
        plot(M_log(1,:), M_log(2,:)*0.4-5, 'r');
        plot(g_log(1,:), g_log(2,:)*0.4-5, 'g');


	if level<5
	    text(size(pfad_spl(1,:),2)*0.05*0.5, -6, '(Leertaste) dürcken um fortzufahren...', 'bc');
	else
	    if punkte_spl > punkte_reg
	        text(size(pfad_spl(1,:),2)*0.05*0.5, -6, 'SPIEL BEENDET! SPIELER (2) GEWINNT!', 'bc');
	    else
	        text(size(pfad_spl(1,:),2)*0.05*0.5, -6, 'SPIEL BEENDET! SPIELER (1) GEWINNT!', 'bc');
	    end
	end
		
	
    else


        // Achsen definieren
        scale('equal',[1,5,-2.5,2.5]);
        label('', '');

	
        // Nulllinie zeichnen
        line([0,1],0,'b:');

        // Kurve zeichen
        plot( x_werte, func(x_werte+t, kurve, y_rand, t) );

        // Pfade zeichnen
        plot(pfad_spl(1,:)-t, pfad_spl(2,:), ':');
        plot(pfad_reg(1,:)-t, pfad_reg(2,:), '.');

        // Scale holen
        sc = scale;

	
        // Radius bestimmen
        if is_heavy==1
        	r = 0.1414;
        else
        	r = 0.1000;
        end

        // Spielfiguren zeichnen
        circle(delta_t_spl, y_spl, r, 'rf');
        text(delta_t_spl, y_spl, '1');
        circle(delta_t_reg, y_reg, r, 'gf');
        text(delta_t_reg, y_reg, '2');

        // Gravitationspfeile zeichnen (falls erforderlich)
        if g_change==1
		
	    i=-0.9;	
	    while i<sc(2)
	        draw_arrow(i, 2.3-max([min([tan(5*t),1]),-1])*0.05, 1);
	        i=i+0.2;
            end;
            
        elseif g_change==-1

    	    i=-0.9;	
	    while i<sc(2)
	        draw_arrow(i, -2.3+max([min([tan(5*t),1]),-1])*0.05, -1);
	        i=i+0.2;
            end;

        end


        // Vertikale zeichnen
        plot([sc(1),sc(1),-1,-1], [-3,3,3,-3], 'h(f1f1f1)f');
        line([1,0],-1,'k!');

        // Slider zeichnen
        plot([sc(1)+0.3,sc(1)+0.3,sc(1)+0.7,sc(1)+0.7,sc(1)+0.3], [-2.2,2.2,2.2,-2.2,-2.2], 'h(dddddd)f');
        plot([sc(1)+0.3,sc(1)+0.3,sc(1)+0.7,sc(1)+0.7,sc(1)+0.3], [-2.2,2.2,2.2,-2.2,-2.2], 'k');

        circle( sc(1)+0.51, u_reg/25, 0.1, 'h(55aa55)f', 1);
        circle( sc(1)+0.51, u_spl/25, 0.1, 'h(aa5555)f', 2);
        
        text(sc(1)+0.5, 2.5, sprintf('Level: %d', level), 'tc');
	
	if is_started==0
	  text( (sc(2)+sc(1))*0.5, -2.5, '(Leertaste) drücken zum Starten...', 'bc');
	elseif is_paused==1
	  text( (sc(2)+sc(1))*0.5, -2.5, 'PAUSE! (Leertaste) drücken zum Fortfahren...', 'bc');
	end


    end


function draw_arrow(x,y,d)

    plot([x, x     ], [y, y+d*0.15], 'b');
    plot([x, x-0.05], [y, y+d*0.08], 'b');
    plot([x, x+0.06], [y, y+d*0.08], 'b');


function (slider_pos) = dragSlider(slider_pos, id, y1, M)

    if isempty(id) //id ~== 1
        cancel;
    end

    if(y1>2)
            y1 = 2;
    end
    if(y1<-2)
            y1 = -2;
    end

    slider_pos = y1;



function cursor = overSlider(id)
    // displays a finger if the cursor is over the silder,
    // and a plain cursor otherwise
    cursor = ~isempty(id);

function downSlider()
    // do nothing


@}