Ejemplo n.º 1
0
        public void MovePlayer(int tag, int num)
        {
            Tuple <double, double> vect;

            if (!server.Players[num].IsRemote)
            {
                vect = view.AngleByMousePos();
            }
            else
            {
                vect = Utily.MakePair <double>(server.Players[num].MousePos.Item1 - arena.map.players[tag].x, server.Players[num].MousePos.Item2 - arena.map.players[tag].y);
            }
            if (Utily.Hypot2(vect.Item1, vect.Item2) < Map.RPlayer * Map.RPlayer * 2)
            {
                arena.MovePlayer(tag, Utily.MakePair <double>(0, 0));
                view.MovePlayer(tag, Utily.MakePair <double>(0, 0));
            }
            else
            {
                int Forw = server.Players[num].Forward, Left = server.Players[num].Left;
                var newvect = Utily.MakePair <double>(vect.Item1 * Forw + vect.Item2 * Left, vect.Item2 * Forw - vect.Item1 * Left);
                arena.MovePlayer(tag, newvect);
                view.MovePlayer(tag, newvect);
            }
        }
Ejemplo n.º 2
0
 public void ReleaseMouseDown(int tag, int num, int button)
 {
     if (state == ControlState.BattleState)
     {
         if (button == (int)Mouse.Button.Left)
         {
             Tuple <double, double> vect;
             if (!server.Players[num].IsRemote)
             {
                 vect = view.AngleByMousePos();
             }
             else
             {
                 vect = vect = Utily.MakePair <double>(server.Players[num].MousePos.Item1 - arena.map.players[tag].x, server.Players[num].MousePos.Item2 - arena.map.players[tag].y);
             }
             if (Utily.Hypot2(vect.Item1, vect.Item2) == 0)
             {
                 return;
             }
             int tagArr = arena.FirePlayer(tag, vect);
             if (tagArr != -1)
             {
                 view.AddArrow(tagArr);
             }
         }
     }
 }
Ejemplo n.º 3
0
        public void MovePlayer(int tag, Tuple <double, double> speed)
        {
            double m = players[tag].Speed();
            Tuple <double, double> NewVect = Utily.Normalizing(speed, players[tag].Speed());

            map.MovePlayer(tag, NewVect);
        }
Ejemplo n.º 4
0
        public void ApplyString(string s)
        {
            if (s == "")
            {
                return;
            }
            int ind = s.IndexOf('#');

            int[] data = s.Substring(0, ind).Split().Select(int.Parse).ToArray();
            for (int i = 0; i < data.Length - 2; i += 2)
            {
                int         code = data[i];
                TypeKeyDown tkd  = (TypeKeyDown)data[i + 1];
                if (tkd == TypeKeyDown.KeyDown)
                {
                    AddKey(code);
                }
                if (tkd == TypeKeyDown.KeyUp)
                {
                    KeyUp(code);
                }
                if (tkd == TypeKeyDown.MouseDown)
                {
                    MouseDown(code);
                }
            }
            MousePos = Utily.MakePair <int>(data[data.Length - 2], data.Last());
            NickName = s.Substring(ind + 1);
        }
