/// <summary>
        /// Process any buffered messages separated by '\n'
        /// Then inform the view
        /// </summary>
        /// <param name="state"></param>
        private void ReceiveWorld(SocketState state)
        {
            //Gets the data from the state and splits it by a new line
            string totalData = state.GetData();

            string[] parts = Regex.Split(totalData, @"(?<=[\n])");

            // Loop until we have processed all messages.
            // We may have received more than one.

            //Gets the player number, which should only be once
            int playerNumber = 0;

            havePlayerNum = int.TryParse(parts[0], out playerNumber);
            parts[0]      = "";
            if (playerNumber != 0)
            {
                playerNum = playerNumber;
            }

            //Gets the dimensions of the world that should only happen once
            int dim = 0;

            haveDimension = int.TryParse(parts[1], out dim);
            parts[1]      = "";
            if (dim != 0)
            {
                worldDimension = dim;
                world          = new World(worldDimension);
            }

            //Iterates through all the data given by the server
            foreach (string p in parts)
            {
                // Ignore empty strings added by the regex splitter
                if (p.Length == 0)
                {
                    continue;
                }
                // The regex splitter will include the last string even if it doesn't end with a '\n',
                // So we need to ignore it if this happens.
                if (p[p.Length - 1] != '\n')
                {
                    break;
                }

                //Locks with a world so that we process information in a single thread
                lock (world)
                {
                    //Parses the object with the JSON
                    JObject jObject = JObject.Parse(p);

                    //Converts the JSON object to a token based on the name of the string
                    JToken projToken  = jObject["proj"];
                    JToken beamToken  = jObject["beam"];
                    JToken tankToken  = jObject["tank"];
                    JToken wallToken  = jObject["wall"];
                    JToken powerToken = jObject["power"];

                    //If the projToken is not null, i.e. if the JSON string passed was a projectile, then it goes in this condition
                    if (projToken != null)
                    {
                        //Deserializes the string and converts it to a projectile
                        Projectile proj = JsonConvert.DeserializeObject <Projectile>(p);

                        //Adds the projectile to the world
                        world.SetProjectile(proj.GetID(), proj);

                        //If projectile is dead, removes the projectile from the world
                        if (proj.GetDead() == true)
                        {
                            world.GetProjectile().Remove(proj.GetID());
                        }
                    }

                    //If the beamToken is not null, i.e. if the JSON string passed was a beam, then it goes in this condition
                    if (beamToken != null)
                    {
                        //Deserializes the string and converts it to a beam
                        Beams b = JsonConvert.DeserializeObject <Beams>(p);

                        //Adds the beam in the world's beam dictionary
                        world.SetBeams(b.GetBeamID(), b);
                    }

                    //If the tankToken is not null, i.e. if the JSON string passed was a tank, then it goes in this condition
                    if (tankToken != null)
                    {
                        //Deserializes the string and converts it to a tank
                        Tank t = JsonConvert.DeserializeObject <Tank>(p);

                        //Sets the color of the tank based on the tank's ID
                        t.SetColor(t.GetID());

                        //Adds the tank to the world's tank dictionary
                        world.SetTanks(t.GetID(), t);

                        //If the hitpoints of the tank are 0, then it remove it from the dictionary
                        if (t.GetHitPoints() == 0)
                        {
                            world.GetTanks().Remove(t.GetID());
                        }

                        //If the tank gets disconnected, then it remove it from the dictionary
                        if (t.GetDisconnected())
                        {
                            world.GetTanks().Remove(t.GetID());
                        }

                        //If the tank is dead, then it remove it from the dictionary
                        if (t.GetDead())
                        {
                            world.GetTanks().Remove(t.GetID());
                        }
                    }

                    //If the wallToken is not null, i.e. if the JSON string passed was a wall, then it goes in this condition
                    if (wallToken != null)
                    {
                        //Deserializes the string and converts it to a wall
                        Wall w = JsonConvert.DeserializeObject <Wall>(p);

                        //Adds the wall to the world's wall dictionary
                        world.SetWalls(w.GetID(), w);
                    }



                    //If the powerToken is not null, i.e. if the JSON string passed was a powerup, then it goes in this condition
                    if (powerToken != null)
                    {
                        //Deserializes the string and converts it to a powerup
                        Powerups power = JsonConvert.DeserializeObject <Powerups>(p);

                        //Adds the powerup to the world's powerup dictionary
                        world.SetPowerups(power.GetID(), power);

                        //If the powerup is dead, then it removes it from the dictionary
                        if (power.GetDead())
                        {
                            world.GetPowerups().Remove(power.GetID());
                        }
                    }
                }



                // Then remove it from the SocketState's growable buffer
                state.RemoveData(0, p.Length);
            }

            if (UpdateArrived != null)
            {
                // inform the view to redraw
                UpdateArrived();
            }

            //Inform the server
            Process();
        }