public async Task Post(Stringy file)
        {
            switch (file.value)
            {
            case "announce":
                await CreateAnnounce();

                break;

            case "pbnotes":
                await CreatePbnotes();

                break;

            case "noteshelp":
                await CreateNoteshelp();

                break;

            case "pad":
                await CreatePad();

                break;

            default:
                break;
            }
        }
Example #2
0
 public static Coordinate Objectify(string xml)
 {
     var coordinate = Stringy.ExtractSubStringFromBetween(xml, "<coordinate>", "</coordinate>");
     var x = Stringy.ExtractSubStringFromBetween(coordinate, "<x>", "</x>");
     var y = Stringy.ExtractSubStringFromBetween(coordinate, "<y>", "</y>");
     return new Coordinate(Double.Parse(x), Double.Parse(y));
 }
Example #3
0
        public static Ground Objectify(string str)
        {
            var a      = Stringy.SplitOn(str, "abbreviation")[0];
            var ground = Util.GetGrounds().FirstOrDefault(g => g.Abbreviation == a);

            return(ground);
        }
Example #4
0
        public async Task <bool> Put(Stringy uri)
        {
            LinkProcessor lp   = new LinkProcessor(null);
            bool          test = await lp.Test2(uri.value);

            return(test);
        }
Example #5
0
        public static Score Objectify(string str)
        {
            var goals  = Convert.ToInt32(Stringy.SplitOn(str, "goals")[0]);
            var points = Convert.ToInt32(Stringy.SplitOn(str, "points")[0]);

            return(new Score(goals, points));
        }
Example #6
0
        public static Quarter Objectify(string str)
        {
            var number    = Convert.ToInt32(Stringy.SplitOn(str, "number")[0]);
            var homeScore = Score.Objectify(Stringy.SplitOn(str, "homescore")[0]);
            var awayScore = Score.Objectify(Stringy.SplitOn(str, "awayscore")[0]);

            return(new Quarter(number, homeScore, awayScore));
        }
Example #7
0
        private static void Main()
        {
            takesAFunction(foo);

            Stringy f = returnsAFunction();            f();

            Stringy baz = () => "anonymous stringy\n";            fmt.Printf(baz());
        }
Example #8
0
        /*
         * public BsonDocument Bsonify()
         * {
         *  //TODO: this probably shouldn't know about Bson
         *  var rounds = new BsonArray();
         *  foreach (var round in Rounds)
         *  {
         *      rounds.Add(round.Bsonify());
         *  }
         *
         *  var match = new BsonDocument
         *  {
         *      {"year", Year},
         *      {"rounds", rounds}
         *  };
         *  return match;
         * }*/

        public static Season Objectify(string str)
        {
            var year   = Convert.ToInt32(Stringy.SplitOn(str, "year")[0]);
            var rs     = Stringy.SplitOn(Stringy.SplitOn(str, "rounds")[0], "round");
            var rounds = rs.Select(Round.Objectify).ToList();
            var season = new Season(year, rounds);

            return(season);
        }
Example #9
0
        public void ShouldReturnOneForExactMatch()
        {
            //Arrange
            const string original = "string";
            //Act
            var result = Stringy.Compare(original, original);

            //Assert
            Assert.AreEqual(1, result);
        }
Example #10
0
        public void ShouldReturnNegativeOneForExactNull()
        {
            //Arrange
            const string original = "string";
            //Act
            var result = Stringy.Compare(original, null);

            //Assert
            Assert.AreEqual(-1, result);
        }
Example #11
0
        public void ShouldReturnOneHundredCharacterSpacePaddedString()
        {
            //Arrange
            const string inString       = "Just 10 characters long";
            const int    requiredLength = 100;
            //Act
            string result = Stringy.Lengthen(inString, requiredLength);

            //assert
            Assert.AreEqual(100, result.Length);
            Assert.AreEqual(' ', result[99]);
        }
Example #12
0
        /*
         * public BsonDocument Bsonify()
         * {
         *  var matches = new BsonArray();
         *  foreach (var match in Matches)
         *  {
         *      matches.Add(match.Bsonify());
         *  }
         *
         *  var round = new BsonDocument
         *  {
         *      {"matches", matches},
         *      {"number", Number},
         *      {"year", Year}
         *  };
         *
         *  return round;
         * }
         */
        public static Round Objectify(string str)
        {
            var year    = Convert.ToInt32(Stringy.SplitOn(str, "year")[0]);
            var number  = Convert.ToInt32(Stringy.SplitOn(str, "number")[0]);
            var isFinal = Convert.ToBoolean(Stringy.SplitOn(str, "isfinal")[0]);
            var ms      = Stringy.SplitOn(Stringy.SplitOn(str, "matches")[0], "match");

            if (ms.Count == 0 || ms[0] == "0" || ms[0] == "")
            {
                return(new Round());
            }

            var matches = ms.Select(Match.Objectify).ToList();

            return(new Round(year, number, isFinal, matches));
        }