Ejemplo n.º 5
0
        /*public void HealHP(int HPHealed)
         * {
         *  if (Health + HPHealed >= MAX_HP)
         *  {
         *      Health = MAX_HP;
         *  }else
         *  {
         *      Health += HPHealed;
         *  }
         * }
         * public void NextItem()
         * {
         *  int yk = rightHand + 1;
         *  int cntItem = Inventory.totalNumberofItems;
         *  while (!inventory.isInStock(yk % cntItem) || yk % cntItem == 0
         || Items.allItems[yk % cntItem] is Arrow)
         ++yk;
         || rightHand = yk % cntItem;
         ||}
         ||public void PrevItem()
         ||{
         || int yk = rightHand - 1;
         || int cntItem = Inventory.totalNumberofItems;
         || while (!inventory.isInStock((yk + cntItem) % cntItem) || (yk + cntItem) % cntItem == 0
         || Items.allItems[(yk + cntItem) % cntItem] is Arrow)
         ||     --yk;
         || rightHand = (yk + cntItem) % cntItem;
         ||}*/
        /*
         * public void NextArrow()
         * {
         *  int yk = inventory.getCurrentArrow().id + 1;
         *  int cntItem = Inventory.totalNumberofItems;
         *  while (!inventory.isInStock(yk % cntItem) || !(Items.allItems[yk % cntItem] is Arrow))
         ++yk;
         *  inventory.setCurrentArrow(yk % cntItem);
         * }
         * public void PrevArrow()
         * {
         *  int yk = inventory.getCurrentArrow().id - 1;
         *  int cntItem = Inventory.totalNumberofItems;
         *  while (!inventory.isInStock((yk + cntItem) % cntItem) || !(Items.allItems[(yk + cntItem) % cntItem] is Arrow))
         *      --yk;
         *  inventory.setCurrentArrow(yk % cntItem);
         * }
         */
        /*
         * public string LargeString()
         * {
         *  StringBuilder ans = new StringBuilder();
         *  ans.Append(Health);
         *  ans.Append(" ");
         *  ans.Append(rightHand);
         *  ans.Append(" ");
         *  ans.Append(RightReloadTimer.ElapsedMilliseconds);
         *  ans.Append(" ");
         *  ans.Append(inventory.LargeString());
         *  return ans.ToString();
         * }
         * public string SmallString()
         * {
         *  StringBuilder ans = new StringBuilder();
         *  ans.Append(Health);
         *  ans.Append(" ");
         *  ans.Append(rightHand);
         *  ans.Append(inventory.SmallString());
         *  return ans.ToString();
         * }
         */
        public void TakeSmallString(string s)
        {
            var pla_inv = s.Split('#');
            var arr     = pla_inv[0].Split(' ');

            Health    = Utily.Parse(arr[0]);
            rightHand = Utily.Parse(arr[1]);
            inventory.TakeSmallString(pla_inv[1]);
        }
Ejemplo n.º 6
0
        private double Length(double x, double y, double x1, double y1, double x2, double y2)
        {
            double len = ((y1 - y2) * x + (x2 - x1) * y + (x1 * y2 - x2 * y1)) * ((y1 - y2) * x + (x2 - x1) * y + (x1 * y2 - x2 * y1)) / ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

            if (mul(x - x1, y - y1, x2 - x1, y2 - y1) < 0 || mul(x - x2, y - y2, x2 - x1, y2 - y1) < 0)
            {
                return(Math.Min(Utily.Hypot2(x - x1, y - y1), Utily.Hypot2(x - x2, y - y2)));
            }
            return(len);
        }
Ejemplo n.º 7
0
        public int AddPlayer(string name)
        {
            int tag = Utily.GetTag();

            players[tag] = new Player();
            players[tag].respawn();
            ArenaPlayer[tag] = new APlayer(name);
            map.AddPlayer(tag);
            map.SpawnPlayer(tag);
            return(tag);
        }
