Example #1
0
        public Weather(Rectangle2D[] area, Temperature temperature, DensityOfCloud cloud, QuantityOfWind wind, bool isStatic)
        {
            m_Area        = area;
            m_Temperature = temperature;
            m_Cloud       = cloud;
            m_Wind        = wind;
            m_IsStatic    = isStatic;

            m_Weathers.Add(this);

            m_NextWeatherChange = DateTime.Now + Interval;

            Timer.DelayCall(TimeSpan.FromSeconds(5.0), TimeSpan.FromSeconds(60.0), new TimerCallback(Weather_OnTick));
        }
Example #2
0
        public ConditionGump(Mobile from) : base(0, 0)
        {
            m_From = from;

            Closable   = true;
            Disposable = true;
            Dragable   = true;
            Resizable  = false;

            AddPage(0);

            //Background
            AddBackground(80, 72, 420, 500, 3600);
            AddBackground(90, 82, 400, 480, 9200);
            AddBackground(100, 92, 380, 460, 3500);
            AddBackground(115, 335, 350, 200, 9300);

            //Dragons
            AddImage(39, 53, 10440);
            AddImage(459, 53, 10441);

            //Titres
            AddImage(125, 110, 95);
            AddImage(132, 119, 96);
            AddImage(268, 119, 96);
            AddImage(445, 110, 97);

            AddImage(125, 350, 95);
            AddImage(132, 359, 96);
            AddImage(268, 359, 96);
            AddImage(445, 350, 97);

            AddHtml(248, 105, 200, 20, "<h3><basefont color=#025a>Condition<basefont></h3>", false, false);
            AddHtml(240, 344, 200, 20, "<h3><basefont color=#025a>Informations<basefont></h3>", false, false);

            try
            {
                Server.Misc.Weather weather = Server.Misc.Weather.GetWeather(from.Location);

                if (weather != null)
                {
                    TimeOfDay      t = Time.GetTimeofDay();
                    Season         s = (Season)Map.Felucca.Season;
                    DensityOfCloud c = weather.Cloud;
                    string[]       cloud;

                    if (s == Season.Winter)
                    {
                        if (t == TimeOfDay.Night)
                        {
                            cloud = m_DensityOfCloudWinterNight;
                        }
                        else
                        {
                            cloud = m_DensityOfCloudWinterDay;
                        }
                    }
                    else
                    {
                        if (t == TimeOfDay.Night)
                        {
                            cloud = m_DensityOfCloudSummerNight;
                        }
                        else
                        {
                            cloud = m_DensityOfCloudSummerDay;
                        }
                    }
                    int year, month, day;
                    Time.GetDate(out year, out month, out day);
                    try { AddHtml(130, 380, 200, 20, String.Format("<h3><basefont color=#5A4A31>Température : {0}<basefont></h3>", m_Temperature[(int)weather.Temperature]), false, false); }
                    catch (Exception ex) { Misc.ExceptionLogging.WriteLine(ex, String.Format("m_Temperature was {0}. weather.Temperature was {1}.", m_Temperature.ToString(), weather.Temperature.ToString())); }
                    try { AddHtml(130, 410, 200, 20, String.Format("<h3><basefont color=#5A4A31>Temps : {0}<basefont></h3>", cloud[(int)c]), false, false); }
                    catch (Exception ex) { Misc.ExceptionLogging.WriteLine(ex, String.Format("cloud was {0}. c was {1}.", cloud.ToString(), c.ToString())); }
                    try { AddHtml(130, 440, 200, 20, String.Format("<h3><basefont color=#5A4A31>Vent : {0}<basefont></h3>", m_QuantityOfWind[(int)weather.Wind]), false, false); }
                    catch (Exception ex) { Misc.ExceptionLogging.WriteLine(ex, String.Format("m_QuantityOfWind was {0}. weather.Wind was {1}.", m_QuantityOfWind.ToString(), weather.Wind.ToString())); }
                    try { AddHtml(130, 470, 200, 20, String.Format("<h3><basefont color=#5A4A31>Saison : {0}<basefont></h3>", m_Season[(int)s]), false, false); }
                    catch (Exception ex) { Misc.ExceptionLogging.WriteLine(ex, String.Format("m_Season was {0}. s was {1}.", m_Season.ToString(), s.ToString())); }
                    AddHtml(130, 500, 200, 20, String.Format("<h3><basefont color=#5A4A31>Année : {0}<basefont></h3>", year), false, false);
                    int gumpID;

                    switch (c)
                    {
                    default:     //DensityOfCloud.Cloud0
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay: gumpID = 1574; break;

                        case TimeOfDay.ScaleToNight: gumpID = 1538; break;

                        case TimeOfDay.Night: gumpID = 1537; break;

                        default: gumpID = 1536; break;             //TimeOfDay.Day
                        }

                        break;
                    }

                    case DensityOfCloud.Ensolleile:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1541; break;

                        case TimeOfDay.Night: gumpID = 1540; break;

                        default: gumpID = 1539; break;
                        }

                        break;
                    }

                    case DensityOfCloud.PassageNuageux:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1544; break;

                        case TimeOfDay.Night: gumpID = 1543; break;

                        default: gumpID = 1542; break;
                        }

                        break;
                    }

                    case DensityOfCloud.CielVariable:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1547; break;

                        case TimeOfDay.Night: gumpID = 1546; break;

                        default: gumpID = 1545; break;
                        }

                        break;
                    }

                    case DensityOfCloud.NuageuxAvecEclaircies:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1550; break;

                        case TimeOfDay.Night: gumpID = 1549; break;

                        default: gumpID = 1548; break;
                        }

                        break;
                    }

                    case DensityOfCloud.Nuageux:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1562; break;

                        case TimeOfDay.Night: gumpID = 1561; break;

                        default: gumpID = 1560; break;
                        }

                        break;
                    }

                    case DensityOfCloud.FaiblePluie:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay: gumpID = 1572; break;

                        case TimeOfDay.ScaleToNight: gumpID = 1565; break;

                        case TimeOfDay.Night: gumpID = 1564; break;

                        default: gumpID = 1563; break;
                        }

                        break;
                    }

                    case DensityOfCloud.Pluie:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay: gumpID = 1573; break;

                        case TimeOfDay.ScaleToNight: gumpID = 1568; break;

                        case TimeOfDay.Night: gumpID = 1567; break;

                        default: gumpID = 1566; break;
                        }

                        break;
                    }

                    case DensityOfCloud.FortePluie:
                    {
                        switch (t)
                        {
                        case TimeOfDay.ScaleToDay:
                        case TimeOfDay.ScaleToNight: gumpID = 1571; break;

                        case TimeOfDay.Night: gumpID = 1570; break;

                        default: gumpID = 1569; break;
                        }

                        break;
                    }

                    case DensityOfCloud.Caverne:
                    {
                        gumpID = 1551;

                        break;
                    }
                    }

                    //AddImage(257, 88, gumpID);
                    AddBackground(200, 145, 170, 133, 2620);
                    AddButton(205, 150, gumpID, gumpID, 1, GumpButtonType.Reply, 0);
                }
            }
            catch (Exception ex)
            {
                Misc.ExceptionLogging.WriteLine(ex);
            }

            //Image
            //AddBackground(200, 145, 170, 133, 2620);
            //AddButton(205, 150, 1536, 1536, 1, GumpButtonType.Reply, 0);
        }