Example #13
0
        public static NetworkActor Objectify(string str)
        {
            var networkId        = Stringy.SplitOn(str, "network")[0];
            var oldNetworkIds    = Stringy.SplitOn(str, "oldNetworkIds")[0];
            var datasubsetString = Stringy.SplitOn(str, "datasubset")[0];
            var datasubset       = datasubsetString.Split(',').Select(bool.Parse).ToList();
            var successRate      = Double.Parse(Stringy.SplitOn(str, "successRate")[0]);

            var actor = new NetworkActor {
                Network = Network.Load("Network/" + networkId + ".ann")
            };
            var oldNetworks = oldNetworkIds.Select(oldNetworkId => Network.Load("Network/" + oldNetworkId + ".ann")).ToList();

            actor.Facade.SetMask(datasubset);
            actor.SuccessRate = successRate;
            actor.OldNetworks = oldNetworks;
            return(actor);
        }
Example #14
0
        static void Main( )
        {
            Stringy first = new Stringy(new char[] { 'R', 'o', 'm', 'a', '\0' });

            Console.WriteLine("String object = " + first.Str);

            Digits second = new Digits(new char[] { '1', '2', '3', '4', '\0' });

            Console.WriteLine("Digits object  = " + second.Str);
            Console.WriteLine("Increased Digits object = " + second.StringIncrease());

            Symvols third = new Symvols(new char[] { 'k', 'o', 'k', 'a', '\0' });

            Console.WriteLine("Symvols object = " + third.Str);
            Console.WriteLine("Increased Symvols object =  " + third.StringIncrease());

            Console.ReadKey();
        }
        public static GeographicallyIndependentTerritory Objectify(string xml)
        {
            var geographicallyIndependentBorderedRegion = Stringy.ExtractSubStringFromBetween(xml, "<geographicallyindependentterritory>", "</geographicallyindependentterritory>");


            var patternCoordinate = @"<territoryoutline>.*?<\/territoryoutline>";
            var rCoordinate       = new Regex(patternCoordinate);
            var simpleoutlineXmls = (from object match in rCoordinate.Matches(geographicallyIndependentBorderedRegion) select match.ToString()).ToList();

            var simpleOutline = new List <Coordinate>();

            foreach (var simpleoutlineXml in simpleoutlineXmls)
            {
                var coordinateXml = Stringy.ExtractSubStringFromBetween(simpleoutlineXml, "<territoryoutline>", "</territoryoutline>");
                var coordinate    = Coordinate.Objectify(coordinateXml);
                simpleOutline.Add(coordinate);
            }
            return(new GeographicallyIndependentTerritory(simpleOutline));
        }
Example #16
0
        public void ShouldPreferExactMatchToPartialToNoMatchToBlank()
        {
            //Arrange
            const string original = "string";
            const string partial  = "strizang";
            const string noMatch  = "qweyuop";
            const string blank    = "";
            //Act
            var exactResult   = Stringy.Compare(original, original);
            var partialResult = Stringy.Compare(original, partial);
            var noMatchResult = Stringy.Compare(original, noMatch);
            var blankResult   = Stringy.Compare(original, blank);

            //Assert
            Assert.IsTrue(exactResult > partialResult);
            Assert.IsTrue(partialResult > noMatchResult);
            Assert.AreEqual(0, noMatchResult);
            Assert.AreEqual(0, blankResult);
        }
Example #17
0
        /*public BsonDocument Bsonify()
         * {
         *  //TODO: this probably shouldn't know about Bson
         *  var quarters = new BsonDocument()
         *  {
         *      {"1", Quarters[0].Bsonify()},
         *      {"2", Quarters[1].Bsonify()},
         *      {"3", Quarters[2].Bsonify()},
         *      {"4", Quarters[3].Bsonify()}
         *  };
         *
         *  var match = new BsonDocument
         *  {
         *      {"home", Home.ApiName},
         *      {"away", Away.ApiName},
         *      {"ground", Ground.Abbreviation},
         *      {"date", Date},
         *      {"quarters", quarters},
         *      {"homeOdds", HomeOdds},
         *      {"awayOdds", AwayOdds}
         *  };
         *  return match;
         * }*/

        public static Match Objectify(string str)
        {
            var home   = Team.Objectify(Stringy.SplitOn(str, "hometeam")[0]);
            var away   = Team.Objectify(Stringy.SplitOn(str, "awayteam")[0]);
            var ground = Ground.Objectify(Stringy.SplitOn(str, "ground")[0]);
            var d      = Stringy.SplitOn(str, "date")[0];
            var date   = new DateTime();

            if (d.Length > 1)
            {
                date = DateTime.Parse(d, CultureInfo.GetCultureInfo("en-au"));
            }
            var qs       = Stringy.SplitOn(Stringy.SplitOn(str, "quarters")[0], "quarter");
            var quarters = qs.Select(Quarter.Objectify).ToList();
            var hos      = Stringy.SplitOn(str, "homeOdds")[0];
            var homeOdds = Double.Parse(hos);
            var aos      = Stringy.SplitOn(str, "awayOdds")[0];
            var awayOdds = Double.Parse(aos);

            return(new Match(home, away, quarters, ground, date, homeOdds, awayOdds));
        }