Ejemplo n.º 8
0
        public void Update()
        {
            map.UpDate();
            MEvent Event;

            while ((Event = map.NextEvent()) != null)
            {
                if (Event.Type == MEvents.PlayerArrow)
                {
                    int TagArrow  = ((MEventArrowHit)Event).TagArrow;
                    int TagPlayer = ((MEventArrowHit)Event).TagPlayer;
                    players[TagPlayer].recieveDamage(Arrows[TagArrow].dmg);
                    if (players[TagPlayer].isDead())
                    {
                        if (ArenaPlayer.ContainsKey(Arrows[TagArrow].creater))
                        {
                            ArenaPlayer[Arrows[TagArrow].creater].AddKill();
                        }
                        ArenaPlayer[TagPlayer].AddDeath();
                        if (players[TagPlayer].rightHand != 1)
                        {
                            int NewTag = Utily.GetTag();
                            Drops.Add(NewTag, new ADrop(1, players[TagPlayer].rightHand));
                            map.SpawnDrops(NewTag, map.players[TagPlayer].x, map.players[TagPlayer].y);
                        }
                        map.SpawnPlayer(TagPlayer);
                        players[TagPlayer].respawn();
                    }
                    Arrows.Remove(TagArrow);
                }
                if (Event.Type == MEvents.PlayerDrop)
                {
                    var drop = Drops[((MEventDrop)Event).TagDrop];
                    players[((MEventDrop)Event).TagPlayer].pickedUpItem(drop.id, drop.Count);
                    Drops.Remove(((MEventDrop)Event).TagDrop);
                    if (((MEventDrop)Event).BySpawner)
                    {
                        DropForRespawn.Enqueue(Utily.MakePair <long, int>(timer.ElapsedMilliseconds, ((MEventDrop)Event).NumSpawner));
                    }
                }
                if (Event.Type == MEvents.DestroyArrow)
                {
                    Arrows.Remove(((MEventDestroyArrow)Event).TagArrow);
                }
            }
            while (DropForRespawn.Count > 0 && DropForRespawn.Peek().Item1 + WaitRespawnDrop < timer.ElapsedMilliseconds)
            {
                int num = DropForRespawn.Dequeue().Item2;
                int tag = Utily.GetTag();
                map.SpawnDrops(num, tag);
                Drops.Add(tag, new ADrop(map.dropSpawners[num].count, map.dropSpawners[num].id));
            }
        }
Ejemplo n.º 9
0
        public void TakeLargeString(string s)
        {
            var arr = s.Split(' ');

            Mana               = Utily.Parse(arr[0]);
            currentArrow       = Utily.Parse(arr[1]);
            totalNumberofItems = Utily.Parse(arr[2]);
            for (int i = 0; i < totalNumberofItems; ++i)
            {
                inventory[i] = Utily.Parse(arr[3 + i]);
            }
        }
Ejemplo n.º 10
0
        public int TakeAllString(string s)
        {
            var BigBlock = s.Split('#');

            //map.TakeString(BigBlock[0]);
            TakeString(BigBlock[1], BigBlock[2], BigBlock[3]);
            var           pla    = BigBlock[4].Split(';');
            HashSet <int> IsUsed = new HashSet <int>();

            for (int i = 0; i < pla.Length; i++)
            {
                int ind = pla[i].IndexOf(' ');
                int tag = Utily.Parse(pla[i].Substring(0, ind));
                if (!players.ContainsKey(tag))
                {
                    players.Add(tag, new Player());
                }
                else
                {
                    IsUsed.Add(tag);
                }
                players[tag].TakeSmallString(pla[i].Substring(ind + 1));
            }
            int MainPlayerTag;
            {
                int ind = BigBlock[5].IndexOf(' ');
                int tag = Utily.Parse(BigBlock[5].Substring(0, ind));
                if (!players.ContainsKey(tag))
                {
                    players.Add(tag, new Player());
                }
                else
                {
                    IsUsed.Add(tag);
                }
                players[tag].TakeLargeString(BigBlock[5].Substring(ind + 1));
                MainPlayerTag = tag;
            }
            List <int> ForRemove = new List <int>();

            foreach (var i in players)
            {
                if (!IsUsed.Contains(i.Key))
                {
                    ForRemove.Add(i.Key);
                }
            }
            foreach (var i in ForRemove)
            {
                players.Remove(i);
            }
            return(MainPlayerTag);
        }
Ejemplo n.º 11
0
        public static MPlayer Load(string save)
        {
            string[] args = save.Split().ToArray();
            bool     tmp;
            bool     Exist = Boolean.TryParse(args[0], out tmp);
            double   x = double.Parse(args[1]), y = double.Parse(args[2]);
            Tuple <double, double> Speed = new Tuple <double, double>(double.Parse(args[3]), double.Parse(args[4]));
            MPlayer Pl = new MPlayer(Utily.GetTag(), x, y);

            Pl.Speed = Speed;
            Pl.Exist = Exist;
            return(Pl);
        }
