public BattleSpecification(int par0, global::robocode.control.BattlefieldSpecification par1, robocode.control.RobotSpecification[] par2) : 
         base(((global::net.sf.jni4net.jni.JNIEnv)(null))) {
     global::net.sf.jni4net.jni.JNIEnv @__env = global::net.sf.jni4net.jni.JNIEnv.ThreadEnv;
     using(new global::net.sf.jni4net.jni.LocalFrame(@__env, 16)){
     @__env.NewObject(global::robocode.control.BattleSpecification.staticClass, global::[email protected]__ctorBattleSpecification8, this, global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par0), global::net.sf.jni4net.utils.Convertor.ParStrongCp2J(par1), global::net.sf.jni4net.utils.Convertor.ParArrayStrongCp2J(@__env, par2));
     }
 }

 public BattleSpecification(global::robocode.control.BattlefieldSpecification par0, int par1, long par2, double par3, int par4, bool par5, robocode.control.RobotSpecification[] par6, robocode.control.RobotSetup[] par7) : 
         base(((global::net.sf.jni4net.jni.JNIEnv)(null))) {
     global::net.sf.jni4net.jni.JNIEnv @__env = global::net.sf.jni4net.jni.JNIEnv.ThreadEnv;
     using(new global::net.sf.jni4net.jni.LocalFrame(@__env, 26)){
     @__env.NewObject(global::robocode.control.BattleSpecification.staticClass, global::robocode.control.BattleSpecification.j4n__ctorBattleSpecification11, this, global::net.sf.jni4net.utils.Convertor.ParStrongCp2J(par0), global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par1), global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par2), global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par3), global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par4), global::net.sf.jni4net.utils.Convertor.ParPrimC2J(par5), global::net.sf.jni4net.utils.Convertor.ParArrayStrongCp2J(@__env, par6), global::net.sf.jni4net.utils.Convertor.ParArrayStrongCp2J(@__env, par7));
     }
 }

        private static IRobotSnapshot[] MapRobotSnapshots(robocode.control.snapshot.IRobotSnapshot[] robotSnapshots)
        {
            if (robotSnapshots == null)
            {
                return null;
            }

            IRobotSnapshot[] mappedSnapshots = new IRobotSnapshot[robotSnapshots.Length];

            for (int i = 0; i < robotSnapshots.Length; i++)
            {
                mappedSnapshots[i] = MapRobotSnapshot(robotSnapshots[i]);
            }
            return mappedSnapshots;
        }

 internal RobotSpecification(robocode.control.RobotSpecification robotSpecification)
 {
     this.robotSpecification = robotSpecification;
 }

 public void onTurnStarted(robocode.control.events.TurnStartedEvent evnt)
 {
     engine.OnTurnStarted(new TurnStartedEvent());
 }

 private static RobotState MapRobotState(robocode.control.snapshot.RobotState robotState)
 {
     switch (robotState.getValue())
     {
         case 0:
             return RobotState.Active;
         case 1:
             return RobotState.HitWall;
         case 2:
             return RobotState.HitRobot;
         case 3:
         default:
             return RobotState.Dead;
     }
 }

 public TurnSnapshot(robocode.control.snapshot.ITurnSnapshot turnSnapshot)
 {
     this.turnSnapshot = turnSnapshot;
 }

        private static IBulletSnapshot[] MapBulletSnapshots(robocode.control.snapshot.IBulletSnapshot[] bulletSnapshots)
        {
            if (bulletSnapshots == null)
            {
                return null;
            }

            IBulletSnapshot[] mappedSnapshots = new IBulletSnapshot[bulletSnapshots.Length];

            for (int i = 0; i < bulletSnapshots.Length; i++)
            {
                mappedSnapshots[i] = MapBulletSnapshot(bulletSnapshots[i]);
            }
            return mappedSnapshots;
        }

        private static IDebugProperty[] MapDebugProperties(robocode.control.snapshot.IDebugProperty[] debugProperties)
        {
            if (debugProperties == null)
            {
                return null;
            }

            IDebugProperty[] mappedProperties = new IDebugProperty[debugProperties.Length];

            for (int i = 0; i < debugProperties.Length; i++)
            {
                mappedProperties[i] = MapDebugProperty(debugProperties[i]);
            }
            return mappedProperties;
        }

 private static BattleCompletedEvent MapEvent(robocode.control.events.BattleCompletedEvent evnt)
 {
     return new BattleCompletedEvent(MapBattleRules(evnt.getBattleRules()), MapBattleResults(evnt.getIndexedResults()));
 }

 public void onBattleError(robocode.control.events.BattleErrorEvent evnt)
 {
     engine.OnBattleError(MapEvent(evnt));
 }

 public void onBattleMessage(robocode.control.events.BattleMessageEvent evnt)
 {
     engine.OnBattleMessage(MapEvent(evnt));
 }

 public void onTurnEnded(robocode.control.events.TurnEndedEvent evnt)
 {
     engine.OnTurnEnded(MapEvent(evnt));
 }

 private static IRobotSnapshot MapRobotSnapshot(robocode.control.snapshot.IRobotSnapshot robotSnapshot)
 {
     return new RobotSnapshot(robotSnapshot);
 }

 private static IScoreSnapshot MapScoreSnapshot(robocode.control.snapshot.IScoreSnapshot scoreSnapshot)
 {
     return new ScoreSnapshot(scoreSnapshot);
 }

 private static IBulletSnapshot MapBulletSnapshot(robocode.control.snapshot.IBulletSnapshot bulletSnapshot)
 {
     return new BulletSnapshot(bulletSnapshot);
 }

 private static IDebugProperty MapDebugProperty(robocode.control.snapshot.IDebugProperty debugProperty)
 {
     return new DebugProperty(debugProperty.getKey(), debugProperty.getValue());
 }

 private static BulletState MapBulletState(robocode.control.snapshot.BulletState bulletState)
 {
     switch (bulletState.getValue())
     {
         case 0:
             return BulletState.Fired;
         case 1:
             return BulletState.Moving;
         case 2:
             return BulletState.HitVictim;
         case 3:
             return BulletState.HitBullet;
         case 4:
             return BulletState.HitWall;
         case 5:
             return BulletState.Exploded;
         case 6:
         default:
             return BulletState.Inactive;
     }
 }

 public void onBattleResumed(robocode.control.events.BattleResumedEvent evnt)
 {
     engine.OnBattleResumed(new BattleResumedEvent());
 }

 public RobotSnapshot(robocode.control.snapshot.IRobotSnapshot robotSnapshot)
 {
     this.robotSnapshot = robotSnapshot;
 }