Scripte MP ready

So ich hoffe ich kann damit bissl helfen:

[lua]

-- Prinzipiell sollte man Spezis immer mit einem Großbuchstaben beginnen: MyScript in dem fall aber das is heir erstmal egal.

myScript = {};

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

function myScript: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.

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;

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

function myScript:delete()
end;

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

function myScript:keyEvent(unicode, sym, modifier, isDown)
end;

function myScript: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 myScript: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 myScript:update(dt)

if InputBinding.isPressed(InputBinding.TASTE) 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
end;

end;

function myScript: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;
end;

function myScript: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 myScript:draw()
end;[/lua]

Das Event

[lua]RotationEvent = {};
RotationEvent_mt = Class(RotationEvent, Event);

InitEventClass(RotationEvent, "RotationEvent");

function RotationEvent:emptyNew() -- hoier wir ein leeres Event objekt erzeugt
local self = Event:new(RotationEvent_mt );
self.className="RotationEvent";
return self;
end;

function RotationEvent:new(vehicle, direction) -- Der konsturktor des Events (erzeugt eben ein neues Event). Wir wollen das vehicle (aufrufer) und die neue richtung speichern bzw. übertragen
self.vehicle = vehicle;
self.direction = direction;
return self;
end;

function RotationEvent:readStream(streamId, connection) -- wird aufgerufen wenn mich ein Event erreicht
local id = streamReadInt32(streamId); -- hier lesen wir die übertragene ID des vehicles aus
self.direction = streamReadBool(streamId); -- hier lesen wir die neue direction aus (es handelt sich hierbei um einen Bool (true/false)
self.vehicle = networkGetObject(id); -- wir wandeln nunn die ID des vehicles in das passende Objekt um
self:run(connection); -- das event wurde komplett empfangen und kann nun "ausgeführt" werden
end;

function RotationEvent:writeStream(streamId, connection) -- Wird aufgrufen wenn ich ein event verschicke (merke: reihenfolge der Daten muss mit der bei readStream übereinstimmen (z.B. hier: erst die Vehicle-Id und dann die rotation senden, und bei Readstream dann eben erst die vehicleId lesen und dann die rotation)
streamWriteInt32(streamId, networkGetObjectId(self.vehicle)); -- wir übertragen das Vehicle in form seiner ID
streamWriteBool(streamId, self.direction ); -- wir übertragen die neue direction
end;

function RotationEvent:run(connection) -- wir führen das empfangene event aus
self.vehicle:setRotateDirection(self.direction, true); -- wir rufen die funktion setRotateDirection auf, damit auch hier bei uns die drehrichtung geändert wird. Das true ist hier wichtig, dann wir haben ein event erhalten, d.h. wir brauchen es nicht mehr versenden, weil es alle anderen mitpsieler schon erreicht hat! Das true also hier nie vergessen!!!!!!
if not connection:getIsServer() then -- wenn der Empfänger des Events der Server ist, dann soll er das Event an alle anderen Clients schicken
g_server:broadcastEvent(RotationEvent:new(self.vehicle, self.direction), nil, connection, self.object);
end;
end;

function RotationEvent.sendEvent(vehicle, direction, noEventSend) -- hilfsfunktion, die Events anstößte (wirde von setRotateDirection in der Spezi aufgerufen)
if noEventSend == nil or noEventSend == false then
if g_server ~= nil then -- wenn wir der Server sind dann schicken wir das event an alle clients
g_server:broadcastEvent(RotationEvent:new(vehicle, direction), nil, nil, vehicle);
else -- wenn wir ein Client sind dann schicken wir das event zum server
g_client:getServerConnection():sendEvent(RotationEvent:new(vehicle, directiont));
end;
end;
end;
[/lua]

habe auch mal eine frage hierzu:

wie muss ich die einträge in der ersten lua abändern damit sie auch in einer anderen lua funktionieren bzw. welche sachen sind änderbar
oder andersgesagt: welche einträge müssen in der lua vorhanden sein damit eine bestimmte funktion mp tauglich ist?

grüße...muss den thread mal wieder ins leben rufen...habe folgendes problem...bin dabei die strawSpec für den MP umzuschreiben....jetzt weis ich aber nicht, was ich bei

function myScript:setRotateDirection(newDirection, noEventSend) -- noEventSend bedeutet , dass wenn die variable(da es ja 2 sind) 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;

schreiben soll, da diese ja 2 funktionen hat...komm aber einfach nicht weiter,und ich denke, die geschichte is bissl komplizierter....anbei mal die lua...
hoffe mir kann einer helfen...
mfg chris

mal kurz ne kleine themenabweichung:

@stx375: willst du das teil nur um eine bestimmt gradzahl drehen oder um eine achse rotieren lassen?

Bei sowas musst du dir dann die x,y,z werte des sich drehenden Teiles ausgeben lassen diese übertragen

wenn das ne feste animation ist, dann mach das mit der Animations-Spezi, die ist bereits gesynched.

wenn das zB was unwichtiges is wie ne haspel, dann schau dir mal das Script vom Kärcher an wie das da gelöst ist mit dem "TastenDruck"

ich übertrage da nur ein event wenn ich die taste drücke und einmal wenn ich sie loslasse... alles was dazwischen ist muss nicht übertragen werden, sondern eben nur das initiale event

Hallo,

@ Face: cool danke für deinen Script!!!

Hab nen kleinen Fehler in der Event.lua gefunden, und zwar ganz unten ist ein "t" hinter das direction geraten. Das müsst ihr noch selber entfernen!

Zitat

g_client:getServerConnection():sendEvent(RotationEvent:new(vehicle, directiont));

PS: was muss man denn tun wenn man mehrere Rotationen reinmachen will? und diese auch noch mit unterschiedlichen Tasten betätigen will?

also das man alle Rotation1 in Rotation2 usw umbenennt ist ja klar, aber wie mach ich es im Update Bereich, das funktioniert ja nicht das man das mit unterschiedlichen Tasten macht

oder muss man für jedes ein neues Script machen?

Danke!

Zitat von Sheldon

PS: was muss man denn tun wenn man mehrere Rotationen reinmachen will? und diese auch noch mit unterschiedlichen Tasten betätigen will?

Hi Jungs und Mädels,

Da Face so gütig war uns die Funktionsweise des MP hier zu erklären will ich auch mein "Senf" dazugeben da es mir sehr geholfen hat.

[lua]Window = {};

WindowAction = { --- ist eine Hilfe um die Zahl die mitübergeben wird darzustellen (Man könnte auch einfach nur eine Zahl mitübergeben, aber so wird es Übersichtlicher)

window = 1,
windowback = 2,

}

function Window.prerequisitesPresent(specializations)
return SpecializationUtil.hasSpecialization(Motorized, specializations);
end;

function Window:load(xmlFile)

self.setRotateDirectionWindow = SpecializationUtil.callSpecializationsFunction("setRotateDirectionWindow");


self.rotationPartwindowMax = false;
self.rotationPartwindowBackMax = false;


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

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

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

self.rotationPartwindow.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.window#rotTime"), 2)*1000;
self.rotationPartwindow.touchRotLimit = Utils.degToRad(Utils.getNoNil(getXMLString(xmlFile, "vehicle.window#touchRotLimit"), 10));
end;
local rotationPartNodewindowback = Utils.indexToObject(self.rootNode, getXMLString(xmlFile, "vehicle.windowback#index"));
if rotationPartNodewindowback ~= nil then
self.rotationPartwindowback = {};
self.rotationPartwindowback.node = rotationPartNodewindowback;

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

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

self.rotationPartwindowback.rotTime = Utils.getNoNil(getXMLString(xmlFile, "vehicle.windowback#rotTime"), 2)*1000;
self.rotationPartwindowback.touchRotLimit = Utils.degToRad(Utils.getNoNil(getXMLString(xmlFile, "vehicle.windowback#touchRotLimit"), 10));
end;




end;

function Window:keyEvent(unicode, sym, modifier, isDown)

if InputBinding.isPressed(InputBinding.WINDOW) then
---- Hier rufe ich die Funktion setRotateDirectionWindow auf und übergebe 2 Parameter Die Zahl 1 "hier nur dargestellt durch eine variable um den Überblick zu behalten" und das Gegenteil von der Variable "self.rotationPartwindowMax"
self:setRotateDirectionWindow(WindowAction.window, not self.rotationPartwindowMax);
end;
if InputBinding.isPressed(InputBinding.WINDOWBACK) then
---- Hier rufe ich die Funktion setRotateDirectionWindow auf und übergebe 2 Parameter Die Zahl 2 "hier nur dargestellt durch eine variable um den Überblick zu behalten" und das Gegenteil von der Variable "self.rotationPartwindowBackMax"
self:setRotateDirectionWindow(WindowAction.windowback, not self.rotationPartwindowBackMax);
end;

end;

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

function Window:readStream(streamId, connection)
self.rotationPartwindowMax = streamReadBool(streamId);
self.rotationPartwindowBackMax = streamReadBool(streamId);
end;

function Window:writeStream(streamId, connection)
streamWriteBool(streamId, self.rotationPartwindowMax);
streamWriteBool(streamId, self.rotationPartwindowBackMax);
end;

function Window:update(dt)


end;

function Window:updateTick(dt)

if self.rotationPartwindow ~= nil then
local x, y, z = getRotation(self.rotationPartwindow.node);
local rot = {x,y,z};
local newRot = Utils.getMovedLimitedValues(rot, self.rotationPartwindow.maxRot, self.rotationPartwindow.minRot, 3, self.rotationPartwindow.rotTime, dt, not self.rotationPartwindowMax);
setRotation(self.rotationPartwindow.node, unpack(newRot));
end;

if self.rotationPartwindowback ~= nil then
local x, y, z = getRotation(self.rotationPartwindowback.node);
local rot = {x,y,z};
local newRot = Utils.getMovedLimitedValues(rot, self.rotationPartwindowback.maxRot, self.rotationPartwindowback.minRot, 3, self.rotationPartwindowback.rotTime, dt, not self.rotationPartwindowBackMax);
setRotation(self.rotationPartwindowback.node, unpack(newRot));
end;

end;

function Window:setRotateDirectionWindow(action, state, noEventSend)
if action == WindowAction.window then -- Hier frage ich die Zahl ab und entscheide welches Fenster ich auf oder zumachen will (WindowAction.window ist eine Zahl in diesem Fall die 1)
self.rotationPartwindowMax = state;
elseif action == WindowAction.windowback then ---- Wenn die zahl 2 ist dann Mache das Hintere Fenster auf
self.rotationPartwindowBackMax = state;
end;
if noEventSend ~= true then
WindowEvent.sendEvent(self, action, state); -- Die Funktion ruft sendEvent auf und übergibt 3 Werte (self "also mein ID", action, "Ist eine Zahl an der ich festmache welches Fenster ich aufmachen will", state "Ist der eigentliche Wert also true oder false"
end;

end;

function Window:draw()
end;

function Window:onEnter()
end;

function Window:onLeave()
end;

function Window:delete()
end;

--- Und Hier die EventKlasse

WindowEvent = {};
WindowEvent_mt = Class(WindowEvent, Event);

InitEventClass(WindowEvent, "WindowEvent");

function WindowEvent:emptyNew()
local self = Event:new(WindowEvent_mt);
self.className="WindowEvent ";
return self;
end;

function WindowEvent:new(object, action, state)
local self = WindowEvent :emptyNew()
self.object = object;
self.action = action; ---- ist die Zahl die wir mitübergeben
self.state = state; ------Der eigentliche Wert also true oder false
return self;
end;

function WindowEvent:readStream(streamId, connection)
local id = streamReadInt32(streamId);
self.object = networkGetObject(id);
self.action = streamReadUInt8(streamId); ---- ist die Zahl die wir mitübergeben
self.state = streamReadBool(streamId); ------Der eigentliche Wert also true oder false

self.object:setRotateDirectionWindow(self.action, self.state, true);

if not connection:getIsServer() then
g_server:broadcastEvent(WindowEvent:new(self.object, self.action, self.state), nil, connection, self.object);
end;
end;

function WindowEvent:writeStream(streamId, connection)
streamWriteInt32(streamId, networkGetObjectId(self.object));
streamWriteUInt8(streamId, self.action);
streamWriteBool(streamId, self.state);
end;

function WindowEvent.sendEvent(object, action, state)
if g_server ~= nil then
g_server:broadcastEvent(WindowEvent:new(object, action, state), nil, nil, object);
else
g_client:getServerConnection():sendEvent(WindowEvent:new(object, action, state));
end;
end;
[/lua]

Ich hoffe ich konnte euch damit auch ein wenig helfen.

PS bevor ich es vergesse Danke Face und mach weiter so

Mfg Hitman