Ejemplo n.º 12
0
        private bool IsCrossCircleSquare(double x, double y, double r, double x1, double y1, double x2, double y2)
        {
            if (y1 > y2)
            {
                Utily.Swap <double>(ref y1, ref y2);
            }
            if (x1 > x2)
            {
                Utily.Swap <double>(ref x1, ref x2);
            }
            double dist1 = GetDistToVertSegm(x1, y1, y2, x, y);
            double dist3 = GetDistToVertSegm(x2, y1, y2, x, y);
            double dist2 = GetDistToVertSegm(-y1, x1, x2, -y, x);
            double dist4 = GetDistToVertSegm(-y2, x1, x2, -y, x);
            double len   = Math.Min(Math.Min(dist1, dist2), Math.Min(dist3, dist4));

            return(len < r * r);
        }
Ejemplo n.º 13
0
 public void NewMap(string name)
 {
     map = new Map("./data/Maps/" + name + ".txt");
     foreach (var i in players)
     {
         map.AddPlayer(i.Key);
         players[i.Key].respawn();
     }
     Arrows.Clear();
     Drops.Clear();
     DropForRespawn.Clear();
     for (int i = 0; i < map.dropSpawners.Count; ++i)
     {
         int tag = Utily.GetTag();
         map.SpawnDrops(i, tag);
         Drops.Add(tag, new ADrop(map.dropSpawners[i].count, map.dropSpawners[i].id));
     }
     timer.Restart();
 }
Ejemplo n.º 14
0
        public int FirePlayer(int tag, Tuple <double, double> vect)
        {
            int dmg = players[tag].attack();

            if (dmg <= 0)
            {
                return(-1);
            }
            Tuple <double, double> NewVect = Utily.Normalizing(vect, players[tag].ArrowSpeed());
            int arTag = Utily.GetTag();
            int nowid = players[tag].inventory.getCurrentArrow().id;

            if (players[tag].getItemRight() is Magic)
            {
                nowid = players[tag].rightHand;
            }
            Arrows[arTag] = new AArow(tag, dmg, nowid);
            map.FirePlayer(tag, arTag, NewVect.Item1, NewVect.Item2);
            return(arTag);
        }
Ejemplo n.º 15
0
        public void SpawnPlayer(int Tag)
        {
            List <Tuple <double, double> > ListOfGoodPlace = new List <Tuple <double, double> >();

            foreach (var p in spawners)
            {
                Entity e   = new Entity(0, p.Item1, p.Item2, RPlayer);
                bool   bol = true;
                foreach (var pl in players)
                {
                    bol = bol && !IsCrossEntity(e, pl.Value);
                }
                if (bol)
                {
                    ListOfGoodPlace.Add(p);
                }
            }
            int i = Utily.Next() % ListOfGoodPlace.Count;

            SpawnPlayer(Tag, (int)ListOfGoodPlace[i].Item1, (int)ListOfGoodPlace[i].Item2);
        }
Ejemplo n.º 16
0
 public void AddKey(int key)
 {
     KeyDown.Enqueue(Utily.MakePair <int, TypeKeyDown>(key, TypeKeyDown.KeyDown));
     if (key == (int)Keyboard.Key.W)
     {
         isW = true;
     }
     if (key == (int)Keyboard.Key.S)
     {
         isS = true;
     }
     if (key == (int)Keyboard.Key.A)
     {
         isA = true;
     }
     if (key == (int)Keyboard.Key.D)
     {
         isD = true;
     }
     UpdateDir();
 }
Ejemplo n.º 17
0
 public void MouseDown(int button)
 {
     KeyDown.Enqueue(Utily.MakePair <int, TypeKeyDown>(button, TypeKeyDown.MouseDown));
 }
Ejemplo n.º 18
0
        public Tuple <double, double> AngleByMousePos()
        {
            var mp = viewPlayers[MainPlayer];

            return(Utily.MakePair <double>(NowMouseX - mp.x + CameraPosX, NowMouseY - mp.y + CameraPosY));
        }