Example #3
0
 public static void AddWeather(Temperature temperature, DensityOfCloud cloud, QuantityOfWind wind, bool isStatic, params Rectangle2D[] area)
 {
     new Weather(area, temperature, cloud, wind, isStatic);
 }
Example #4
0
        public virtual void Weather_OnTick()
        {
            int  type             = 0xFE;
            int  density          = 0;
            int  temperature      = IsUnderZero ? -30 : 30;
            bool wasRaining       = IsRaining;
            bool seasonHasChanged = false;

            if (m_NextWeatherChange < DateTime.Now)
            {
                m_Temperature = GenerateTemperature();
                m_Cloud       = GenerateCloud();
                m_Wind        = GenerateWind();

                m_NextWeatherChange = DateTime.Now + Interval;
            }

            if (IsRaining)
            {
                if (!IsUnderZero)
                {
                    type = 0;
                }
                else
                {
                    type = 2;
                }

                if (m_Cloud == DensityOfCloud.FaiblePluie)
                {
                    density = 10;
                }
                else if (m_Cloud == DensityOfCloud.Pluie)
                {
                    density = 40;
                }
                else if (m_Cloud == DensityOfCloud.FortePluie)
                {
                    density = 70;
                }
            }

            int year, month, day;

            Time.GetDate(out year, out month, out day);

            Season season = Time.Months[month - 1].Season;

            if (Map.Felucca.Season != (int)season)
            {
                Map.Felucca.Season = (int)season;
                Time.OnSeasonChange(season);
                seasonHasChanged = true;
            }

            List <NetState> states = NetState.Instances;

            Packet weatherPacket = null;
            Packet seasonPacket  = null;

            for (int i = 0; i < states.Count; ++i)
            {
                NetState ns  = (NetState)states[i];
                Mobile   mob = ns.Mobile;

                if (mob == null || mob.Map != Map.Felucca)
                {
                    continue;
                }

                if (seasonHasChanged)
                {
                    if (seasonPacket == null)
                    {
                        seasonPacket = Packet.Acquire(new SeasonChange(Map.Felucca.Season, false));
                    }

                    ns.Send(seasonPacket);

                    mob.CheckLightLevels(false);
                }

                bool contains = (m_Area.Length == 0);

                for (int j = 0; !contains && j < m_Area.Length; ++j)
                {
                    contains = m_Area[j].Contains(mob.Location);
                }

                if (!contains)
                {
                    continue;
                }

                if (weatherPacket == null)
                {
                    weatherPacket = Packet.Acquire(new Server.Network.Weather(type, density, temperature));
                }

                ns.Send(weatherPacket);

                if (wasRaining && !IsRaining)
                {
                    ns.Send(new MobileUpdate(mob));
                    ns.Send(new MobileIncoming(mob, mob));
                }

                //ns.Mobile.ProcessDelta();
            }
        }