MMPC/TankiOnline2.0DemoClient
3
0
Fork 0
mirror of https://github.com/MapMakersAndProgrammers/TankiOnline2.0DemoClient.git synced 2025-10-27 18:39:10 -07:00
Code Issues Packages Projects Releases Wiki Activity

Add mostly deobfuscated package, class and function name source

Browse Source
This commit is contained in:
Pyogenics
2025-05-09 17:55:37 +01:00
parent bbf438a33f
commit f8ac96858f
1034 changed files with 48614 additions and 40522 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/_codec/versions/version2/a3d/animation/CodecA3D2AnimationClip.as Normal file
View File

@@ -0,0 +1,72 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import versions.version2.a3d.animation.A3D2AnimationClip;
public class CodecA3D2AnimationClip implements ICodec
{
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var §_-2o§:ICodec;
private var §_-HX§:ICodec;
private var §_-XW§:ICodec;
private var §_-Td§:ICodec;
private var §_-Z-§:ICodec;
public function CodecA3D2AnimationClip()
{
super();
}
public function init(protocol:IProtocol) : void
{
this.§_-2o§ = protocol.getCodec(new TypeCodecInfo(int,false));
this.§_-HX§ = protocol.getCodec(new TypeCodecInfo(Boolean,false));
this.§_-XW§ = protocol.getCodec(new TypeCodecInfo(String,true));
this.§_-Td§ = protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),true,1));
this.§_-Z-§ = protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(int,false),false,1));
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
log = IClientLog(OSGi.getInstance().getService(IClientLog));
var value_id:int = int(this.§_-2o§.decode(protocolBuffer) as int);
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2AnimationClip","id",value_id);
var value_loop:Boolean = Boolean(this.§_-HX§.decode(protocolBuffer) as Boolean);
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2AnimationClip","loop",value_loop);
var value_name:String = this.§_-XW§.decode(protocolBuffer) as String;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2AnimationClip","name",value_name);
var value_objectIDs:Vector.<Long> = this.§_-Td§.decode(protocolBuffer) as Vector.<Long>;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2AnimationClip","objectIDs",value_objectIDs);
var value_tracks:Vector.<int> = this.§_-Z-§.decode(protocolBuffer) as Vector.<int>;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2AnimationClip","tracks",value_tracks);
return new A3D2AnimationClip(value_id,value_loop,value_name,value_objectIDs,value_tracks);
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var struct:A3D2AnimationClip = A3D2AnimationClip(object);
this.§_-2o§.encode(protocolBuffer,struct.id);
this.§_-HX§.encode(protocolBuffer,struct.loop);
this.§_-XW§.encode(protocolBuffer,struct.name);
this.§_-Td§.encode(protocolBuffer,struct.objectIDs);
this.§_-Z-§.encode(protocolBuffer,struct.tracks);
}
}
}

54
src/_codec/versions/version2/a3d/animation/CodecA3D2Keyframe.as Normal file
View File

@@ -0,0 +1,54 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import versions.version2.a3d.animation.A3D2Keyframe;
import versions.version2.a3d.objects.A3D2Transform;
public class CodecA3D2Keyframe implements ICodec
{
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var §_-dk§:ICodec;
private var §_-S2§:ICodec;
public function CodecA3D2Keyframe()
{
super();
}
public function init(protocol:IProtocol) : void
{
this.§_-dk§ = protocol.getCodec(new TypeCodecInfo(Float,false));
this.§_-S2§ = protocol.getCodec(new TypeCodecInfo(A3D2Transform,false));
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
log = IClientLog(OSGi.getInstance().getService(IClientLog));
var value_time:Number = Number(this.§_-dk§.decode(protocolBuffer) as Number);
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2Keyframe","time",value_time);
var value_transform:A3D2Transform = this.§_-S2§.decode(protocolBuffer) as A3D2Transform;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2Keyframe","transform",value_transform);
return new A3D2Keyframe(value_time,value_transform);
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var struct:A3D2Keyframe = A3D2Keyframe(object);
this.§_-dk§.encode(protocolBuffer,struct.time);
this.§_-S2§.encode(protocolBuffer,struct.transform);
}
}
}