Ejemplo n.º 19
0
        public void LoadMap(string path)
        {
            using (StreamReader sr = File.OpenText(path))
            {
                string        s    = "";
                List <string> args = new List <string>();
                while ((s = sr.ReadLine()) != null)
                {
                    args.Add(s);
                }
                int[] tmp = args[0].Split().Select(x => int.Parse(x)).ToArray();
                this.width = tmp[0]; this.height = tmp[1];
                int couPl = int.Parse(args[1]);
                this.players = new Dictionary <int, MPlayer>();
                for (int i = 2; i < couPl + 2; ++i)
                {
                    string   stmp = args[i];
                    string[] Tmp  = stmp.Split().ToArray();
                    this.players.Add(int.Parse(Tmp[0]), MPlayer.Load(stmp));
                }
                int couArr = int.Parse(args[couPl + 2]);
                this.arrows = new Dictionary <int, MArrow>();
                for (int i = couPl + 3; i < couPl + 3 + couArr; ++i)
                {
                    string   stmp = args[i];
                    string[] Tmp  = stmp.Split().ToArray();
                    this.arrows.Add(int.Parse(Tmp[0]), MArrow.Load(stmp));
                }
                int couDro = int.Parse(args[couArr + couPl + 3]);
                this.drops = new Dictionary <int, MDrop>();
                for (int i = couPl + 4 + couArr; i < couPl + 4 + couArr + couDro; ++i)
                {
                    string   stmp = args[i];
                    string[] Tmp  = stmp.Split().ToArray();
                    this.drops.Add(int.Parse(Tmp[0]), MDrop.Load(stmp));
                }
                int nowline    = 4 + couArr + couDro + couPl;
                int countSpawn = int.Parse(args[nowline]);
                ++nowline;
                spawners = new List <Tuple <double, double> >();
                for (int i = 0; i < countSpawn; ++i)
                {
                    int x = int.Parse(args[nowline].Split()[0]), y = int.Parse(args[nowline].Split()[1]);
                    ++nowline;
                    spawners.Add(Utily.MakePair <double>(x, y));
                }
                int countSpawnDrop = int.Parse(args[nowline]);
                ++nowline;
                dropSpawners = new List <DropSpawner>();
                for (int i = 0; i < countSpawnDrop; ++i)
                {
                    int x = int.Parse(args[nowline].Split()[0]), y = int.Parse(args[nowline].Split()[1]);
                    int cnt = int.Parse(args[nowline].Split()[2]), id = int.Parse(args[nowline].Split()[3]);
                    ++nowline;
                    dropSpawners.Add(new DropSpawner(x, y, id, cnt));
                }
                tmp         = args[nowline].Split().Select(x => int.Parse(x)).ToArray();
                this.Pwidth = tmp[0] + 2; this.Pheight = tmp[1] + 2;
                this.Field  = new List <List <Square> >();
                for (int x = 0; x < this.Pwidth; ++x)
                {
                    this.Field.Add(new List <Square>());
                }

                for (int i = 0; i < this.Pwidth; i++)
                {
                    this.Field[i].Add(new Square(i, 0, 1));
                }
                for (int i = 1; i < this.Pheight - 1; i++)
                {
                    this.Field[0].Add(new Square(0, i, 1));
                    this.Field[this.Pwidth - 1].Add(new Square(this.Pwidth - 1, i, 1));
                }
                for (int y = 1; y < this.Pheight - 1; ++y)
                {
                    string line = args[y + nowline].Trim();
                    int[]  agrs = line.Split().Select(x => int.Parse(x)).ToArray();
                    for (int x = 1; x < Pwidth - 1; ++x)
                    {
                        this.Field[x].Add(new Square(x, y, agrs[x - 1]));
                    }
                }
                for (int i = 0; i < this.Pwidth; i++)
                {
                    this.Field[i].Add(new Square(i, this.Pheight - 1, 1));
                }
            }
        }