Example #18
0
        public static void UpdateSeasonByMethod(int year, string value)
        {
            var db = new MongoDb();

            if (value == "")
            {
                UpdateSeason(year);
            }
            else
            {
                var ss     = Stringy.SplitOn(Stringy.SplitOn(value, "seasons")[0], "season");
                var season = ss.Select(Season.Objectify).ToList().First();
                if (season.Year != year)
                {
                    return;
                }

                db.UpdateSeasons(new List <Season> {
                    season
                });
            }
        }
Example #19
0
        public static Country Objectify(string xml)
        {
            var country = Stringy.ExtractSubStringFromBetween(xml, "<country>", "</country>");

            var name       = Stringy.ExtractSubStringFromBetween(country, "<name>", "</name>");
            var alpha2code = Stringy.ExtractSubStringFromBetween(country, "<alpha2code>", "</alpha2code>");
            ColorDifferentiator differentiator = (ColorDifferentiator)Int32.Parse(Stringy.ExtractSubStringFromBetween(country, "<differentiator>", "</differentiator>"));


            var patternCountryoutline = @"<countryoutline>.*?<\/countryoutline>";
            var rCountryoutline       = new Regex(patternCountryoutline);
            var countryoutlineXmls    = (from object match in rCountryoutline.Matches(country) select match.ToString()).ToList();
            var countryOutline        = new List <GeographicallyIndependentTerritory>();

            foreach (var countryOutlineXml in countryoutlineXmls)
            {
                var geographicallyIndependentTerritoryXml = Stringy.ExtractSubStringFromBetween(countryOutlineXml, "<countryoutline>", "</countryoutline>");
                var geographicallyIndependentTerritory    = GeographicallyIndependentTerritory.Objectify(geographicallyIndependentTerritoryXml);
                countryOutline.Add(geographicallyIndependentTerritory);
            }
            return(new Country(name, alpha2code, differentiator, countryOutline));
        }
Example #20
0
        public async Task <bool> Post(Stringy uri)
        {
            LinkProcessor lp = new LinkProcessor(null);

            return(await lp.Test(uri.value));
        }
Example #21
0
 private static void takesAFunction(Stringy foo)
 {
     fmt.Printf("takesAFunction I: %v\n", foo());
 }