60
src/_codec/versions/version2/a3d/animation/CodecA3D2Track.as Normal file
View File

@@ -0,0 +1,60 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Keyframe;
import versions.version2.a3d.animation.A3D2Track;
public class CodecA3D2Track implements ICodec
{
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var §_-2o§:ICodec;
private var §_-Ja§:ICodec;
private var §_-Fo§:ICodec;
public function CodecA3D2Track()
{
super();
}
public function init(protocol:IProtocol) : void
{
this.§_-2o§ = protocol.getCodec(new TypeCodecInfo(int,false));
this.§_-Ja§ = protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(A3D2Keyframe,false),false,1));
this.§_-Fo§ = protocol.getCodec(new TypeCodecInfo(String,false));
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
log = IClientLog(OSGi.getInstance().getService(IClientLog));
var value_id:int = int(this.§_-2o§.decode(protocolBuffer) as int);
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2Track","id",value_id);
var value_keyframes:Vector.<A3D2Keyframe> = this.§_-Ja§.decode(protocolBuffer) as Vector.<A3D2Keyframe>;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2Track","keyframes",value_keyframes);
var value_objectName:String = this.§_-Fo§.decode(protocolBuffer) as String;
log.log("codec","struct %1 field %2 value %3","versions.version2.a3d.animation.A3D2Track","objectName",value_objectName);
return new A3D2Track(value_id,value_keyframes,value_objectName);
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var struct:A3D2Track = A3D2Track(object);
this.§_-2o§.encode(protocolBuffer,struct.id);
this.§_-Ja§.encode(protocolBuffer,struct.keyframes);
this.§_-Fo§.encode(protocolBuffer,struct.objectName);
}
}
}

59
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2AnimationClipLevel1.as Normal file
View File

@@ -0,0 +1,59 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2AnimationClip;
public class VectorCodecA3D2AnimationClipLevel1 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2AnimationClipLevel1(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2AnimationClip,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<A3D2AnimationClip> = new Vector.<A3D2AnimationClip>(length,true);
for(var i:int = 0; i < length; i++)
{
result[i] = A3D2AnimationClip(this.elementCodec.decode(protocolBuffer));
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<A3D2AnimationClip> = Vector.<A3D2AnimationClip>(object);
var length:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length);
for(var i:int = 0; i < length; i++)
{
this.elementCodec.encode(protocolBuffer,data[i]);
}
}
}
}

89
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2AnimationClipLevel2.as Normal file
View File