Ejemplo n.º 20
0
 public void KeyUp(int key)
 {
     KeyDown.Enqueue(Utily.MakePair <int, TypeKeyDown>(key, TypeKeyDown.KeyUp));
 }
Ejemplo n.º 21
0
 /*
  * public string LargeString()
  * {
  *  StringBuilder ans = new StringBuilder();
  *  ans.Append(Mana);
  *  ans.Append(" ");
  *  ans.Append(currentArrow);
  *  ans.Append(" ");
  *  ans.Append(totalNumberofItems);
  *  for (int i = 0; i < totalNumberofItems; i++)
  *  {
  *      ans.Append(" ");
  *      ans.Append(inventory[i]);
  *  }
  *  return ans.ToString();
  * }
  * public string SmallString()
  * {
  *  return currentArrow.ToString();
  * }
  */
 public void TakeSmallString(string s)
 {
     currentArrow = Utily.Parse(s);
 }
Ejemplo n.º 22
0
        public void TakeString(string Arrow, string Drop, string Player)
        {
            var           arr    = Arrow.Split(',');
            HashSet <int> IsUsed = new HashSet <int>();

            for (int i = 0; i < arr.Length; i++)
            {
                var small = arr[i].Split(' ');
                int tag   = Utily.Parse(small[0]);
                int dmg   = Utily.Parse(small[1]);
                int id    = Utily.Parse(small[2]);
                if (Arrows.ContainsKey(tag))
                {
                    Arrows[tag].dmg = dmg;
                    Arrows[tag].id  = id;
                }
                else
                {
                    Arrows.Add(tag, new AArrow(dmg, id));
                    ArrowEvent.Enqueue(tag);
                }
                IsUsed.Add(tag);
            }
            List <int> ForRemove = new List <int>();

            foreach (var i in Arrows)
            {
                if (!IsUsed.Contains(i.Key))
                {
                    ForRemove.Add(i.Key);
                    ArrowEvent.Enqueue(-i.Key);
                }
            }
            foreach (var i in ForRemove)
            {
                Arrows.Remove(i);
            }

            var dro = Drop.Split(',');

            IsUsed.Clear();
            for (int i = 0; i < arr.Length; i++)
            {
                var small = dro[i].Split(' ');
                int tag   = Utily.Parse(small[0]);
                int cnt   = Utily.Parse(small[1]);
                int id    = Utily.Parse(small[2]);
                if (Drops.ContainsKey(tag))
                {
                    Drops[tag].Count = cnt;
                    Drops[tag].id    = id;
                }
                else
                {
                    Drops.Add(tag, new ADrop(cnt, id));
                    DropEvent.Enqueue(tag);
                }
                IsUsed.Add(tag);
            }
            ForRemove.Clear();
            foreach (var i in Drops)
            {
                if (!IsUsed.Contains(i.Key))
                {
                    ForRemove.Add(i.Key);
                    DropEvent.Enqueue(-i.Key);
                }
            }
            foreach (var i in ForRemove)
            {
                Drops.Remove(i);
            }

            var pla = Player.Split(',');

            IsUsed.Clear();
            for (int i = 0; i < arr.Length; i++)
            {
                var small = pla[i].Split(' ');
                int tag   = Utily.Parse(small[0]);
                int kill  = Utily.Parse(small[1]);
                int death = Utily.Parse(small[2]);
                if (ArenaPlayer.ContainsKey(tag))
                {
                    ArenaPlayer[tag].RealName = small[3];
                    IsUsed.Add(tag);
                }
                else
                {
                    ArenaPlayer.Add(tag, new APlayer(small[3]));
                }
                ArenaPlayer[tag].Kill  = kill;
                ArenaPlayer[tag].Death = death;
            }
            ForRemove.Clear();
            foreach (var i in ArenaPlayer)
            {
                if (!IsUsed.Contains(i.Key))
                {
                    ForRemove.Add(i.Key);
                }
            }
            foreach (var i in ForRemove)
            {
                ArenaPlayer.Remove(i);
            }
        }