public static Packet[] Package(int id, Enums.MessageTarget target, byte[] img)
 {
     int totalPackets = img.Length % 512 > 1 ? img.Length / 512 : (img.Length / 512) - 1;
     bool first = true;
     var packets = new List<Packet>();
     while (true)
     {
         if (first)
         {
             packets.Add(ProcessFirstChunk(img.Length, img.Take(512).ToArray(), id, target));
             first = false;
             img = img.Skip(512).ToArray();
         }
         else
         {
             if (img.Length > 512)
             {
                 packets.Add(ProcessBodyChunk(img.Take(512).ToArray(), id, target));
                 img = img.Skip(512).ToArray();
             }
             else
             {
                 packets.Add(ProcessLastChunk(img, id, target));
                 break;
             }
         }
     }
     return packets.ToArray();
 }

 public Luxury(string aer, string sistem, string enterain, string marca, int nrUsi, Enums.Culori culoare, Categorie categ, string serieSasiu)
     : base(marca, nrUsi, culoare, categ, serieSasiu)
 {
     this.AerConditionatC = aer;
     this.SistemParktronic = sistem;
     this.EntertainmentSystem = enterain;
 }

 public RolDialog(String _descripcion, Enums.tipoDialog tipoDialog)
 {
     InitializeComponent();
     this.tipo = tipoDialog;
     this.descripcionTextbox.Text = _descripcion;
     this.dr = DialogResult.Cancel;
 }

 private void ProcessTurnOutcome(Enums.TurnOutcome turnOutcome)
 {
     if (turnOutcome != Enums.TurnOutcome.MoveMadeAndPointScored)
         _numberOfTurnsWithNoPointsGained++;
     else
         _numberOfTurnsWithNoPointsGained = 0;
 }

 public FileManagerForm(Enums.TypePath tp, long id_controller)
 {
     InitializeComponent();
     path_work = getPath(tp, id_controller);
     searchFiles();
     webBrowser.DocumentText = TruckSystem.Properties.Resources.SelectOneFile;
 }

 public static void DrawNpc(RendererDestinationData destData, Map activeMap, Enums.MapID targetMapID, int npcSlot)
 {
     MapNpc npc = activeMap.MapNpcs[npcSlot];
     if (npc != null && npc.Num > 0 && npc.ScreenActive) {
         SpriteRenderer.DrawSprite(destData, activeMap, targetMapID, npc);
     }
 }

        public Hetman(Enums.Kolor_pionków kolor, int x, int y, bool ruch)
        {
            if (kolor == Enums.Kolor_pionków.Biale)
            {
                this.grafika = BasicBlue.Properties.Resources.HetmanWhite;
                this.kolor = Enums.Kolor_pionków.Biale;
            }
            else
            {
                this.grafika = BasicBlue.Properties.Resources.hetmanBlack;
                this.kolor = Enums.Kolor_pionków.Czarne;
            }
            this.pozycjaX = x;
            this.pozycjaY = y;
            this.zasieg = 8;
            this.punkty = 400;// Paweł Potera & Krzysztof Sakowicz
            this.litera = "Q";
            this.bylRuch = ruch;

            kierunkiRuchu.Add(Enums.KierunekRuchu.Skos);
            kierunkiRuchu.Add(Enums.KierunekRuchu.Gora);
            kierunkiRuchu.Add(Enums.KierunekRuchu.Dol);
            kierunkiRuchu.Add(Enums.KierunekRuchu.Bok);

            kierunekBicia.Add(Enums.KierunekRuchu.Gora);
            kierunekBicia.Add(Enums.KierunekRuchu.Dol);
            kierunekBicia.Add(Enums.KierunekRuchu.Bok);
            kierunekBicia.Add(Enums.KierunekRuchu.Skos);
        }

 public ManageFormResponse(Enums.ManageFormState responseCommand, string name, string picture, string newName)
 {
     Name = name;
     NewName = newName;
     Picture = picture;
     RespondCommand = responseCommand;
 }

 public static int DetermineMissionExpRequirement(Enums.ExplorerRank rank)
 {
     switch (rank) {
         case Enums.ExplorerRank.Normal:
             return 0;
         case Enums.ExplorerRank.Bronze:
             return 100;
         case Enums.ExplorerRank.Silver:
             return 300;
         case Enums.ExplorerRank.Gold:
             return 1600;
         case Enums.ExplorerRank.Diamond:
             return 3200;
         case Enums.ExplorerRank.Super:
             return 5000;
         case Enums.ExplorerRank.Ultra:
             return 7500;
         case Enums.ExplorerRank.Hyper:
             return 10500;
         case Enums.ExplorerRank.Master:
             return 13500;
         case Enums.ExplorerRank.MasterX:
             return 17000;
         case Enums.ExplorerRank.MasterXX:
             return 21000;
         case Enums.ExplorerRank.MasterXXX:
             return 25000;
         case Enums.ExplorerRank.Guildmaster:
             return 100000;
         default:
             return -1;
     }
 }

 public County CreateCounty(string name, Enums.Provinces province)
 {
     using (countyViewContext)
     {
         return countyViewContext.CreateCounty(name, province);
     }
 }

        public bool Edit(Guid id, string description, bool active, Enums.StartType startType, string trigger, string className, out string message)
        {
            using (var conn = this.OpenConnection())
            {
                string sql = @"
            UPDATE TOP(1) [Job]
            SET [email protected],[email protected],[email protected],[email protected],[Trigger][email protected]
            WHERE [email protected]
            ";
                var para = new
                {
                    ID = id,
                    Description = description,
                    Active = active,
                    StartType = (byte)startType,
                    Trigger = trigger,
                    ClassName = className
                };

                var rows = conn.Execute(sql, para);

                if (rows > 0)
                {
                    message = null;
                    return true;
                }
                else
                {
                    message = "Job不存在";
                    return false;
                }
            }
        }

        public static List<Photo> GetAllByFieldValue(string fieldName, Guid fieldValue, string fieldName2, Guid fieldValue2,Enums.ContextSubType ContextSubTypeId, Enums.PhotoCategory PhotoCategoryId)
        {
            List<Photo> returnEntityCollection = new List<Photo>();

            Database db = DatabaseFactory.CreateDatabase(Constants.CONNECTIONSTRING);
            DbCommand dbCommand = db.GetStoredProcCommand("usp_PhotoSelectAllBy" + fieldName2);

            db.AddInParameter(dbCommand, fieldName, DbType.Guid, fieldValue);
            db.AddInParameter(dbCommand, fieldName2, DbType.Guid, fieldValue2);
            db.AddInParameter(dbCommand, "ContextSubTypeId", DbType.Int32, (int)ContextSubTypeId);
            db.AddInParameter(dbCommand, "PhotoCategoryId", DbType.Int32, (int)PhotoCategoryId);

            using (IDataReader dataReader = db.ExecuteReader(dbCommand))
            {
                while (dataReader.Read())
                {
                    Photo entity = new Photo();

                    Utility.Generic.AssignDataReaderToEntity(dataReader, entity);
                    returnEntityCollection.Add(entity);
                }
            }

            return returnEntityCollection;
        }

 public GameRound(Player player, IEnumerable<Enums.Colors> choices, Enums.Colors answer)
 {
     _player = player;
     _date = DateTime.Now;
     _choices = convertFrom(choices);
     _answer = answer;
 }

        public bool Move(BaseEntity entity, Enums.Intent action)
        {
            entity.OldY = entity.Y;
            entity.OldX = entity.X;

            switch (action)
            {
                case Infrastructure.Enums.Intent.Idle:
                    break;
                case Infrastructure.Enums.Intent.MoveUp:
                    entity.Y -= 1;
                    break;
                case Infrastructure.Enums.Intent.MoveDown:
                    entity.Y += 1;
                    break;
                case Infrastructure.Enums.Intent.MoveRight:
                    entity.X += 1;
                    break;
                case Infrastructure.Enums.Intent.MoveLeft:
                    entity.X -= 1;
                    break;
                default: return false;
            }

            if (!IsLegal(entity.X, entity.Y))
            {
                entity.X = entity.OldX;
                entity.Y = entity.OldY;
                return false;
            }

            return true;
        }

 public Energy(int value, Enums.Element type, bool special, int BOGUS_ID)
     : base(BOGUS_ID)
 {
     this.value = value;
     this.type = type;
     this.special = special;
 }

 public MailSend(Invoice invoice, Enums.MessageType type)
 {
     ID = 0;
     this.Invoice = invoice;
     MessageType = type;
     Status = Enums.MailStatus.WAITING;
 }

 public bool Login(
     string username,
     string password,
     Enums.OnlineStatus onlineStatus = Enums.OnlineStatus.Online,
     Enums.DeviceType deviceType = Enums.DeviceType.Android)
 {
     try
     {
         Current = this;
         PacketManager.InitializeHandlers();
         CommandManager.InitializeCommands();
         Username = username;
         Password = password;
         OnlineStatus = onlineStatus;
         DeviceType = deviceType;
         _tcpClient = new TcpClient(_host, _port);
         Current = this;
         _networkStream = _tcpClient.GetStream();
         SendPacket(PacketTemplates.Logon(Username, DeviceType));
         _networkStream.BeginRead(_buffer, 0, _buffer.Length, ReadCallback, null);
         Console.WriteLine(_buffer.Length);
         return true;
     }
     catch (Exception a)
     {
         return false;
     }
 }

 public List<RideHostSession> GetPostedRides(int inAmt_, Enums.SortRideBy inSortRideBy_, FacebookUser inFacebookUser_ = null)
 {
     if (inFacebookUser_ != null)
         return _rideManager.GetRideSessions(inFacebookUser_);
     else
         return _rideManager.GetRideSessions(inSortRideBy_, inAmt_);
 }

        public static void DrawMapItem(RendererDestinationData destData, Map map, Enums.MapID targetMapID, int itemSlot)
        {
            Item item = ItemHelper.Items[map.MapItems[itemSlot].Num];

            Rectangle cropRect = new Rectangle((item.Pic - (item.Pic / 6) * 6) * Constants.TILE_WIDTH,
                                               (item.Pic / 6) * Constants.TILE_HEIGHT, Constants.TILE_WIDTH, Constants.TILE_HEIGHT);

            int itemX= map.MapItems[itemSlot].X;
            int itemY = map.MapItems[itemSlot].Y;

            Renderers.Maps.SeamlessWorldHelper.ConvertCoordinatesToBorderless(map, targetMapID, ref itemX, ref itemY);
            Point dstPoint = new Point(ScreenRenderer.ToScreenX(itemX * Constants.TILE_WIDTH),
                                       ScreenRenderer.ToScreenY(itemY * Constants.TILE_HEIGHT));

            //Surface itemSurface = new Surface(32,32);
            //itemSurface.Blit(Graphics.GraphicsManager.Items, cropRect);

            //if (darkness != null && !darkness.Disposed) {
            //    Point darknessPoint = new Point(darkness.Buffer.Width / 2 + dstPoint.X - darkness.Focus.X, darkness.Buffer.Height / 2 + dstPoint.Y - darkness.Focus.Y);
            //    Surface darknessSurface = new Surface(32, 32);
            //    darknessSurface.Blit(darkness.Buffer, new Point(0, 0), new Rectangle(darknessPoint, new Size(Constants.TILE_WIDTH, Constants.TILE_HEIGHT)));

            //}
            //destData.Blit(itemSurface, dstPoint);
            destData.Blit(Graphics.GraphicsManager.Items, dstPoint, cropRect);
        }

        /// <summary>
        /// Init fight with mobs
        /// </summary>
        public Fight(Fighter fighter1, Engines.Map.MonsterGroup monsters, Engines.MapEngine map,
                                                        Enums.FightTypeEnum fightType = Enums.FightTypeEnum.PvM)
        {
            //Stop the bonus timer
            monsters.StopBonusTimer();

            this.FightType = fightType;
            this.Map = map;
            this.ID = this.Map.GetActorAvailableID;
            this.RedTeam = new FightTeam(0, fighter1, this, false);
            this.BlueTeam = new FightTeam(1, new Fighter(-9, monsters.Leader, monsters), this, true);
            this.InitPlaces();
            this.InitMontersGroup(monsters);
            this.InitTimeline();
            this.PlacePlayer(fighter1);
            this.StartTime = Environment.TickCount;
            this.InitCheckFight();
            if (FightType == Enums.FightTypeEnum.PvM)
            {
                this.StartTimer = new System.Timers.Timer(30000);
                this.StartTimer.Enabled = true;
                this.StartTimer.Elapsed += new System.Timers.ElapsedEventHandler(StartTimer_Elapsed);
                this.StartTimer.Start();
            }
        }