Klappen = {};

function Klappen.prerequisitesPresent(specializations)
    return true;
end;

function Klappen:load(xmlFile)

self.setRotateDirection= SpecializationUtil.callSpecializationsFunction("setRotateDirection");  -- setRotation wäre hier irreführend weils die funktion von Giants schon gibt, nimm lieder die hier. Mit dem aufruf registrierst du die funktion.
    self.haspel = Utils.indexToObject(self.components, getXMLString(xmlFile, "vehicle.haspel#index"));

local rotationPartNodeRotation1= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation1#index"));
    if rotationPartNodeRotation1 ~= nil then
        self.Rotation1 = {};
        self.Rotation1.node = rotationPartNodeRotation1;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation1#minRot"));
        self.Rotation1.minRot = {};
        self.Rotation1.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation1.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation1.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation1#maxRot"));
        self.Rotation1.maxRot = {};
        self.Rotation1.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation1.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation1.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation1.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation1#rotTime"), 2)*1000;
    end;
local rotationPartNodeRotation12= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation12#index"));
    if rotationPartNodeRotation12 ~= nil then
        self.Rotation12 = {};
        self.Rotation12.node = rotationPartNodeRotation12;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation12#minRot"));
        self.Rotation12.minRot = {};
        self.Rotation12.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation12.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation12.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation12#maxRot"));
        self.Rotation12.maxRot = {};
        self.Rotation12.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation12.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation12.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation12.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation12#rotTime"), 2)*1000;
    end;	
local rotationPartNodeRotation14= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation14#index"));
    if rotationPartNodeRotation14 ~= nil then
        self.Rotation14 = {};
        self.Rotation14.node = rotationPartNodeRotation14;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation14#minRot"));
        self.Rotation14.minRot = {};
        self.Rotation14.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation14.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation14.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation14#maxRot"));
        self.Rotation14.maxRot = {};
        self.Rotation14.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation14.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation14.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation14.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation14#rotTime"), 2)*1000;
    end;
local rotationPartNodeRotation7= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation7#index"));
    if rotationPartNodeRotation7 ~= nil then
        self.Rotation7 = {};
        self.Rotation7.node = rotationPartNodeRotation7;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation7#minRot"));
        self.Rotation7.minRot = {};
        self.Rotation7.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation7.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation7.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation7#maxRot"));
        self.Rotation7.maxRot = {};
        self.Rotation7.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation7.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation7.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation7.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation7#rotTime"), 2)*1000;
    end;
local rotationPartNodeRotation9= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation9#index"));
    if rotationPartNodeRotation9 ~= nil then
        self.Rotation9 = {};
        self.Rotation9.node = rotationPartNodeRotation9;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation9#minRot"));
        self.Rotation9.minRot = {};
        self.Rotation9.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation9.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation9.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation9#maxRot"));
        self.Rotation9.maxRot = {};
        self.Rotation9.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation9.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation9.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation9.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation9#rotTime"), 2)*1000;
    end;	
local rotationPartNodeRotation5= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation5#index"));
    if rotationPartNodeRotation5 ~= nil then
        self.Rotation5 = {};
        self.Rotation5.node = rotationPartNodeRotation5;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation5#minRot"));
        self.Rotation5.minRot = {};
        self.Rotation5.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation5.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation5.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation5#maxRot"));
        self.Rotation5.maxRot = {};
        self.Rotation5.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation5.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation5.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation5.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation5#rotTime"), 2)*1000;
    end;
local rotationPartNodeRotation6= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation6#index"));
    if rotationPartNodeRotation6 ~= nil then
        self.Rotation6 = {};
        self.Rotation6.node = rotationPartNodeRotation6;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation6#minRot"));
        self.Rotation6.minRot = {};
        self.Rotation6.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation6.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation6.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation6#maxRot"));
        self.Rotation6.maxRot = {};
        self.Rotation6.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation6.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation6.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation6.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation6#rotTime"), 2)*1000;
    end;
local rotationPartNodeRotation3= Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.Rotation3#index"));
    if rotationPartNodeRotation3 ~= nil then
        self.Rotation3 = {};
        self.Rotation3.node = rotationPartNodeRotation3;

        local x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation3#minRot"));
        self.Rotation3.minRot = {};
        self.Rotation3.minRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation3.minRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation3.minRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        x, y, z = Utils.getVectorFromString(getXMLString(xmlFile, "vehicle.Rotation3#maxRot"));
        self.Rotation3.maxRot = {};
        self.Rotation3.maxRot[1] = Utils.degToRad(Utils.getNoNil(x, 0));
        self.Rotation3.maxRot[2] = Utils.degToRad(Utils.getNoNil(y, 0));
        self.Rotation3.maxRot[3] = Utils.degToRad(Utils.getNoNil(z, 0));

        self.Rotation3.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.Rotation3#rotTime"), 2)*1000;
    end;

  self.currentRotationDir= false; -- die aktuelle richtung der drehung als Boolean(wahrheitswert)
