// Use this for initialization
 void Start()
 {
     m_Grid = GameObject.FindGameObjectWithTag("Grid").GetComponent<Grid>();
     m_target = m_Grid.GetRandGrid();
     m_actor = GetComponent<IActor>();
     m_path = new List<GridNode>();
 }

        public IOutputPlug[] GetOutputPlugs(IActor actor, IInputPlug plug)
        {
            List<IOutputPlug> tempList = new List<IOutputPlug>();

            foreach (IOutputPlug p in outputPlugs)
            {
                // Cases to add.
                if (plug != null)
                {
                    if (p.IsCompatible(plug))
                        tempList.Add(p);
                }
                else if (actor != null)
                {
                    foreach (IInputPlug ip in actor.GetInputPlugs(null, null))
                    {
                        if (p.IsCompatible(ip))
                        {
                            tempList.Add(p);
                            break;
                        }
                    }
                }
                else
                {
                    tempList.Add(p);
                }
            }

            return tempList.ToArray();
        }

 /// <summary>
 /// Method that get called when a player want to enter a location also notifies to trip 
 /// recorder that player entered location
 /// </summary>
 /// <param name="actor"></param>
 /// <returns></returns>
 public virtual bool EnterLocation(IActor actor)
 {
     actor.CurrentLocation = this;
     //Console.WriteLine("cell {0} entered by actor {1}", LocationName, actor.Name);
     Recorder.EnterLocation(actor.Name, LocationName);
     return true;
 }

        public static ConfigFileActor FindConfigFile(IActor actor)
        {
            if (actor.Environment != null)
            {
                IActor currentActor = actor.Environment.Owner;

                if (currentActor != null)
                {
                    while (!(currentActor is ConfigFileActor))
                    {
                        currentActor = currentActor.Environment.Owner;

                        if (currentActor == null)
                            break;
                    }

                    if (currentActor != null)
                    {
                        if (currentActor is ConfigFileActor)
                        {
                            return (ConfigFileActor)currentActor;
                        }
                    }
                }
            }

            return null;
        }

        public PWUnit(IActor actor)
        {
            actor = Compatibility.Check<IPWRobot>(this, actor);
//            actor.World.Clocks.AddTrigger(new TimerTrigger(UpdateSpeed, TriggerFrequency)); adding trigger example
            rules = Compatibility.Check<IPWRules>(this, actor.Rules);
            
        }

 public PositionComponent(IActor actor, IClientSyncComponent syncComponent, ILogger logger)
     : base(actor)
 {
     _logger = logger;
     _syncComponent = syncComponent;
     _syncComponent.MessageReceived += new EventHandler<Core.Utility.EventArgs<Tuple<Core.Networking.IConnection, Core.Networking.Messages.ActorMessage>>>(_syncComponent_MessageReceived);
 }

 public PositionComponent(IActor actor, IServerSyncComponent syncComponent)
     : base(actor)
 {
     _syncComponent = syncComponent;
     _syncComponent.ConnectionEnteringRelevantSet += new EventHandler<Core.Utility.EventArgs<Core.Networking.IConnection>>(_syncComponent_ConnectionEnteringRelevantSet);
     sendPosition();
 }

 /// <summary>
 /// player can enter a location
 /// </summary>
 /// <param name="actor"></param>
 /// <returns></returns>
 public override bool EnterLocation(IActor actor)
 {
     if (base.EnterLocation(actor)) {
         actor.CurrentLocation = this;
         return true;
     } else return false;
 }

 public override void ExitLocation(IActor player)
 {
     DeadEnd(_location);
     Exit();
     _location.EnterLocation(player);
     _update = new UpdateRequest(player, _location, _check);
 }

		public IEnumerable<ICommand> Preprocess(IActor actor, ICommand command)
		{
			if (!(command is IDWMCommand))
			{
				yield return command;
				yield break;
			}
			var cmd = command as IDWMCommand;
			if (cmd.DifWheelMovement == null)
			{
				yield return command;
				yield break;
			}



			cmd.DifWheelMovement = new DifWheelMovement
			{
				LeftRotatingVelocity=cmd.DifWheelMovement.LeftRotatingVelocity*Multiplier,
				RightRotatingVelocity = cmd.DifWheelMovement.RightRotatingVelocity*Multiplier,
				Duration=cmd.DifWheelMovement.Duration,
			
			};
			yield return cmd as ICommand;

		}

        public IModifier CreateModifier(IActor target, IActor source, IStat stat, int amount)
        {
            IModifier modifier = this.CreateModifier(target, source, amount);
            modifier.SetAffectedStat(stat);

            return modifier;
        }

 public static Region GetRegionFromPosition(IActor actor)
 {
     Console.WriteLine(string.Format("posX {0} - posY {1}",actor.posX,actor.posY));
     int indexX = GetIndex(actor.posX);
     int indexY = GetIndex(actor.posY);
     return Region.arrRegion[indexX, indexY];
 }

        private void Explore(IActor actor, ILocation location)
        {
            //If an exit location is found, print the path and continue to find another exit
            if (location is ExitLocation)
            {
                if ((location as ExitLocation).ExitPreviouslyFound)
                    return;
                (location as ExitLocation).ExitPreviouslyFound = true;
                NumberOfExits++;
                TripRecorder.Instance.PrintTrip();
                terrain.PathToExit();
                terrain.TerrainPrinter(terrain.StartLocation);
                str= String.Format("{0} Number Of Exit(s) Found!", NumberOfExits);
                   Console.WriteLine(str);
                Console.WriteLine("*****************************************************************");
                return;
            }

            //When the location is dead end
            if (location.ListOfNeighbors().Count == 0)
            {
                (location as MarkedLocation).MarkRed();
                return;
            }

            //traverses to all the neigbors of a location
            foreach (var neighbor in location.ListOfNeighbors())
            {
                location.MoveToNeighbor(actor, neighbor.Key);
                Explore(actor, neighbor.Value);
            }
            //The location will be marked red when it backtracks
            (location as MarkedLocation).MarkRed();
        }

 public SimpleSyncComponent(IActor actor, IConnectionManager connectionManager)
 {
     _actor = actor;
     _connectionManager = connectionManager;
     _connectionManager.ConnectionInitialized += new EventHandler<EventArgs<IConnection>>(_connectionManager_ConnectionInitialized);
     _connectionManager.ConnectionTerminated += new EventHandler<EventArgs<IConnection>>(_connectionManager_ConnectionTerminated);
 }

 public void interact(IActor actor)
 {
     if (canInteract(actor)) {
         ICommand command = new PickUpCommand(actor, item);
         command.execute();
     }
 }

 /// <summary>
 /// explores the terrain
 /// </summary>
 public void Explore(Terrain terrain, IActor actor)
 {
     this.terrain = terrain;
     //the Explore starts from the start location in the terrain
     Explore(terrain.StartLocation, actor);
     Console.WriteLine("**** There are no more Exits ************");
 }

        public void Use(IActor targetActor)
        {
            //get variables
            IChunk chunk = this.Chunk;
            int x = this.Position.X;
            int y = this.Position.Y;
            int z = this.Position.Z;
            IActor actor = targetActor;

            //permission check, is the Player allowed to open the door?
            Chunk castedChunk = chunk as Chunk;
            string nationName = castedChunk.NationOwner;
            if ((!string.IsNullOrEmpty(nationName) && (actor.Nation != nationName)))
                return;

            //get the index for the Block array from the given x, y and z
            int index = chunk.GetBlockIndex(x, y, z);
            //get the specific Block data by its index
            ushort currentBlock = chunk.Blocks[index];

            if (IsOdd((int)currentBlock))
            {
                chunk.ChangeBlock((ushort)(currentBlock - 1), x, y, z);
            }
            else
            {
                chunk.ChangeBlock((ushort)(currentBlock + 1), x, y, z);
            }
        }

 public void AddActor(int actorId, IActor actor)
 {
     lock (_lock)
     {
         _actors.Add(actorId, actor);
     }
 }

        public void Use(IActor targetActor)
        {
            //get variables
            IChunk chunk = this.Chunk;
            int x = this.Position.X;
            int y = this.Position.Y;
            int z = this.Position.Z;
            IActor actor = targetActor;

            //permission check, is the Player allowed to open the door?
            Chunk castedChunk = chunk as Chunk;
            string nationName = castedChunk.NationOwner;
            if ((!string.IsNullOrEmpty(nationName) && (actor.Nation != nationName)))
                return;

            //get the index for the Block array from the given x, y and z
            int index = chunk.GetBlockIndex(x, y, z);
            //get the specific Block data by its index
            ushort currentBlock = chunk.Blocks[index];

            //get baseDoorID (reason why the doorID has to be a multiple of 10, for this script to properly work)
            int baseDoorID = ((int)currentBlock / 10) * 10;
            int offset = (int)currentBlock - baseDoorID;

            //call ToggleDoors function with variables
            ToggleDoor(chunk, baseDoorID, offset, x, y, z);
        }

        private static DynamicMethod BuildDispatchingMethod(IActor handler, IStructSizeCounter counter,
            Func<Type, int> messageIdGetter)
        {
            var handlerType = handler.GetType();
            var handleMethods = ActorRegistry.GetHandleMethods(handlerType)
                .ToDictionary(m => messageIdGetter(m.GetParameters()[1].ParameterType.GetElementType()), m => m)
                .OrderBy(kvp => kvp.Key)
                .ToArray();

            var dm = new DynamicMethod("ReadMessagesFor_" + handlerType.Namespace.Replace(".", "_") + handlerType.Name,
                typeof (void), new[] {typeof (MessageReader), typeof (int), typeof (ByteChunk)},
                handlerType.Assembly.Modules.First(), true);

            var actorField = typeof (MessageReader).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
                .Single(fi => fi.FieldType == typeof (IActor));

            var il = dm.GetILGenerator();

            // push handler
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldfld, actorField);
            il.Emit(OpCodes.Castclass, handlerType);

            var endLbl = il.DefineLabel();

            // dispatch
            foreach (var method in handleMethods)
            {
                var lbl = il.DefineLabel();
                il.Emit(OpCodes.Ldarg_1); // messageTypeId
                il.Emit(OpCodes.Ldc_I4, method.Key);
                il.Emit(OpCodes.Ceq);
                il.Emit(OpCodes.Brfalse_S, lbl);

                // push envelope
                il.Emit(OpCodes.Ldarg_2);
                il.Emit(OpCodes.Ldfld, typeof (ByteChunk).GetField("Pointer"));

                //var messageType = method.Value.GetParameters()[1].ParameterType.GetElementType();
                //il.Emit(OpCodes.Ldc_I4, (int)Marshal.OffsetOf(messageType, Envelope.FieldName));
                //il.Emit(OpCodes.Add);

                // push message
                il.Emit(OpCodes.Ldarg_2);
                il.Emit(OpCodes.Ldfld, typeof (ByteChunk).GetField("Pointer"));

                il.EmitCall(OpCodes.Callvirt, method.Value, null);
                il.Emit(OpCodes.Br_S, endLbl);
                il.MarkLabel(lbl);
            }

            // nothing was called, pop
            il.Emit(OpCodes.Pop);

            // end label
            il.MarkLabel(endLbl);
            il.Emit(OpCodes.Ret);
            return dm;
        }