Exemple #1
0
        public RepairDisaster(EventSlot slot, long startTime, long endTime, StationPart stationPart) :
            base(slot, startTime, endTime)
        {
            StationPart = stationPart;
            IsSilenced  = false;

            switch (slot)
            {
            case EventSlot.North:
                Position = northDrawLoc;
                break;

            case EventSlot.South:
                Position = southDrawLoc;
                break;

            case EventSlot.East:
                Position = eastDrawLoc;
                break;

            case EventSlot.West:
                Position = westDrawLoc;
                break;

            case EventSlot.Center:
                Position = centerDrawLoc;
                break;
            }
        }
Exemple #2
0
        public DisasterEvent NextEvent() {
            //Next event time is last event time plus random value
            if (lastPlayer == 1) {
                lastPlayer = 0;
                long nextEventTime;
                if (lastP1EventStarted == 0) {
                    nextEventTime = synchronizer.Next(3000, 5000);
                } else {
                    nextEventTime = lastP1EventStarted + synchronizer.Next(minEventInterval, maxEventInterval);
                }

                var slots = Enum.GetValues(typeof(EventSlot)).Cast<EventSlot>().ToList();
                List<EventSlot> goodEvents = new List<EventSlot>();
                foreach (var slot in slots) {
                    if (p1EventSlots[slot] < nextEventTime) {
                        goodEvents.Add(slot);
                    }
                }

                EventSlot nextSlot;
                if (goodEvents.Count > 0) {
                    nextSlot = goodEvents[synchronizer.Next(0, goodEvents.Count)];
                } else {
                    nextEventTime += 10000;
                    foreach (var slot in slots) {
                        if (p1EventSlots[slot] < nextEventTime) {
                            goodEvents.Add(slot);
                        }
                    }
                    nextSlot = goodEvents[synchronizer.Next(0, slots.Count)];
                }

                long eventDuration = synchronizer.Next(minDuration, maxDuration);
                p1EventSlots[nextSlot] = nextEventTime + eventDuration;
                lastP1EventStarted = nextEventTime;

                //Currently only creating gas leaks
                var steamColors = Enum.GetValues(typeof(SteamColor));
                SteamColor steamColor = (SteamColor)(steamColors.GetValue(synchronizer.Next(0, steamColors.Length)));
                return new GasLeakDisaster(nextSlot, nextEventTime, nextEventTime + eventDuration, steamColor);
            } else {
                //Generate player 2 event
                lastPlayer = 1;
                long nextEventTime;
                if (lastP2EventStarted == 0) {
                    nextEventTime = synchronizer.Next(3000, 5000);
                } else {
                    nextEventTime = lastP2EventStarted + synchronizer.Next(minEventInterval, maxEventInterval);
                }

                var slots = Enum.GetValues(typeof(EventSlot)).Cast<EventSlot>().ToList();
                List<EventSlot> goodEvents = new List<EventSlot>();
                foreach (var slot in slots) {
                    if (p2EventSlots[slot] < nextEventTime) {
                        goodEvents.Add(slot);
                    }
                }

                EventSlot nextSlot;
                if (goodEvents.Count > 0) {
                    nextSlot = goodEvents[synchronizer.Next(0, goodEvents.Count)];
                } else {
                    nextEventTime += 10000;
                    foreach (var slot in slots) {
                        if (p2EventSlots[slot] < nextEventTime) {
                            goodEvents.Add(slot);
                        }
                    }
                    nextSlot = goodEvents[synchronizer.Next(0, slots.Count)];
                }

                long eventDuration = synchronizer.Next(minDuration, maxDuration);
                p2EventSlots[nextSlot] = nextEventTime + eventDuration;
                lastP2EventStarted = nextEventTime;

                //Choose damaged item
                var stationParts = Enum.GetValues(typeof(StationPart));
                StationPart stationPart = (StationPart)(stationParts.GetValue(synchronizer.Next(0, stationParts.Length)));
                return new RepairDisaster(nextSlot, nextEventTime, nextEventTime + eventDuration, stationPart);
            }
        }