Example #22
0
        public void OnTrigger(GameClient Session, RoomItem Item, int Request, bool HasRights)
        {
            if (Session == null || Item == null)
            {
                return;
            }
            if (!HasRights)
            {
                return;
            }
            string          ExtraInfo    = "";
            bool            flag         = false;
            int             i            = 0;
            List <RoomItem> list         = new List <RoomItem>();
            string          ExtraString  = "";
            string          ExtraString2 = "";

            using (IQueryAdapter queryreactor = CyberEnvironment.GetDatabaseManager().getQueryReactor())
            {
                queryreactor.setQuery("SELECT * FROM wired_items WHERE id=@id LIMIT 1");
                queryreactor.addParameter("id", Item.Id);
                DataRow row = queryreactor.getRow();
                if (row != null)
                {
                    ExtraInfo    = row["string"].ToString();
                    i            = (int)row["delay"] / 500;
                    flag         = (row["bool"].ToString() == "1");
                    ExtraString  = row["extra_string"].ToString();
                    ExtraString2 = row["extra_string_2"].ToString();
                    string[] array = row["items"].ToString().Split(new char[]
                    {
                        ';'
                    });
                    for (int j = 0; j < array.Length; j++)
                    {
                        string s   = array[j];
                        uint   pId = 0u;
                        if (uint.TryParse(s, out pId))
                        {
                            RoomItem item = Item.GetRoom().GetRoomItemHandler().GetItem(pId);
                            if (item != null && !list.Contains(item))
                            {
                                list.Add(item);
                            }
                        }
                    }
                }
            }
            switch (Item.GetBaseItem().InteractionType)
            {
            case InteractionType.triggertimer:
            {
                ServerMessage serverMessage = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage.AppendBoolean(false);
                serverMessage.AppendInt32(5);
                serverMessage.AppendInt32(list.Count);
                foreach (RoomItem current in list)
                {
                    serverMessage.AppendUInt(current.Id);
                }
                serverMessage.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage.AppendUInt(Item.Id);
                serverMessage.AppendString(ExtraInfo);
                serverMessage.AppendInt32(1);
                serverMessage.AppendInt32(1);
                serverMessage.AppendInt32(1);
                serverMessage.AppendInt32(3);
                serverMessage.AppendInt32(0);
                serverMessage.AppendInt32(0);
                Session.SendMessage(serverMessage);
                return;
            }

            case InteractionType.triggerroomenter:
            {
                ServerMessage serverMessage2 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage2.AppendBoolean(false);
                serverMessage2.AppendInt32(0);
                serverMessage2.AppendInt32(list.Count);
                foreach (RoomItem current2 in list)
                {
                    serverMessage2.AppendUInt(current2.Id);
                }
                serverMessage2.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage2.AppendUInt(Item.Id);
                serverMessage2.AppendString(ExtraInfo);
                serverMessage2.AppendInt32(0);
                serverMessage2.AppendInt32(0);
                serverMessage2.AppendInt32(7);
                serverMessage2.AppendInt32(0);
                serverMessage2.AppendInt32(0);
                serverMessage2.AppendInt32(0);
                Session.SendMessage(serverMessage2);
                return;
            }

            case InteractionType.triggergameend:
            {
                ServerMessage serverMessage3 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage3.AppendBoolean(false);
                serverMessage3.AppendInt32(0);
                serverMessage3.AppendInt32(list.Count);
                foreach (RoomItem current3 in list)
                {
                    serverMessage3.AppendUInt(current3.Id);
                }
                serverMessage3.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage3.AppendUInt(Item.Id);
                serverMessage3.AppendString(ExtraInfo);
                serverMessage3.AppendInt32(0);
                serverMessage3.AppendInt32(0);
                serverMessage3.AppendInt32(8);
                serverMessage3.AppendInt32(0);
                serverMessage3.AppendInt32(0);
                serverMessage3.AppendInt32(0);
                Session.SendMessage(serverMessage3);
                return;
            }

            case InteractionType.triggergamestart:
            {
                ServerMessage serverMessage4 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage4.AppendBoolean(false);
                serverMessage4.AppendInt32(0);
                serverMessage4.AppendInt32(list.Count);
                foreach (RoomItem current4 in list)
                {
                    serverMessage4.AppendUInt(current4.Id);
                }
                serverMessage4.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage4.AppendUInt(Item.Id);
                serverMessage4.AppendString(ExtraInfo);
                serverMessage4.AppendInt32(0);
                serverMessage4.AppendInt32(0);
                serverMessage4.AppendInt32(8);
                serverMessage4.AppendInt32(0);
                serverMessage4.AppendInt32(0);
                serverMessage4.AppendInt32(0);
                Session.SendMessage(serverMessage4);
                return;
            }

            case InteractionType.triggerlongrepeater:
            {
                ServerMessage serverMessage = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage.AppendBoolean(false);
                serverMessage.AppendInt32(5);
                serverMessage.AppendInt32(0);
                serverMessage.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage.AppendUInt(Item.Id);
                serverMessage.AppendString("");
                serverMessage.AppendInt32(1);
                serverMessage.AppendInt32(i / 10);//fix
                serverMessage.AppendInt32(0);
                serverMessage.AppendInt32(12);
                serverMessage.AppendInt32(0);
                Session.SendMessage(serverMessage);
                return;
            }

            case InteractionType.triggerrepeater:
            {
                ServerMessage serverMessage5 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage5.AppendBoolean(false);
                serverMessage5.AppendInt32(5);
                serverMessage5.AppendInt32(list.Count);
                foreach (RoomItem current5 in list)
                {
                    serverMessage5.AppendUInt(current5.Id);
                }
                serverMessage5.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage5.AppendUInt(Item.Id);
                serverMessage5.AppendString(ExtraInfo);
                serverMessage5.AppendInt32(1);
                serverMessage5.AppendInt32(i);
                serverMessage5.AppendInt32(0);
                serverMessage5.AppendInt32(6);
                serverMessage5.AppendInt32(0);
                serverMessage5.AppendInt32(0);
                Session.SendMessage(serverMessage5);
                return;
            }

            case InteractionType.triggeronusersay:
            {
                ServerMessage serverMessage6 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage6.AppendBoolean(false);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(list.Count);
                foreach (RoomItem current6 in list)
                {
                    serverMessage6.AppendUInt(current6.Id);
                }
                serverMessage6.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage6.AppendUInt(Item.Id);
                serverMessage6.AppendString(ExtraInfo);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(0);
                serverMessage6.AppendInt32(0);
                Session.SendMessage(serverMessage6);
                return;
            }

            case InteractionType.triggerscoreachieved:
            {
                ServerMessage serverMessage7 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage7.AppendBoolean(false);
                serverMessage7.AppendInt32(5);
                serverMessage7.AppendInt32(0);
                serverMessage7.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage7.AppendUInt(Item.Id);
                serverMessage7.AppendString("");
                serverMessage7.AppendInt32(1);
                serverMessage7.AppendInt32((String.IsNullOrWhiteSpace(ExtraInfo)) ? 100 : int.Parse(ExtraInfo));
                serverMessage7.AppendInt32(0);
                serverMessage7.AppendInt32(10);
                serverMessage7.AppendInt32(0);
                serverMessage7.AppendInt32(0);
                Session.SendMessage(serverMessage7);
                return;
            }

            case InteractionType.triggerstatechanged:
            {
                ServerMessage serverMessage8 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage8.AppendBoolean(false);
                serverMessage8.AppendInt32(5);
                serverMessage8.AppendInt32(list.Count);
                foreach (RoomItem current8 in list)
                {
                    serverMessage8.AppendUInt(current8.Id);
                }
                serverMessage8.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage8.AppendUInt(Item.Id);
                serverMessage8.AppendString(ExtraInfo);
                serverMessage8.AppendInt32(0);
                serverMessage8.AppendInt32(0);
                serverMessage8.AppendInt32(1);
                serverMessage8.AppendInt32(i);
                serverMessage8.AppendInt32(0);
                serverMessage8.AppendInt32(0);
                Session.SendMessage(serverMessage8);
                return;
            }

            case InteractionType.triggerwalkonfurni:
            {
                ServerMessage serverMessage9 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage9.AppendBoolean(false);
                serverMessage9.AppendInt32(5);
                serverMessage9.AppendInt32(list.Count);
                foreach (RoomItem current9 in list)
                {
                    serverMessage9.AppendUInt(current9.Id);
                }
                serverMessage9.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage9.AppendUInt(Item.Id);
                serverMessage9.AppendString(ExtraInfo);
                serverMessage9.AppendInt32(0);
                serverMessage9.AppendInt32(0);
                serverMessage9.AppendInt32(1);
                serverMessage9.AppendInt32(0);
                serverMessage9.AppendInt32(0);
                serverMessage9.AppendInt32(0);
                Session.SendMessage(serverMessage9);
                return;
            }

            case InteractionType.actionmuteuser:
            {
                ServerMessage serverMessage18 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage18.AppendBoolean(false);
                serverMessage18.AppendInt32(5);
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage18.AppendUInt(Item.Id);
                serverMessage18.AppendString(ExtraInfo);
                serverMessage18.AppendInt32(1);
                serverMessage18.AppendInt32(i);
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(20);
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(0);
                Session.SendMessage(serverMessage18);
                return;
            }

            case InteractionType.triggerwalkofffurni:
            {
                ServerMessage serverMessage10 = new ServerMessage(Outgoing.WiredTriggerMessageComposer);
                serverMessage10.AppendBoolean(false);
                serverMessage10.AppendInt32(5);
                serverMessage10.AppendInt32(list.Count);
                foreach (RoomItem current10 in list)
                {
                    serverMessage10.AppendUInt(current10.Id);
                }
                serverMessage10.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage10.AppendUInt(Item.Id);
                serverMessage10.AppendString(ExtraInfo);
                serverMessage10.AppendInt32(0);
                serverMessage10.AppendInt32(0);
                serverMessage10.AppendInt32(1);
                serverMessage10.AppendInt32(0);
                serverMessage10.AppendInt32(0);
                serverMessage10.AppendInt32(0);
                serverMessage10.AppendInt32(0);
                Session.SendMessage(serverMessage10);
                return;
            }

            case InteractionType.actiongivescore:
            {
                // Por hacer.
                ServerMessage serverMessage11 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage11.AppendBoolean(false);
                serverMessage11.AppendInt32(5);
                serverMessage11.AppendInt32(0);
                serverMessage11.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage11.AppendUInt(Item.Id);
                serverMessage11.AppendString("");
                serverMessage11.AppendInt32(2);
                if (String.IsNullOrWhiteSpace(ExtraInfo))
                {
                    serverMessage11.AppendInt32(10); // Puntos a dar
                    serverMessage11.AppendInt32(1);  // Numero de veces por equipo
                }
                else
                {
                    string[] Integers = ExtraInfo.Split(',');
                    serverMessage11.AppendInt32(int.Parse(Integers[0])); // Puntos a dar
                    serverMessage11.AppendInt32(int.Parse(Integers[1])); // Numero de veces por equipo
                }
                serverMessage11.AppendInt32(0);
                serverMessage11.AppendInt32(6);
                serverMessage11.AppendInt32(0);
                serverMessage11.AppendInt32(0);
                serverMessage11.AppendInt32(0);
                Session.SendMessage(serverMessage11);
                return;
            }

            case InteractionType.conditiongroupmember:
            case InteractionType.conditionnotgroupmember:
            {
                ServerMessage Message = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                Message.AppendBoolean(false);
                Message.AppendInt32(5);
                Message.AppendInt32(0);
                Message.AppendInt32(Item.GetBaseItem().SpriteId);
                Message.AppendUInt(Item.Id);
                Message.AppendString("");
                Message.AppendInt32(0);
                Message.AppendInt32(0);
                Message.AppendInt32(10);
                Session.SendMessage(Message);
                return;
            }

            case InteractionType.conditionitemsmatches:
            case InteractionType.conditionitemsdontmatch:
            {
                ServerMessage serverMessage21 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage21.AppendBoolean(false);
                serverMessage21.AppendInt32(5);
                serverMessage21.AppendInt32(list.Count);
                foreach (RoomItem current20 in list)
                {
                    serverMessage21.AppendUInt(current20.Id);
                }
                serverMessage21.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage21.AppendUInt(Item.Id);
                serverMessage21.AppendString(ExtraString2);
                serverMessage21.AppendInt32(3);

                if (String.IsNullOrWhiteSpace(ExtraInfo))
                {
                    serverMessage21.AppendInt32(0);
                    serverMessage21.AppendInt32(0);
                    serverMessage21.AppendInt32(0);
                }
                else
                {
                    string[] boolz = ExtraInfo.Split(',');

                    foreach (string Stringy in boolz)
                    {
                        if (Stringy.ToLower() == "true")
                        {
                            serverMessage21.AppendInt32(1);
                        }
                        else
                        {
                            serverMessage21.AppendInt32(0);
                        }
                    }
                }
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                Session.SendMessage(serverMessage21);
                return;
            }


            case InteractionType.actionposreset:
            {
                ServerMessage serverMessage12 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage12.AppendBoolean(false);
                serverMessage12.AppendInt32(5);
                serverMessage12.AppendInt32(list.Count);
                foreach (RoomItem current12 in list)
                {
                    serverMessage12.AppendUInt(current12.Id);
                }
                serverMessage12.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage12.AppendUInt(Item.Id);
                serverMessage12.AppendString(ExtraString2);
                serverMessage12.AppendInt32(3);

                if (String.IsNullOrWhiteSpace(ExtraInfo))
                {
                    serverMessage12.AppendInt32(0);
                    serverMessage12.AppendInt32(0);
                    serverMessage12.AppendInt32(0);
                }
                else
                {
                    string[] boolz = ExtraInfo.Split(',');

                    foreach (string Stringy in boolz)
                    {
                        if (Stringy.ToLower() == "true")
                        {
                            serverMessage12.AppendInt32(1);
                        }
                        else
                        {
                            serverMessage12.AppendInt32(0);
                        }
                    }
                }
                serverMessage12.AppendInt32(0);
                serverMessage12.AppendInt32(3);
                serverMessage12.AppendInt32(i);                 // Delay
                serverMessage12.AppendInt32(0);
                Session.SendMessage(serverMessage12);
                return;
            }

            case InteractionType.actionmoverotate:
            {
                ServerMessage serverMessage13 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage13.AppendBoolean(false);
                serverMessage13.AppendInt32(5);
                serverMessage13.AppendInt32(list.Count);
                foreach (RoomItem current13 in list)
                {
                    serverMessage13.AppendUInt(current13.Id);
                }
                serverMessage13.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage13.AppendUInt(Item.Id);
                serverMessage13.AppendString(ExtraInfo);
                serverMessage13.AppendInt32(2);
                serverMessage13.AppendInt32(int.Parse(ExtraInfo.Split(new char[]
                    {
                        ';'
                    })[1]));
                serverMessage13.AppendInt32(int.Parse(ExtraInfo.Split(new char[]
                    {
                        ';'
                    })[0]));
                serverMessage13.AppendInt32(0);
                serverMessage13.AppendInt32(4);
                serverMessage13.AppendInt32(i);
                serverMessage13.AppendInt32(0);
                serverMessage13.AppendInt32(0);
                Session.SendMessage(serverMessage13);
                return;
            }

            case InteractionType.actionresettimer:
            {
                ServerMessage serverMessage14 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage14.AppendBoolean(false);
                serverMessage14.AppendInt32(5);
                serverMessage14.AppendInt32(list.Count);
                foreach (RoomItem current14 in list)
                {
                    serverMessage14.AppendUInt(current14.Id);
                }
                serverMessage14.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage14.AppendUInt(Item.Id);
                serverMessage14.AppendString(ExtraInfo);
                serverMessage14.AppendInt32(0);
                serverMessage14.AppendInt32(0);
                serverMessage14.AppendInt32(0);
                serverMessage14.AppendInt32(0);
                serverMessage14.AppendInt32(0);
                serverMessage14.AppendInt32(0);
                Session.SendMessage(serverMessage14);
                return;
            }

            case InteractionType.actionshowmessage:
            case InteractionType.actionkickuser:
            {
                ServerMessage serverMessage15 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage15.AppendBoolean(false);
                serverMessage15.AppendInt32(0);
                serverMessage15.AppendInt32(list.Count);
                foreach (RoomItem current15 in list)
                {
                    serverMessage15.AppendUInt(current15.Id);
                }
                serverMessage15.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage15.AppendUInt(Item.Id);
                serverMessage15.AppendString(ExtraInfo);
                serverMessage15.AppendInt32(0);
                serverMessage15.AppendInt32(0);
                serverMessage15.AppendInt32(7);
                serverMessage15.AppendInt32(0);
                serverMessage15.AppendInt32(0);
                serverMessage15.AppendInt32(0);
                Session.SendMessage(serverMessage15);
                return;
            }

            case InteractionType.actionteleportto:
            {
                ServerMessage serverMessage16 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage16.AppendBoolean(false);
                serverMessage16.AppendInt32(5);
                serverMessage16.AppendInt32(list.Count);
                foreach (RoomItem current16 in list)
                {
                    serverMessage16.AppendUInt(current16.Id);
                }
                serverMessage16.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage16.AppendUInt(Item.Id);
                serverMessage16.AppendString(ExtraInfo);
                serverMessage16.AppendInt32(0);
                serverMessage16.AppendInt32(8);
                serverMessage16.AppendInt32(0);
                serverMessage16.AppendInt32(i);
                serverMessage16.AppendInt32(0);
                serverMessage16.AppendByte(2);
                Session.SendMessage(serverMessage16);
                return;
            }

            case InteractionType.actiontogglestate:
            {
                ServerMessage serverMessage17 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage17.AppendBoolean(false);
                serverMessage17.AppendInt32(5);
                serverMessage17.AppendInt32(list.Count);
                foreach (RoomItem current17 in list)
                {
                    serverMessage17.AppendUInt(current17.Id);
                }
                serverMessage17.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage17.AppendUInt(Item.Id);
                serverMessage17.AppendString(ExtraInfo);
                serverMessage17.AppendInt32(0);
                serverMessage17.AppendInt32(8);
                serverMessage17.AppendInt32(0);
                serverMessage17.AppendInt32(i);
                serverMessage17.AppendInt32(0);
                serverMessage17.AppendInt32(0);
                Session.SendMessage(serverMessage17);
                return;
            }

            case InteractionType.actiongivereward:
            {
                ServerMessage serverMessage18 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage18.AppendBoolean(false);
                serverMessage18.AppendInt32(5);
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage18.AppendUInt(Item.Id);
                serverMessage18.AppendString(ExtraInfo);
                serverMessage18.AppendInt32(3);
                serverMessage18.AppendInt32((ExtraString == "") ? 0 : int.Parse(ExtraString));
                serverMessage18.AppendInt32(flag ? 1 : 0);
                serverMessage18.AppendInt32((ExtraString2 == "") ? 0 : int.Parse(ExtraString2));
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(17);
                serverMessage18.AppendInt32(0);
                serverMessage18.AppendInt32(0);
                Session.SendMessage(serverMessage18);
                return;
            }

            case InteractionType.conditionhowmanyusersinroom:
            case InteractionType.conditionnegativehowmanyusers:
            {
                ServerMessage serverMessage19 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage19.AppendBoolean(false);
                serverMessage19.AppendInt32(5);
                serverMessage19.AppendInt32(0);
                serverMessage19.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage19.AppendUInt(Item.Id);
                serverMessage19.AppendString("");
                serverMessage19.AppendInt32(2);
                if (String.IsNullOrWhiteSpace(ExtraInfo))
                {
                    serverMessage19.AppendInt32(1);
                    serverMessage19.AppendInt32(50);
                }
                else
                {
                    foreach (string Integers in ExtraInfo.Split(','))
                    {
                        serverMessage19.AppendInt32(int.Parse(Integers));
                    }
                }
                serverMessage19.AppendBoolean(false);
                serverMessage19.AppendInt32(0);
                serverMessage19.AppendInt32(1290);
                Session.SendMessage(serverMessage19);
                return;
            }

            case InteractionType.conditionfurnishaveusers:
            case InteractionType.conditionstatepos:
            case InteractionType.conditiontriggeronfurni:
            case InteractionType.conditionfurnihasfurni:
            case InteractionType.conditionfurnitypematches:
            case InteractionType.conditionfurnihasnotfurni:
            case InteractionType.conditionfurnishavenotusers:
            case InteractionType.conditionfurnitypedontmatch:
            case InteractionType.conditiontriggerernotonfurni:
            {
                ServerMessage serverMessage19 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage19.AppendBoolean(false);
                serverMessage19.AppendInt32(5);
                serverMessage19.AppendInt32(list.Count);
                foreach (RoomItem current18 in list)
                {
                    serverMessage19.AppendUInt(current18.Id);
                }
                serverMessage19.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage19.AppendUInt(Item.Id);
                serverMessage19.AppendInt32(0);
                serverMessage19.AppendInt32(0);
                serverMessage19.AppendInt32(0);
                serverMessage19.AppendBoolean(false);
                serverMessage19.AppendBoolean(true);
                Session.SendMessage(serverMessage19);
                return;
            }

            case InteractionType.conditiontimelessthan:
            case InteractionType.conditiontimemorethan:
            {
                ServerMessage serverMessage21 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage21.AppendBoolean(false);
                serverMessage21.AppendInt32(5);
                serverMessage21.AppendInt32(list.Count);
                foreach (RoomItem current20 in list)
                {
                    serverMessage21.AppendUInt(current20.Id);
                }
                serverMessage21.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage21.AppendUInt(Item.Id);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                Session.SendMessage(serverMessage21);
                return;
            }

            case InteractionType.conditionuserwearingeffect:
            case InteractionType.conditionusernotwearingeffect:
            {
                int effect = 0;
                int.TryParse(ExtraInfo, out effect);
                ServerMessage serverMessage21 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage21.AppendBoolean(false);
                serverMessage21.AppendInt32(5);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage21.AppendUInt(Item.Id);
                serverMessage21.AppendString("");
                serverMessage21.AppendInt32(1);
                serverMessage21.AppendInt32(effect);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(12);
                Session.SendMessage(serverMessage21);
                return;
            }

            case InteractionType.conditionuserwearingbadge:
            case InteractionType.conditionusernotwearingbadge:
            {
                ServerMessage serverMessage21 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage21.AppendBoolean(false);
                serverMessage21.AppendInt32(5);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage21.AppendUInt(Item.Id);
                serverMessage21.AppendString(ExtraInfo);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(11);
                Session.SendMessage(serverMessage21);
                return;
            }

            case InteractionType.conditiondaterangeactive:
            {
                int date1 = 0;
                int date2 = 0;

                try
                {
                    string[] strArray = ExtraInfo.Split(',');
                    date1 = int.Parse(strArray[0]);
                    date2 = int.Parse(strArray[1]);
                }
                catch { }

                ServerMessage serverMessage21 = new ServerMessage(Outgoing.WiredConditionMessageComposer);
                serverMessage21.AppendBoolean(false);
                serverMessage21.AppendInt32(5);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage21.AppendUInt(Item.Id);
                serverMessage21.AppendString(ExtraInfo);
                serverMessage21.AppendInt32(2);
                serverMessage21.AppendInt32(date1);
                serverMessage21.AppendInt32(date2);
                serverMessage21.AppendInt32(0);
                serverMessage21.AppendInt32(24);
                Session.SendMessage(serverMessage21);
                return;
            }



            case InteractionType.arrowplate:
            case InteractionType.pressurepad:
            case InteractionType.ringplate:
            case InteractionType.colortile:
            case InteractionType.colorwheel:
            case InteractionType.floorswitch1:
            case InteractionType.floorswitch2:
            case InteractionType.firegate:
            case InteractionType.glassfoor:
                break;

            case InteractionType.specialrandom:
            {
                ServerMessage serverMessage24 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage24.AppendBoolean(false);
                serverMessage24.AppendInt32(5);
                serverMessage24.AppendInt32(list.Count);
                foreach (RoomItem current23 in list)
                {
                    serverMessage24.AppendUInt(current23.Id);
                }
                serverMessage24.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage24.AppendUInt(Item.Id);
                serverMessage24.AppendString(ExtraInfo);
                serverMessage24.AppendInt32(0);
                serverMessage24.AppendInt32(8);
                serverMessage24.AppendInt32(0);
                serverMessage24.AppendInt32(0);
                serverMessage24.AppendInt32(0);
                serverMessage24.AppendInt32(0);
                Session.SendMessage(serverMessage24);
                return;
            }

            case InteractionType.specialunseen:
            {
                ServerMessage serverMessage25 = new ServerMessage(Outgoing.WiredEffectMessageComposer);
                serverMessage25.AppendBoolean(false);
                serverMessage25.AppendInt32(5);
                serverMessage25.AppendInt32(list.Count);
                foreach (RoomItem current24 in list)
                {
                    serverMessage25.AppendUInt(current24.Id);
                }
                serverMessage25.AppendInt32(Item.GetBaseItem().SpriteId);
                serverMessage25.AppendUInt(Item.Id);
                serverMessage25.AppendString(ExtraInfo);
                serverMessage25.AppendInt32(0);
                serverMessage25.AppendInt32(8);
                serverMessage25.AppendInt32(0);
                serverMessage25.AppendInt32(0);
                serverMessage25.AppendInt32(0);
                serverMessage25.AppendInt32(0);
                Session.SendMessage(serverMessage25);
                return;
            }

            default:
                return;
            }
        }
Example #23
0
        public static Team Objectify(string str)
        {
            var apiName = Stringy.SplitOn(str, "APIName")[0];

            return(Util.GetTeamByName(apiName));
        }