end;

function Klappen:delete()
end;

function Klappen:mouseEvent(posX, posY, isDown, isUp, button)
end;

function Klappen:keyEvent(unicode, sym, modifier, isDown)
       if isDown and sym == Input.KEY_k then
             self:setRotateDirection(not self.currentRotationDir); -- tastenevents sollte man als funktion auslagern, um MP-sachen zu vereinfachen. Beim tastendruck wird eben die funktion aufgerufen nur eben mit dem genau anderen wert :D
      end;
     end;

function Klappen:readStream(streamId, connection)  -- wird Aufgerufen wenn ich selber ein Spiel join
     self:setRotateDirection(streamReadBool(streamId), true);  -- ich rufe also vom server die aktuelle richtung ab. True ist hier wichtig, weil ich will ja nur an meinem rechner den wert haben, und nich an alle anderen Mitspiele das Event schicken (weil die haben den aktuellen wert ja schon :-)) Das true hier also nie vergessen
end;

function Klappen:writeStream(streamId, connection)  -- wird am Server aufgerufen wenn ein Spieler joint
    streamWriteBool(streamId, self.currentRotationDir);   -- Wenn einspieler joint möchte ich ihm die aktuelle rotationsrichtung übertragen
end;

function Klappen:update(dt)
    if self.isThreshing and self.haspel ~= nil then
		rotate(self.haspel, dt*0.005, 0, 0);
    end;
end;


function Klappen:updateTick(dt)  -- ist wie Update nur verzögert um performance zu sparen. Prinzipiell sollte alles hier rein, bis auf sachen für die die verzögerung nicht reihct(z.b. tastendruck etz)
	if self.Rotation1 ~= nil then
		local x, y, z = getRotation(self.Rotation1.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation1.maxRot, self.Rotation1.minRot, 3, self.Rotation1.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation1.node, unpack(newRot));
   end;
   if self.Rotation12 ~= nil then
		local x, y, z = getRotation(self.Rotation12.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation12.maxRot, self.Rotation12.minRot, 3, self.Rotation12.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation12.node, unpack(newRot));
   end;
   if self.Rotation14 ~= nil then
		local x, y, z = getRotation(self.Rotation14.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation14.maxRot, self.Rotation14.minRot, 3, self.Rotation14.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation14.node, unpack(newRot));
   end;
	if self.Rotation5 ~= nil then
		local x, y, z = getRotation(self.Rotation5.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation5.maxRot, self.Rotation5.minRot, 3, self.Rotation5.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation5.node, unpack(newRot));
   end;
	if self.Rotation6 ~= nil then
		local x, y, z = getRotation(self.Rotation6.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation6.maxRot, self.Rotation6.minRot, 3, self.Rotation6.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation6.node, unpack(newRot));
   end;
	if self.Rotation3 ~= nil then
		local x, y, z = getRotation(self.Rotation3.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation3.maxRot, self.Rotation3.minRot, 3, self.Rotation3.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation3.node, unpack(newRot));
   end;
   if self.Rotation7 ~= nil then
		local x, y, z = getRotation(self.Rotation7.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation7.maxRot, self.Rotation7.minRot, 3, self.Rotation7.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation7.node, unpack(newRot));
   end;
   if self.Rotation9 ~= nil then
		local x, y, z = getRotation(self.Rotation9.node);
		local rot = {x,y,z};
		local newRot = Utils.getMovedLimitedValues(rot, self.Rotation9.maxRot, self.Rotation9.minRot, 3, self.Rotation9.rotTime, dt, not self.currentRotationDir); -- hier habe ich nur drehen druch currentRotationDir ersetzt
		setRotation(self.Rotation9.node, unpack(newRot));
   end;
end;

function Klappen:setRotateDirection(newDirection, noEventSend)  -- noEventSend bedeutet , dass wenn die variable den wert true hat kein event an andere mitspieler gesendet werden soll
    RotationEvent.sendEvent(self, newDirection, noEventSend);	-- wir versuchen das event zu senden. Als parameter übergeben wir die neue rotationDirection, die wir beim tastendruck setzen
    self.currentRotationDir = newDirection; -- wir setzen nun lokal die neue Richtung
end;

function Klappen:draw()
end; 