@@ -0,0 +1,89 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2AnimationClip;
public class VectorCodecA3D2AnimationClipLevel2 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2AnimationClipLevel2(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2AnimationClip,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<A3D2AnimationClip> = null;
var i2:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<A3D2AnimationClip>> = new Vector.<Vector.<A3D2AnimationClip>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<A3D2AnimationClip>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; i2++)
{
items2[i2] = A3D2AnimationClip(this.elementCodec.decode(protocolBuffer));
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<A3D2AnimationClip> = null;
var length2:int = 0;
var i2:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<A3D2AnimationClip>> = Vector.<Vector.<A3D2AnimationClip>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
this.elementCodec.encode(protocolBuffer,items2[i2]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}

119
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2AnimationClipLevel3.as Normal file
View File

@@ -0,0 +1,119 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2AnimationClip;
public class VectorCodecA3D2AnimationClipLevel3 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2AnimationClipLevel3(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2AnimationClip,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<Vector.<A3D2AnimationClip>> = null;
var i2:int = 0;
var length3:int = 0;
var items3:Vector.<A3D2AnimationClip> = null;
var i3:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<Vector.<A3D2AnimationClip>>> = new Vector.<Vector.<Vector.<A3D2AnimationClip>>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<Vector.<A3D2AnimationClip>>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length3 = LengthCodecHelper.decodeLength(protocolBuffer);
items3 = new Vector.<A3D2AnimationClip>(length3,true);
items2[i2] = items3;
for(i3 = 0; i3 < length3; i3++)
{
items3[i3] = A3D2AnimationClip(this.elementCodec.decode(protocolBuffer));
}
}
i2++;
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<Vector.<A3D2AnimationClip>> = null;
var length2:int = 0;
var i2:int = 0;
var items3:Vector.<A3D2AnimationClip> = null;
var length3:int = 0;
var i3:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<Vector.<A3D2AnimationClip>>> = Vector.<Vector.<Vector.<A3D2AnimationClip>>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
items3 = items2[i1];
if(items3 != null)
{
protocolBuffer.optionalMap.addBit(false);
length3 = int(items3.length);
LengthCodecHelper.encodeLength(protocolBuffer,length3);
for(i3 = 0; i3 < length3; i3++)
{
this.elementCodec.encode(protocolBuffer,items3[i3]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}

59
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2KeyframeLevel1.as Normal file
View File

@@ -0,0 +1,59 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Keyframe;
public class VectorCodecA3D2KeyframeLevel1 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2KeyframeLevel1(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Keyframe,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<A3D2Keyframe> = new Vector.<A3D2Keyframe>(length,true);
for(var i:int = 0; i < length; i++)
{
result[i] = A3D2Keyframe(this.elementCodec.decode(protocolBuffer));
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<A3D2Keyframe> = Vector.<A3D2Keyframe>(object);
var length:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length);
for(var i:int = 0; i < length; i++)
{
this.elementCodec.encode(protocolBuffer,data[i]);
}
}
}
}

89
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2KeyframeLevel2.as Normal file
View File

@@ -0,0 +1,89 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Keyframe;
public class VectorCodecA3D2KeyframeLevel2 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2KeyframeLevel2(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Keyframe,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<A3D2Keyframe> = null;
var i2:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<A3D2Keyframe>> = new Vector.<Vector.<A3D2Keyframe>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<A3D2Keyframe>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; i2++)
{
items2[i2] = A3D2Keyframe(this.elementCodec.decode(protocolBuffer));
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<A3D2Keyframe> = null;
var length2:int = 0;
var i2:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<A3D2Keyframe>> = Vector.<Vector.<A3D2Keyframe>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
this.elementCodec.encode(protocolBuffer,items2[i2]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}

119
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2KeyframeLevel3.as Normal file
View File

@@ -0,0 +1,119 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Keyframe;
public class VectorCodecA3D2KeyframeLevel3 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2KeyframeLevel3(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Keyframe,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<Vector.<A3D2Keyframe>> = null;
var i2:int = 0;
var length3:int = 0;
var items3:Vector.<A3D2Keyframe> = null;
var i3:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<Vector.<A3D2Keyframe>>> = new Vector.<Vector.<Vector.<A3D2Keyframe>>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<Vector.<A3D2Keyframe>>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length3 = LengthCodecHelper.decodeLength(protocolBuffer);
items3 = new Vector.<A3D2Keyframe>(length3,true);
items2[i2] = items3;
for(i3 = 0; i3 < length3; i3++)
{
items3[i3] = A3D2Keyframe(this.elementCodec.decode(protocolBuffer));
}
}
i2++;
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<Vector.<A3D2Keyframe>> = null;
var length2:int = 0;
var i2:int = 0;
var items3:Vector.<A3D2Keyframe> = null;
var length3:int = 0;
var i3:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<Vector.<A3D2Keyframe>>> = Vector.<Vector.<Vector.<A3D2Keyframe>>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
items3 = items2[i1];
if(items3 != null)
{
protocolBuffer.optionalMap.addBit(false);
length3 = int(items3.length);
LengthCodecHelper.encodeLength(protocolBuffer,length3);
for(i3 = 0; i3 < length3; i3++)
{
this.elementCodec.encode(protocolBuffer,items3[i3]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}

59
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2TrackLevel1.as Normal file
View File

@@ -0,0 +1,59 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Track;
public class VectorCodecA3D2TrackLevel1 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2TrackLevel1(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Track,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<A3D2Track> = new Vector.<A3D2Track>(length,true);
for(var i:int = 0; i < length; i++)
{
result[i] = A3D2Track(this.elementCodec.decode(protocolBuffer));
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<A3D2Track> = Vector.<A3D2Track>(object);
var length:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length);
for(var i:int = 0; i < length; i++)
{
this.elementCodec.encode(protocolBuffer,data[i]);
}
}
}
}

89
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2TrackLevel2.as Normal file
View File

@@ -0,0 +1,89 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Track;
public class VectorCodecA3D2TrackLevel2 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2TrackLevel2(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Track,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<A3D2Track> = null;
var i2:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<A3D2Track>> = new Vector.<Vector.<A3D2Track>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<A3D2Track>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; i2++)
{
items2[i2] = A3D2Track(this.elementCodec.decode(protocolBuffer));
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<A3D2Track> = null;
var length2:int = 0;
var i2:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<A3D2Track>> = Vector.<Vector.<A3D2Track>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
this.elementCodec.encode(protocolBuffer,items2[i2]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}

119
src/_codec/versions/version2/a3d/animation/VectorCodecA3D2TrackLevel3.as Normal file
View File

@@ -0,0 +1,119 @@
package _codec.versions.version2.a3d.animation
{
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import versions.version2.a3d.animation.A3D2Track;
public class VectorCodecA3D2TrackLevel3 implements ICodec
{
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecA3D2TrackLevel3(optionalElement:Boolean)
{
super();
this.optionalElement = optionalElement;
}
public function init(protocol:IProtocol) : void
{
this.elementCodec = protocol.getCodec(new TypeCodecInfo(A3D2Track,false));
if(this.optionalElement)
{
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(protocolBuffer:ProtocolBuffer) : Object
{
var length2:int = 0;
var items2:Vector.<Vector.<A3D2Track>> = null;
var i2:int = 0;
var length3:int = 0;
var items3:Vector.<A3D2Track> = null;
var i3:int = 0;
var length1:int = LengthCodecHelper.decodeLength(protocolBuffer);
var result:Vector.<Vector.<Vector.<A3D2Track>>> = new Vector.<Vector.<Vector.<A3D2Track>>>(length1,true);
for(var i1:int = 0; i1 < length1; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length2 = LengthCodecHelper.decodeLength(protocolBuffer);
items2 = new Vector.<Vector.<A3D2Track>>(length2,true);
result[i1] = items2;
for(i2 = 0; i2 < length2; )
{
if(!protocolBuffer.optionalMap.OptionalMap())
{
length3 = LengthCodecHelper.decodeLength(protocolBuffer);
items3 = new Vector.<A3D2Track>(length3,true);
items2[i2] = items3;
for(i3 = 0; i3 < length3; i3++)
{
items3[i3] = A3D2Track(this.elementCodec.decode(protocolBuffer));
}
}
i2++;
}
}
i1++;
}
return result;
}
public function encode(protocolBuffer:ProtocolBuffer, object:Object) : void
{
var items2:Vector.<Vector.<A3D2Track>> = null;
var length2:int = 0;
var i2:int = 0;
var items3:Vector.<A3D2Track> = null;
var length3:int = 0;
var i3:int = 0;
if(object == null)
{
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var data:Vector.<Vector.<Vector.<A3D2Track>>> = Vector.<Vector.<Vector.<A3D2Track>>>(object);
var length1:int = int(data.length);
LengthCodecHelper.encodeLength(protocolBuffer,length1);
for(var i1:int = 0; i1 < length1; i1++)
{
items2 = data[i1];
if(items2 != null)
{
protocolBuffer.optionalMap.addBit(false);
length2 = int(items2.length);
LengthCodecHelper.encodeLength(protocolBuffer,length2);
for(i2 = 0; i2 < length2; i2++)
{
items3 = items2[i1];
if(items3 != null)
{
protocolBuffer.optionalMap.addBit(false);
length3 = int(items3.length);
LengthCodecHelper.encodeLength(protocolBuffer,length3);
for(i3 = 0; i3 < length3; i3++)
{
this.elementCodec.encode(protocolBuffer,items3[i3]);
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
else
{
protocolBuffer.optionalMap.addBit(true);
}
}
}
}
}