static private String ChooseArmName(PartClass partClass, float length, int damage) { const String ARM_NAME_LETTERS = "llleoid"; String name; name = ChooseFromLetters(ARM_NAME_LETTERS, 4); name += "-" + (int)partClass; if (length > 1.5) { name += "-LNG"; } else { name += "-SRT"; } if (damage > 15) { name += "^DTH"; } else { name += "^DLL"; } return(name); }
public Shoulders(String partName, PartClass partRank, float missleSize, int damage, int missleTexureNum) : base(partName, partRank) { this.missleSize = missleSize; this.damage = damage; this.missleTexureNum = missleTexureNum; }
static public Shoulders GetRandomShoulder(PartClass partClass) { String name; name = "Shoudler" + (int)partClass; return(new Shoulders(name, partClass, 1, 4, 0)); }
static private String ChooseHeadName(PartClass partClass, EnemyScanAbility enemyScanAbility, float missileInterceptionRate) { const String HEAD_NAME_LETTERS = "zbpquxd"; String name; name = ChooseFromLetters(HEAD_NAME_LETTERS, 8); name += "-" + (int)partClass; if (enemyScanAbility != EnemyScanAbility.None) { name += "XXSMT"; } else { name += "XXDMB"; } if (missileInterceptionRate > 0.5f) { name += "+FST"; } else { name += "+SLO"; } return(name); }
static private String ChooseLegName(PartClass partClass, float speed, MovementType move) { const String LEG_NAME_LETTERS = "lgsfsvvcx"; String name; name = ChooseFromLetters(LEG_NAME_LETTERS, 8); name += "-" + (int)partClass; if (speed > 2) { name += "(MTR)"; } else { name += "(MUD)"; } if (move.Water != MoveQuality.none) { name += "~FSH"; } if (move.Lava != MoveQuality.none) { name += "`HTT`"; } return(name); }
static private String ChooseArmName(PartClass partClass, int velo, int damage) { const String ARM_NAME_LETTERS = "rrruib"; String name; name = ChooseFromLetters(ARM_NAME_LETTERS, 4); name += "-" + (int)partClass; if (velo > 8) { name += "-MCH"; } else { name += "-PST"; } if (damage > 4) { name += "!BMB"; } else { name += "!PEA"; } return(name); }
public RightArm(String partName, PartClass partRank, float projectileSize, int velocity, float timeToFire, int damage, Texture2D bulletTexure) : base(partName, partRank) { this.projectileSize = projectileSize; this.damage = damage; this.bulletTexure = bulletTexure; this.velocity = velocity; this.timeToFire = timeToFire; }
static private float DecideSpeedTilesPerSecond(PartClass partClass) { float speedTilesPerSecond; speedTilesPerSecond = Rng.Next(0, (int)partClass); speedTilesPerSecond *= (float)Rng.NextDouble() / 2; speedTilesPerSecond = Math.Max(speedTilesPerSecond, 0.2f); return(speedTilesPerSecond); }
public async Task<ActionResult<PartClass>> Post([FromBody] PartClass entity) { if (!ModelState.IsValid) { return BadRequest(); } await _partClassRepository.Create(entity); await _unitOfWork.Save(); return Ok(entity); }
static public Head GenerateRandomHead(PartClass partClass) { string name; EnemyScanAbility enemyScanAbility; float missileInterceptionRate; enemyScanAbility = DecideScanAbility(partClass); missileInterceptionRate = DecideMissleInterceptRate(partClass); name = ChooseHeadName(partClass, enemyScanAbility, missileInterceptionRate); return(new Head(name, partClass, enemyScanAbility, missileInterceptionRate)); }
static public Legs GenerateRandomLegs(PartClass partClass) { String name; float speedTilesPerSecond; MovementType movement; speedTilesPerSecond = DecideSpeedTilesPerSecond(partClass); movement = DecideMoveType(partClass); name = ChooseLegName(partClass, speedTilesPerSecond, movement); return(new Legs(name, partClass, speedTilesPerSecond, movement)); }
public override IList <Entry> GetDataList(string searchString) { IList <Entry> list = new ObservableCollection <Entry>(); foreach (DataRow row in DataTable.Rows) { PartClass part = new PartClass(); part.OrderNumber = row[0].ToString(); part.Manufacturer = row[1].ToString(); part.Description = row[2].ToString(); list.Add(part); } return(list); }
static private EnemyScanAbility DecideScanAbility(PartClass partClass) { int scanNumber; scanNumber = 5; for (int k = 0; k < (int)partClass; k++) { scanNumber -= Rng.Next(0, 3); } scanNumber = Math.Min(scanNumber, 3); scanNumber = Math.Max(scanNumber, 0); return((EnemyScanAbility)scanNumber); }
static public Core GenerateRandomCore(PartClass partClass) { int classNum = (int)partClass; String name; int maxHp; bool resistLava; maxHp = DecideMaxHP(partClass); resistLava = DecideResistLava(partClass); name = ChooseCoreName(partClass, maxHp, resistLava); return(new Core("", partClass, maxHp, resistLava)); }
static public LeftArm GenerateLeftArm(PartClass partClass) { String name; float length; int damage; length = (float)(0.5f + Rng.NextDouble( ) / 2 * (int)partClass); damage = 10; name = ChooseArmName(partClass, length, damage); return(new LeftArm(name, partClass, length, damage)); }
public async Task<ActionResult<PartClass>> Put(int id, [FromBody] PartClass entity) { if (!ModelState.IsValid) { return BadRequest(); } var result = await _partClassRepository.UpdateById(id, entity); if (result == null) { return NotFound(); } await _unitOfWork.Save(); return Ok(result); }
static private String ChooseCoreName(PartClass partClass, int maxHp, bool resistLava) { const String CORE_NAME_LETTERS = "csuokjmxz"; String name; name = ChooseFromLetters(CORE_NAME_LETTERS, 8); name += "-" + (int)partClass; if (resistLava) { name += "H+"; } name += "-" + ChooseFromLetters(CORE_NAME_LETTERS, 3); return(name); }
static public RightArm GenerateRightArm(PartClass partClass) { String name; int velocity; float timeToFire; int damage; damage = 3 + (int)((int)partClass / 2.0 * Rng.Next(1, 6)); velocity = 4 + Rng.Next(1, 2 + (int)partClass); float size = 0.1f * damage * (float)Rng.NextDouble( ); size = Math.Max(0.2f, size); size = Math.Min(2, size); timeToFire = Rng.Next(500 - 50 * (int)partClass, 1000 - 100 * (int)partClass); name = ChooseArmName(partClass, velocity, damage); return(new RightArm(name, partClass, size, velocity, timeToFire, damage, bulletTextureList[0])); }
static private MovementType DecideMoveType(PartClass partClass) { MovementType movement = new MovementType( ); int classNum = (int)partClass; if (classNum > 2) { movement.Dirt = (MoveQuality)Rng.Next(1, (classNum + 1) / 2); movement.Grass = (MoveQuality)Rng.Next(1, (classNum + 1) / 2); movement.Sand = (MoveQuality)Rng.Next(0, (classNum + 1) / 2); movement.Water = (MoveQuality)Rng.Next(0, (classNum + 1) / 2); movement.Lava = (MoveQuality)Rng.Next(0, (classNum - 1) / 2); } else { movement.Dirt = (MoveQuality)Rng.Next(1, 3); movement.Grass = (MoveQuality)Rng.Next(1, 3); movement.Sand = (MoveQuality)Rng.Next(0, 2); movement.Water = (MoveQuality)Rng.Next(0, classNum); movement.Lava = MoveQuality.none; } return(movement); }
private Part DropPart() { Part newPart; int type = rng.Next(1, 6); PartClass partClass = GetLeveledClass( ); switch (type) { case 1: newPart = HeadGenerator.GenerateRandomHead(partClass); break; case 2: newPart = CoreGenerator.GenerateRandomCore(partClass); break; case 3: newPart = LeftArmGenerator.GenerateLeftArm(partClass); break; case 4: newPart = RightArmGenerator.GenerateRightArm(partClass); break; case 5: newPart = LegGenerator.GenerateRandomLegs(partClass); break; default: newPart = new Head("ERROR", PartClass.ClassFive, EnemyScanAbility.None, 0.0f); break; } return(newPart); }
private bool parse_test(ref ParsedRule parsed_rule, string part, bool negated) { string[] fragments_in = quoted_split(part); string[] fragments; // if "Not If" then shift fragments left List<string> fragment_list = new List<string>(); if (negated) { for (int i = 1; i < fragments_in.Length; i++) { fragment_list.Add(fragments_in[i]); } fragments = fragment_list.ToArray(); } else fragments = fragments_in; // OK we got to here with the fragments being "If", val1, condition, val2 if (fragments.Length < 4) { parse_error("Bad If condition", parsed_rule.unparsed_rule); return false; } int condition_index = 0; for (int i = 1; i < fragments.Length; i++) { if (fragments[i] == "=" || fragments[i] == "!=" || fragments[i] == "==" || fragments[i] == "<>" || fragments[i] == ">" || fragments[i] == "<" || fragments[i] == ">=" || fragments[i] == "=>" || fragments[i] == "<=" || fragments[i] == "=<" || fragments[i].ToLower() == "contains" || fragments[i].ToLower() == "word" ) { condition_index = i; break; } } if (condition_index == 0) { parse_error("If condition has bad comparison operator", parsed_rule.unparsed_rule); return false; } PartClass p = new PartClass(); p.part_type = PartEnum.Test; p.negated = negated; string condition_part = ""; for (int i = 1; i < condition_index; i++) { condition_part += fragments[i]; } p.string_list.Add(condition_part); p.string_list.Add(fragments[condition_index]); condition_part = ""; for (int i = condition_index + 1; i < fragments.Length; i++) { condition_part += fragments[i]; } p.string_list.Add(condition_part); p.has_count = has_a_count(p); parsed_rule.parts.Add(p); return true; }
private bool parse_teamsize(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length < (negated ? 3 : 2)) { parse_error("Teamsize", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Teamsize; c.negated = negated; try { c.int1 = Int32.Parse(fragments[negated ? 2 : 1]); } catch { parse_error("Teamsize", parsed_rule.unparsed_rule); return false; } parsed_rule.parts.Add(c); return true; }
private bool parse_teamcount(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length == (negated ? 3 : 2)) { PartClass p = new PartClass(); p.part_type = PartEnum.TeamCount; p.negated = negated; p.int1 = Int32.Parse(fragments[negated ? 2 : 1]); p.has_count = true; parsed_rule.parts.Add(p); return true; } parse_error("TeamCount", parsed_rule.unparsed_rule); return false; }
// a player name can be extracted from the say text (into %t%) private bool parse_targetplayer(ref ParsedRule parsed_rule, string part, bool negated) { PartClass c = new PartClass(); c.part_type = PartEnum.TargetPlayer; c.negated = negated; if (part.Length > 12) c.string_list.Add(part.Substring(13)); parsed_rule.parts.Add(c); return true; }
private bool parse_rate(ref ParsedRule parsed_rule, string[] fragments, bool negated) { PartClass p = new PartClass(); if (fragments.Length != (negated ? 4 : 3)) { parse_error("Rate", parsed_rule.unparsed_rule); return false; } try { p.part_type = PartEnum.Rate; p.negated = negated; p.int1 = Int32.Parse(fragments[negated ? 2 : 1]); p.int2 = Int32.Parse(fragments[negated ? 3 : 2]); } catch { parse_error("Rate", parsed_rule.unparsed_rule); return false; } parsed_rule.parts.Add(p); return true; }
// this player is on reserved slots list private bool parse_protected(ref ParsedRule parsed_rule, bool negated) { PartClass c = new PartClass(); c.part_type = PartEnum.Protected; c.negated = negated; parsed_rule.parts.Add(c); return true; }
private bool parse_mapmode(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length != (negated ? 3 : 2)) { parse_error("MapMode", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.MapMode; c.negated = negated; c.string_list = item_keys(fragments[negated ? 2 : 1]); parsed_rule.parts.Add(c); return true; }
//********************************************************************************************** //********************************************************************************************** // EXECUTE THE ACTIONS IN THE CURRENT RULE //********************************************************************************************** //********************************************************************************************** // execute the next action void take_action(string player_name, PartClass p, Dictionary<SubstEnum, string> keywords) { WriteDebugInfo(String.Format("ProconRulz: take_action[{0}] with action '{1}{2} {3}' by '{4}'", player_name, p.target_action ? "TargetAction " : "", Enum.GetName(typeof(PartEnum), p.part_type), p.string_list[0], keywords[SubstEnum.Player] ) ); // if current action is 'Continue' or 'End' then do nothing if (p.part_type == PartEnum.Continue || p.part_type == PartEnum.End) return; // if the current action was TargetAction, add to the players list and return if (p.target_action) { do_action(keywords[SubstEnum.Target], p, keywords); return; } // e.g. from a rule "On Say;Text Yes;TargetConfirm" -- // do nothing (obsolete action) if (p.part_type == PartEnum.TargetConfirm) { return; } if (p.part_type == PartEnum.PlayerBlock) { add_block(player_name, p.string_list[0]); return; } // if the action is a "Kill", then IMMEDIATELY clear this soldier out of the spawn counts // this will open up an opportunity for someone else to spawn with this players items if (p.part_type == PartEnum.Kill && reservationMode == ReserveItemEnum.Player_loses_item_when_dead && !protected_player(player_name)) { spawn_counts.zero_player(player_name); } do_action(player_name, p, keywords); }
// updated to allow '&' char in weapon key instead of a space // this is complicated by the fact that weapon keys can // INCLUDE SPACES (thankyou EA) eg "M1A1 Thompson" and heli weapons // Weapon AUG // Not Weapon AUG // Weapon AUG 3 // Not Weapon AUG 3 // Weapon M1A1 Thompson // Weapon M1A1 Thompson 3 // Not Weapon M1A1 Thompson // Not Weapon M1A1 Thompson 3 // multiple weapon keys can be separated with rulz_item_separator E.g. Weapon SMAW,RPG-7 private bool parse_weapon(ref ParsedRule parsed_rule, string[] fragments, bool negated) { //WriteConsole(String.Format("rule {0}", parsed_rule.unparsed_rule)); //WriteConsole(String.Format("length {0}, negated {1}", fragments.Length, negated)); //WriteConsole(String.Format("fragments {0}", String.Join("---",fragments))); if (fragments.Length < (negated ? 3 : 2)) { parse_error("Weapon", parsed_rule.unparsed_rule); return false; } // ok lets try and figure out what we've got in the rule List<string> weapon_keys = item_keys((negated ? fragments[2] : fragments[1])); // try and make a count out of the last fragment int weapon_count = -1; try { weapon_count = Int32.Parse(fragments[fragments.Length - 1]); } catch { } //WriteConsole(String.Format("weapon_count {0}", weapon_count)); PartClass c = new PartClass(); c.part_type = PartEnum.Weapon; c.negated = negated; if (weapon_count > -1) c.int1 = weapon_count; foreach (string weapon_key in weapon_keys) { if (!weaponDefines.Contains(weapon_key)) WriteConsole(String.Format("ProconRulz: ^1Warning, weapon {0} not found in Procon (but you can still use the key in ProconRulz)", weapon_key)); } c.string_list = weapon_keys; parsed_rule.parts.Add(c); spawn_counts.watch(c.string_list); //else { parse_error("Weapon", parsed_rule.unparsed_rule); return false; } return true; }
static private bool DecideResistLava(PartClass partClass) { double resistLavaChance = -0.4 + 0.2 * (int)partClass; return(Rng.NextDouble( ) < resistLavaChance); }
public Legs(String partName, PartClass partRank, float speedTilePerSecond, MovementType movement) : base(partName, partRank) { this.speedTilePerSecond = speedTilePerSecond; this.movement = movement; }
public Core(String partName, PartClass partRank, int maxHp, bool resistLava) : base(partName, partRank) { this.maxHp = maxHp; this.resistLava = resistLava; }
public LeftArm(String partName, PartClass partRank, float swordLength, int swordDamage) : base(partName, partRank) { this.swordLength = swordLength; this.swordDamage = swordDamage; }
// test for an item at SPAWN // not_test is added to do a "Not Kit Recon" type test private bool test_spawned_count(string team_id, PartClass c) { // e.g. "TeamKit Recon 2" => c.part_type = Kit, c.string1 = "Recon", c.int1 = 2 // check the item limit value int count = spawn_counts.count(c.string_list, team_id); WriteDebugInfo(String.Format("ProconRulz: Test spawn item count {0} versus limit {1}", count, c.int1)); if (count <= c.int1) return c.negated; return !c.negated; // i.e. spawn item above count, non-negated rule => return true }
private bool parse_map(ref ParsedRule parsed_rule, string part, bool negated) { if (part.Length < 5) { parse_error("Map", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Map; c.negated = negated; c.string_list = negated ? item_keys(part.Substring(8).ToLower()) : item_keys(part.Substring(4).ToLower()); parsed_rule.parts.Add(c); return true; }
static private int DecideMaxHP(PartClass partClass) { return((int)(Rng.Next(1, 10) / 2.0 * (int)partClass)); }
// parse a 'part' of a rule, e.g. "Damage SniperRifle" or "TargetAction Kill 300" // returns 'true' if parse succeeded private bool parse_part(ref ParsedRule parsed_rule, string part, bool target_action) { try { bool rule_fail = false; // flag used to skip rest of rule on a parse error bool parsed_int = false; // flag used to confirm a part format with optional int was parsed ok // create action to be added to parsed_rule if we need it PartClass new_action = new PartClass(); new_action.target_action = target_action; string[] fragments = quoted_split(part); // v40b update to allow quoted strings if (fragments == null || fragments.Length == 0) return true; switch (fragments[0].ToLower()) { // TRIGGER ("On Spawn" or "On Kill") case "on": // trigger the rule on Spawn or a Kill rule_fail = !parse_on(ref parsed_rule, fragments); break; // CONDITIONS: i.e. what is needed for this rule to fire case "headshot": // e.g. "Headshot" rule_fail = !parse_headshot(ref parsed_rule, false); break; case "protected": // e.g. "Protected" - this player is on reserved slots list rule_fail = !parse_protected(ref parsed_rule, false); break; case "admin": // e.g. "Admin" - this player is an admin rule_fail = !parse_admin(ref parsed_rule, false); break; case "admins": // e.g. "Admins" - admins are on the server rule_fail = !parse_admins(ref parsed_rule, false); break; case "team": // e.g. "Team Attack" or defend rule_fail = !parse_team(ref parsed_rule, fragments, false); break; case "ping": // e.g. "Ping 300" rule_fail = !parse_ping(ref parsed_rule, fragments, false); break; case "teamsize": // e.g. "Teamsize 8" this rule only applies to teams this small or smaller rule_fail = !parse_teamsize(ref parsed_rule, fragments, false); break; case "map": // e.g. "Map Oasis" this rule only applies to map oasis rule_fail = !parse_map(ref parsed_rule, part, false); break; case "mapmode": // e.g. "MapMode Rush" this rule only applies to maps in Rush mode rule_fail = !parse_mapmode(ref parsed_rule, fragments, false); break; case "kit": // e.g. "Kit Recon 2" - max 2 recons on the team rule_fail = !parse_kit(ref parsed_rule, fragments, false); break; case "weapon": // e.g. "Weapon AUG 3" rule_fail = !parse_weapon(ref parsed_rule, fragments, false); break; case "spec": // e.g. "Spec sp_vdamage 3" rule_fail = !parse_spec(ref parsed_rule, fragments, false); break; case "damage": // e.g. "Damage SniperRifle 8" rule_fail = !parse_damage(ref parsed_rule, fragments, false); break; case "teamkit": // e.g. "TeamKit Recon 2" - max 2 recons on the team rule_fail = !parse_teamkit(ref parsed_rule, fragments, false); break; case "teamweapon": // e.g. "TeamWeapon AUG 3" rule_fail = !parse_teamweapon(ref parsed_rule, fragments, false); break; case "teamspec": // e.g. "TeamSpec sp_vdamage 3" rule_fail = !parse_teamspec(ref parsed_rule, fragments, false); break; case "teamdamage": // e.g. "TeamDamage SniperRifle 8" rule_fail = !parse_teamdamage(ref parsed_rule, fragments, false); break; case "range": // e.g. "Range 100" rule_fail = !parse_range(ref parsed_rule, fragments, false); break; case "not": // e.g. "Not Damage SniperRifle" rule_fail = !parse_not(ref parsed_rule, fragments, part); break; case "count": // e.g. "Count 8" - how many times PLAYER can trigger this rule case "playercount": // e.g. "PlayerCount 8" - how many times PLAYER can trigger this rule rule_fail = !parse_count(ref parsed_rule, fragments, false); break; case "teamcount": // e.g. "TeamCount 8" - how many times TEAM can trigger this rule rule_fail = !parse_teamcount(ref parsed_rule, fragments, false); break; case "servercount": // e.g. "ServerCount 8" - how many times SERVER can trigger this rule rule_fail = !parse_servercount(ref parsed_rule, fragments, false); break; case "playerfirst": case "teamfirst": case "serverfirst": case "playeronce": rule_fail = !parse_first(ref parsed_rule, fragments[0].ToLower(), false); break; case "rate": // e.g. "Rate 5 20" this rule triggered 5 times in 20 seconds rule_fail = !parse_rate(ref parsed_rule, fragments, false); break; case "text": // e.g. "On Say;Text ofc;Yell OFc 4 Ever" rule_fail = !parse_text(ref parsed_rule, part, false); break; case "targetplayer": // e.g. "TargetPlayer" (extract playername from say text) rule_fail = !parse_targetplayer(ref parsed_rule, part, false); break; case "incr": // e.g. "Incr kill_count" rule_fail = !parse_incr(ref parsed_rule, fragments); break; case "decr": // e.g. "Decr kill_count" rule_fail = !parse_decr(ref parsed_rule, fragments); break; case "set": // e.g. "Set kill_count 0" rule_fail = !parse_set(ref parsed_rule, fragments); break; case "if": // e.g. "If kill_count > 7" rule_fail = !parse_test(ref parsed_rule, part, false); break; // ACTIONS i.e. what to do when conditions are true // ************************************************ case "say": // e.g. "Say No more Snipers!" if (part.Length < 5) { parse_error("Say", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.Say; new_action.string_list.Add(part.Substring(4)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "playersay": // e.g. "PlayerSay No more Snipers!" if (part.Length < 11) { parse_error("PlayerSay", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.PlayerSay; new_action.string_list.Add(part.Substring(10)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "squadsay": // e.g. "SquadSay No more Snipers!" if (part.Length < 10) { parse_error("SquadSay", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.SquadSay; new_action.string_list.Add(part.Substring(9)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "teamsay": // e.g. "TeamSay No more Snipers!" if (part.Length < 9) { parse_error("TeamSay", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.TeamSay; new_action.string_list.Add(part.Substring(8)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "victimsay": // e.g. "VictimSay You were killed by %p%, range %r%!" if (part.Length < 11) { parse_error("VictimSay", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.VictimSay; new_action.string_list.Add(part.Substring(10)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "adminsay": // e.g. "AdminSay HACKER WARNING on %p% (5 headshots in 15 seconds)!!" if (part.Length < 10) { parse_error("AdminSay", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.AdminSay; new_action.string_list.Add(part.Substring(9)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "yell": if (part.Length < 6) { parse_error("Yell", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.Yell; parsed_int = false; // assume parsing yell_delay fails try { new_action.int1 = Int32.Parse(fragments[1]); // try and pick up yell delay (seconds) new_action.string_list.Add(String.Join(" ", fragments, 2, fragments.Length-2 )); // rest of string parsed_int = true; } catch { } if (!parsed_int) // we didn't parse a yell delay so use default { new_action.int1 = yell_delay; new_action.string_list.Add(part.Substring(5)); } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "playeryell": // e.g. "PlayerYell No more Snipers!" if (part.Length < 12) { parse_error("PlayerYell", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.PlayerYell; parsed_int = false; // assume parsing yell_delay fails try { new_action.int1 = Int32.Parse(fragments[1]); // try and pick up yell delay (seconds) new_action.string_list.Add(String.Join(" ", fragments, 2, fragments.Length-2 )); // rest of string parsed_int = true; } catch { } if (!parsed_int) // we didn't parse a yell delay so use default { new_action.int1 = yell_delay; new_action.string_list.Add(part.Substring(11)); } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "squadyell": // e.g. "SquadYell No more Snipers!" if (part.Length < 11) { parse_error("SquadYell", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.SquadYell; parsed_int = false; // assume parsing yell_delay fails try { new_action.int1 = Int32.Parse(fragments[1]); // try and pick up yell delay (seconds) new_action.string_list.Add(String.Join(" ", fragments, 2, fragments.Length-2 )); // rest of string parsed_int = true; } catch { } if (!parsed_int) // we didn't parse a yell delay so use default { new_action.int1 = yell_delay; new_action.string_list.Add(part.Substring(10)); } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "teamyell": // e.g. "TeamYell No more Snipers!" if (part.Length < 10) { parse_error("TeamYell", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.TeamYell; parsed_int = false; // assume parsing yell_delay fails try { new_action.int1 = Int32.Parse(fragments[1]); // try and pick up yell delay (seconds) new_action.string_list.Add(String.Join(" ", fragments, 2, fragments.Length-2 )); // rest of string parsed_int = true; } catch { } if (!parsed_int) // we didn't parse a yell delay so use default { new_action.int1 = yell_delay; new_action.string_list.Add(part.Substring(9)); } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "log": if (part.Length < 5) { parse_error("Log", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.Log; new_action.string_list.Add(part.Substring(4)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "all": // say and yell and log if (part.Length < 5) { parse_error("All", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.All; new_action.string_list.Add(part.Substring(4)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "both": // say and yell if (part.Length < 6) { parse_error("Both", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.Both; new_action.string_list.Add(part.Substring(5)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "playerboth": // say and yell to a player if (part.Length < 12) { parse_error("PlayerBoth", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.PlayerBoth; new_action.string_list.Add(part.Substring(11)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "kill": // kill player that triggered this rule new_action.part_type = PartEnum.Kill; if (fragments.Length == 2) new_action.string_list.Add(fragments[1]); else new_action.string_list.Add(kill_delay.ToString()); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "kick": // kick player that triggered this rule new_action.part_type = PartEnum.Kick; if (fragments.Length >= 2) new_action.string_list.Add(part.Substring(5)); else new_action.string_list.Add("Kicked automatically"); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "ban": // ban player that triggered this rule new_action.part_type = PartEnum.Ban; if (fragments.Length >= 2) new_action.string_list.Add(part.Substring(4)); else new_action.string_list.Add("[%p%] Banned automatically"); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "tempban": // temp ban player that triggered this rule new_action.part_type = PartEnum.TempBan; // try and pick up number of seconds for ban from fragments[1] bool tempban_default = true; if (fragments.Length >= 2) try { new_action.int1 = Int32.Parse(fragments[1]); tempban_default = false; } catch { new_action.int1 = ban_delay; } else new_action.int1 = ban_delay; // now try and dig out message // "TempBan" or "TempBan 7777" if (fragments.Length == 1 || (!tempban_default && fragments.Length == 2)) { new_action.string_list.Add("[%p%] automatic temp ban"); } // TempBan <message> else if (tempban_default && fragments.Length >= 2) { new_action.string_list.Add(part.Substring(8)); } // TempBan <N> <message> else if (!tempban_default && fragments.Length > 2) { new_action.string_list.Add(part.Substring(8 + fragments[1].Length)); } else { parse_error("TempBan", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "pbban": // ban player that triggered this rule via PunkBuster new_action.part_type = PartEnum.PBBan; if (fragments.Length >= 2) new_action.string_list.Add(part.Substring(6)); else new_action.string_list.Add("[%p%] Banned automatically"); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "pbkick": // temp ban player that triggered this rule (i.e. kick with timeout via PunkBuster) new_action.part_type = PartEnum.PBKick; // try and pick up number of MINUTES for ban from fragments[1] bool pbkick_default = true; if (fragments.Length >= 2) try { new_action.int1 = Int32.Parse(fragments[1]); pbkick_default = false; } catch { new_action.int1 = 0; } // default is NO temp ban on PB kick else new_action.int1 = 0; // now try and dig out message // "PBKick" or "PBKick 77" if (fragments.Length == 1 || (!pbkick_default && fragments.Length == 2)) { new_action.string_list.Add("[%p%] automatic temp kick/ban"); } // PBKick <message> else if (pbkick_default && fragments.Length >= 2) { new_action.string_list.Add(part.Substring(7)); } // PBKick <N> <message> else if (!pbkick_default && fragments.Length > 2) { new_action.string_list.Add(part.Substring(7 + fragments[1].Length)); } else { parse_error("PBKick", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "playerblock": // block player name from using item new_action.part_type = PartEnum.PlayerBlock; if (fragments.Length == 2) new_action.string_list.Add(fragments[1]); // item key else new_action.string_list.Add("unknown"); parsed_rule.parts.Add(new_action); break; case "targetconfirm": // trigger previous TargetAction actions from this player if (fragments.Length != 1) parse_error("TargetConfirm", parsed_rule.unparsed_rule); new_action.part_type = PartEnum.TargetConfirm; new_action.string_list.Add(""); parsed_rule.parts.Add(new_action); break; case "targetcancel": // cancel previous TargetAction actions from this player if (fragments.Length != 1) parse_error("TargetCancel", parsed_rule.unparsed_rule); new_action.part_type = PartEnum.TargetCancel; new_action.string_list.Add(""); parsed_rule.parts.Add(new_action); break; case "targetaction": // store delayed actions on target from this player rule_fail = !parse_part(ref parsed_rule, part.Substring(13), true); break; case "exec": // e.g. "Exec levelVars.set level levels/mp_007gr vehiclesDisabled false" if (part.Length < 6) { parse_error("Execute", parsed_rule.unparsed_rule); rule_fail = true; break; } new_action.part_type = PartEnum.Execute; new_action.string_list.Add(part.Substring(5)); new_action.has_count = has_a_count(new_action); parsed_rule.parts.Add(new_action); break; case "continue": new_action.part_type = PartEnum.Continue; new_action.string_list.Add(""); parsed_rule.parts.Add(new_action); break; case "end": new_action.part_type = PartEnum.End; new_action.string_list.Add(""); parsed_rule.parts.Add(new_action); break; default: WriteConsole(String.Format("^1ProconRulz: Unrecognised rule {0}", parsed_rule.unparsed_rule)); rule_fail = true; break; } return !rule_fail; } catch (Exception ex) { WriteConsole(String.Format("^1ProconRulz: Exception occurred parsing your rules")); WriteConsole(String.Format("^1ProconRulz: Rule was \"{0}\"", parsed_rule.unparsed_rule)); WriteConsole(String.Format("^1ProconRulz: Part that failed was \"{0}\"", part)); PrintException(ex); return false; } }
// execute the action (kill in a separate thread which can sleep if necessary) void do_action(string target, PartClass a, Dictionary<SubstEnum, string> keywords) { //object[] parameters = (object[])state; //string target = (string)parameters[0]; //PartClass a = (PartClass)parameters[1]; //Dictionary<SubstEnum, string> keywords = (Dictionary<SubstEnum,string>)parameters[2]; // replace all the %p% etc with player name etc string message = replace_keys(a.string_list[0], keywords); message = rulz_vars.replace_vars(target, message); WriteDebugInfo(String.Format("ProconRulz: Doing action '{0} {1}' on {2}", Enum.GetName(typeof(PartEnum), a.part_type), message, target )); switch (a.part_type) { case PartEnum.Say: ExecuteCommand("procon.protected.send", "admin.say", message, "all"); ExecuteCommand("procon.protected.chat.write", message); break; case PartEnum.PlayerSay: ExecuteCommand("procon.protected.send", "admin.say", message, "player", target); ExecuteCommand("procon.protected.chat.write", String.Format("(PlayerSay {0}) ", target) + message); break; case PartEnum.TeamSay: if (!keywords.ContainsKey(SubstEnum.PlayerTeamKey)) break; // skip if we don't know player team ExecuteCommand("procon.protected.send", "admin.say", message, "team", keywords[SubstEnum.PlayerTeamKey]); ExecuteCommand("procon.protected.chat.write", String.Format("(TeamSay[{0}] {1}) ", keywords[SubstEnum.PlayerTeam], target) + message); break; case PartEnum.SquadSay: if (!keywords.ContainsKey(SubstEnum.PlayerTeamKey)) break; // skip if we don't know player team if (!keywords.ContainsKey(SubstEnum.PlayerSquadKey)) break; // skip if we don't know player squad ExecuteCommand("procon.protected.send", "admin.say", message, "squad", keywords[SubstEnum.PlayerTeamKey], keywords[SubstEnum.PlayerSquadKey]); ExecuteCommand("procon.protected.chat.write", String.Format("(SquadSay[{0},{1}] {2}) ", keywords[SubstEnum.PlayerTeam], keywords[SubstEnum.PlayerSquad], target) + message); break; case PartEnum.VictimSay: string victim_name = ""; try { victim_name = keywords[SubstEnum.Victim]; } catch { } if (victim_name != "") { ExecuteCommand("procon.protected.send", "admin.say", message, "player", victim_name); ExecuteCommand("procon.protected.chat.write", String.Format("(VictimSay {0}) ", victim_name) + message); } break; case PartEnum.AdminSay: ExecuteCommand("procon.protected.chat.write", "(AdminSay) " + message); if (!admins_present()) break; foreach (string player_name in players.list_players()) if (is_admin(player_name)) ExecuteCommand("procon.protected.send", "admin.say", message, "player", player_name); break; case PartEnum.Yell: ExecuteCommand("procon.protected.send", "admin.yell", message, a.int1.ToString(), "all"); ExecuteCommand("procon.protected.chat.write", message); break; case PartEnum.PlayerYell: ExecuteCommand("procon.protected.send", "admin.yell", message, a.int1.ToString(), "player", target); ExecuteCommand("procon.protected.chat.write", String.Format("(PlayerYell {0}) ", target) + message); break; case PartEnum.TeamYell: if (!keywords.ContainsKey(SubstEnum.PlayerTeamKey)) break; // skip if we don't know player team ExecuteCommand("procon.protected.send", "admin.yell", message, a.int1.ToString(), "team", keywords[SubstEnum.PlayerTeamKey]); ExecuteCommand("procon.protected.chat.write", String.Format("(TeamYell[{0}] {1}) ", keywords[SubstEnum.PlayerTeam], target) + message); break; case PartEnum.SquadYell: if (!keywords.ContainsKey(SubstEnum.PlayerTeamKey)) break; // skip if we don't know player team if (!keywords.ContainsKey(SubstEnum.PlayerSquadKey)) break; // skip if we don't know player squad ExecuteCommand("procon.protected.send", "admin.yell", message, a.int1.ToString(), "squad", keywords[SubstEnum.PlayerTeamKey], keywords[SubstEnum.PlayerSquadKey]); ExecuteCommand("procon.protected.chat.write", String.Format("(SquadYell[{0},{1}] {2}) ", keywords[SubstEnum.PlayerTeam], keywords[SubstEnum.PlayerSquad], target) + message); break; case PartEnum.Both: ExecuteCommand("procon.protected.send", "admin.say", message, "all"); ExecuteCommand("procon.protected.send", "admin.yell", message, yell_delay.ToString(), "all"); ExecuteCommand("procon.protected.chat.write", message); break; case PartEnum.PlayerBoth: ExecuteCommand("procon.protected.send", "admin.say", message, "player", target); ExecuteCommand("procon.protected.send", "admin.yell", message, yell_delay.ToString(), "player", target); ExecuteCommand("procon.protected.chat.write", String.Format("(PlayerBoth {0}) ", target) + message); break; case PartEnum.Log: WriteLog(String.Format("ProconRulz: {0}", message)); break; case PartEnum.All: ExecuteCommand("procon.protected.send", "admin.say", message, "all"); ExecuteCommand("procon.protected.send", "admin.yell", message, yell_delay.ToString(), "all"); WriteLog(String.Format("ProconRulz: {0}", message)); break; case PartEnum.Kill: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from Kill by ProconRulz", target)); break; } do_kill(target, Int32.Parse(message)); break; case PartEnum.Kick: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from Kick by ProconRulz", target)); break; } //Thread.Sleep(kill_delay); ExecuteCommand("procon.protected.send", "admin.kickPlayer", target, message); WriteLog(String.Format("ProconRulz: Player {0} kicked", target)); break; case PartEnum.Ban: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from Ban by ProconRulz", target)); break; } try { ExecuteCommand("procon.protected.send", "banList.add", "guid", player_info[target].GUID, "perm", message); } catch { try { ExecuteCommand("procon.protected.send", "banList.add", "name", target, "perm", message); } catch { WriteLog(String.Format("ProconRulz: exception when banning {0}", target)); } } //Thread.Sleep(10000); // sleep for 10 seconds ExecuteCommand("procon.protected.send", "banList.save"); //Thread.Sleep(10000); // sleep for 10 seconds ExecuteCommand("procon.protected.send", "banList.list"); WriteLog(String.Format("ProconRulz: Player {0} banned", target)); break; case PartEnum.TempBan: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from TempBan by ProconRulz", target)); break; } try { ExecuteCommand("procon.protected.send", "banList.add", "guid", player_info[target].GUID, "seconds", a.int1.ToString(), message); } catch { try { ExecuteCommand("procon.protected.send", "banList.add", "name", target, "seconds", a.int1.ToString(), message); } catch { WriteLog(String.Format("ProconRulz: exception when TempBanning {0}", target)); } } //Thread.Sleep(10000); // sleep for 10 seconds ExecuteCommand("procon.protected.send", "banList.save"); //Thread.Sleep(10000); // sleep for 10 seconds ExecuteCommand("procon.protected.send", "banList.list"); WriteLog(String.Format("ProconRulz: Player {0} temp banned for {1} seconds", target, a.int1.ToString())); break; case PartEnum.PBBan: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from PBBan by ProconRulz", target)); break; } string guid = players.pb_guid(target); if (guid == null || guid == "") // no PB guid so try ban using name ExecuteCommand("procon.protected.send", "punkBuster.pb_sv_command", String.Format("pb_sv_ban \"{0}\" \"{1}\"", target, message ) ); else // we have a PB guid ExecuteCommand("procon.protected.send", "punkBuster.pb_sv_command", String.Format("pb_sv_banguid \"{0}\" \"{1}\" \"{2}\" \"{3}\"", guid, target, players.ip(target), message ) ); ExecuteCommand("procon.protected.send", "punkBuster.pb_sv_command", "pb_sv_updbanfile"); WriteLog(String.Format("ProconRulz: Player {0} banned via Punkbuster", target)); break; case PartEnum.PBKick: if (protected_player(target)) { WriteLog(String.Format("ProconRulz: Player {0} protected from PBKick by ProconRulz", target)); break; } ExecuteCommand("procon.protected.send", "punkBuster.pb_sv_command", String.Format("pb_sv_kick \"{0}\" {1} \"{2}\"", target, a.int1.ToString(), message ) ); ExecuteCommand("procon.protected.send", "punkBuster.pb_sv_command", "pb_sv_updbanfile"); WriteLog(String.Format("ProconRulz: Player {0} kick/temp banned via Punkbuster for {1} minutes", target, a.int1.ToString())); break; case PartEnum.Execute: // We need to make a string array out of 'procon.protected.send' // and the action message // Note that we delay the %% substitutions until we have 'split' // the message in case we have spaces in subst values List<string> parms_list = new List<string>(); // v39b.1 modification - Use command directly if it begins 'procon.' if (a.string_list != null && a.string_list.Count != 0 && !(a.string_list[0].ToLower().StartsWith("procon."))) { parms_list.Add("procon.protected.send"); } // if this is a punkbuster command then concatenate pb command into a single string // e.g. pb_sv_getss "bambam" if (a.string_list != null && a.string_list.Count != 0 && a.string_list[0].ToLower().StartsWith("punkbuster.pb_sv_command")) { parms_list.Add("punkBuster.pb_sv_command"); parms_list.Add(rulz_vars.replace_vars(target, replace_keys(a.string_list[0].Substring(25).TrimStart(), keywords))); } else // for non-punkbuster commands each param is its own string... { WriteDebugInfo(String.Format("ProconRulz: do_action Exec <{0}>", a.string_list[0])); foreach (string element in quoted_split(a.string_list[0])) // updated v40a.1 for quoted strings { // we 'replace_keys' for each fragment parms_list.Add(rulz_vars.replace_vars(target, replace_keys(element, keywords))); WriteDebugInfo(String.Format("ProconRulz: do_action Exec added element <{0}> <{1}>", element, rulz_vars.replace_vars(target, replace_keys(element, keywords))) ); } } ExecuteCommand(parms_list.ToArray()); WriteLog(String.Format("ProconRulz: Executed command [{0}]", String.Join(",",parms_list.ToArray()))); break; default: WriteConsole(String.Format("ProconRulz: action thread error {0}", Enum.GetName(typeof(PartEnum), a.part_type))); break; } }
// range of the kill private bool parse_range(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length == (negated ? 3 : 2)) { PartClass c = new PartClass(); c.part_type = PartEnum.Range; c.negated = negated; c.int1 = Int32.Parse(fragments[negated ? 2 : 1]); parsed_rule.parts.Add(c); return true; } parse_error("Range", parsed_rule.unparsed_rule); return false; }
// return true if this part refers to a Count bool has_a_count(PartClass p) { if (p.part_type == PartEnum.PlayerCount || p.part_type == PartEnum.TeamCount || p.part_type == PartEnum.ServerCount) return true; foreach (string s in p.string_list) { foreach (string k in subst_keys[SubstEnum.Count]) { if (s.Contains(k)) return true; } foreach (string k in subst_keys[SubstEnum.TeamCount]) { if (s.Contains(k)) return true; } foreach (string k in subst_keys[SubstEnum.ServerCount]) { if (s.Contains(k)) return true; } } return false; }
private bool parse_set(ref ParsedRule parsed_rule, string[] fragments) { if (fragments.Length < 3) { parse_error("Set", parsed_rule.unparsed_rule); return false; } PartClass p = new PartClass(); p.part_type = PartEnum.Set; p.negated = false; p.string_list.Add(fragments[1]); // string_list[0] = var_name string value = ""; for (int i = 2; i < fragments.Length; i++) value += fragments[i]; p.string_list.Add(value); //string_list[1] = value to assign p.has_count = has_a_count(p); parsed_rule.parts.Add(p); return true; }
private bool parse_damage(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length < (negated ? 3 : 2)) { parse_error("Damage", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Damage; c.negated = negated; if (fragments.Length == (negated ? 4 : 3)) try { c.int1 = Int32.Parse(fragments[negated ? 3 : 2]); } catch { parse_error("Damage", parsed_rule.unparsed_rule); return false; } try { c.string_list = item_keys(fragments[negated ? 2 : 1]); foreach (string damage_key in c.string_list) { try { DamageTypes d = (DamageTypes)Enum.Parse(typeof(DamageTypes), damage_key, true); } catch (ArgumentException) { WriteConsole(String.Format("ProconRulz: ^1Warning, damage {0} not found in Procon (but you can still use the key in ProconRulz)", damage_key)); } } parsed_rule.parts.Add(c); spawn_counts.watch(c.string_list); } catch { parse_error("Damage", parsed_rule.unparsed_rule); return false; } return true; }
private bool parse_team(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length < (negated ? 3 : 2)) { parse_error("Team", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Team; c.negated = negated; c.string_list = item_keys(fragments[negated ? 2 : 1].ToLower()); parsed_rule.parts.Add(c); return true; }
// Here we translate some convenience conditions into actual equivalents: // PlayerFirst -> Not PlayerCount 1 (i.e. player count is not > 1, i.e. count MUST be 1) // TeamFirst -> Not TeamCount 1 // ServerFirst -> Not ServerCount 1 // PlayerOnce -> Not Rate 2 100000 (tricky to explain... rule has NOT fired twice in 100000 seconds, // which is only true the FIRST time the rule fires for this player // because the time period is long enough that the second time it fires // will be inside the 100000 second window so the condition will fail // the second (and later) time. // This rule takes advantage of the fact that RATES continue across // new round starts. Rates reset for a player on a new round when they are // NOT online. Told you it was tricky). private bool parse_first(ref ParsedRule parsed_rule, string condition, bool negated) { PartClass p = new PartClass(); p.int1 = 1; // 1 for 'first's, will change to 2 for PlayerOnce... p.negated = !negated; // i.e. "Not PlayerFirst" -> "PlayerCount 1", i.e. the Not inverts switch (condition) { case "playerfirst": p.part_type = PartEnum.PlayerCount; break; case "teamfirst": p.part_type = PartEnum.TeamCount; break; case "serverfirst": p.part_type = PartEnum.ServerCount; break; case "playeronce": p.part_type = PartEnum.Rate; p.int1 = 2; // is 1 for the above conditions, change to 2 here p.int2 = 100000; // period for Rate set to 100000 seconds i.e. about a day break; } p.has_count = true; parsed_rule.parts.Add(p); return true; }
// count of spawned Kits on team private bool parse_teamkit(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length != (negated ? 4 : 3)) { parse_error("TeamKit", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.TeamKit; c.negated = negated; try { c.int1 = Int32.Parse(fragments[negated ? 3 : 2]); c.string_list = item_keys(fragments[negated ? 2 : 1]); foreach (string kit_key in c.string_list) { try { Kits k = (Kits)Enum.Parse(typeof(Kits), kit_key, true); } catch (ArgumentException) { WriteConsole(String.Format("ProconRulz: ^1Warning, kit {0} not found in Procon (but you can still use the key in ProconRulz)", kit_key)); } } parsed_rule.parts.Add(c); spawn_counts.watch(c.string_list); } catch { parse_error("TeamKit", parsed_rule.unparsed_rule); return false; } return true; }
private bool parse_headshot(ref ParsedRule parsed_rule, bool negated) { PartClass c = new PartClass(); c.part_type = PartEnum.Headshot; c.negated = negated; parsed_rule.parts.Add(c); return true; }
// count of spawned specializations on team private bool parse_teamspec(ref ParsedRule parsed_rule, string[] fragments, bool negated) { if (fragments.Length != (negated ? 4 : 3)) { parse_error("TeamSpec", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.TeamSpec; c.negated = negated; c.int1 = Int32.Parse(fragments[negated ? 3 : 2]); List<string> spec_keys = item_keys(fragments[negated ? 2 : 1]); foreach (string spec_key in spec_keys) { if (!specDefines.Contains(spec_key)) WriteConsole(String.Format("ProconRulz: ^1Warning, Specialization {0} not found in Procon (but you can still use the key in ProconRulz)", spec_key)); } c.string_list = spec_keys; parsed_rule.parts.Add(c); spawn_counts.watch(c.string_list); return true; }
// RULZ VARIABLE INCR, DECR, SET and TEST conditions private bool parse_incr(ref ParsedRule parsed_rule, string[] fragments) { if (fragments.Length != 2) { parse_error("Incr", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Incr; c.negated = false; c.string_list.Add(fragments[1].ToLower()); parsed_rule.parts.Add(c); return true; }
private bool parse_text(ref ParsedRule parsed_rule, string part, bool negated) { if (part.Length < 6) { parse_error("Text", parsed_rule.unparsed_rule); return false; } PartClass c = new PartClass(); c.part_type = PartEnum.Text; c.negated = negated; c.string_list = new List<string>(part.Substring(negated ? 9 : 5).ToLower().Split(new char[] { rulz_item_separator }, StringSplitOptions.RemoveEmptyEntries)); parsed_rule.parts.Add(c); return true; }
static private float DecideMissleInterceptRate(PartClass partClass) { return((float)Rng.NextDouble( ) / (5 - (int)partClass)); }
// check a condition (e.g. "Kit Recon 2") in the current rule // rule.trigger is already confirmed to be the current event (e.g. Kill, Spawn) private bool process_part(ParsedRule rule, PartClass p, string player_name, Kill k, string msg, ref Dictionary<SubstEnum, string> keywords) { // CATCH EXCEPTIONS try { string not = p.negated ? "Not " : ""; bool return_val = false; string player_team_id = "-1"; if (keywords.ContainsKey(SubstEnum.PlayerTeamKey)) { player_team_id = keywords[SubstEnum.PlayerTeamKey]; } switch (p.part_type) { case PartEnum.Headshot: // test "Headshot" return_val = p.negated ? !k.Headshot : k.Headshot; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Headshot {2}", player_name, not, return_val)); return return_val; case PartEnum.Protected: // test player os on reserved slots list return_val = p.negated ? !protected_player(player_name) : protected_player(player_name); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Protected {2}", player_name, not, return_val)); return return_val; case PartEnum.Admin: // test player is an admin return_val = p.negated ? !is_admin(player_name) : is_admin(player_name); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Admin {2}", player_name, not, return_val)); return return_val; case PartEnum.Admins: // test if any admins are currently online return_val = p.negated ? !admins_present() : admins_present(); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Admins {2}", player_name, not, return_val)); return return_val; case PartEnum.Team: // test "team attack|defend" bool team_matches = team_match(p.string_list, player_team_id); return_val = p.negated ? !team_matches : team_matches; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Actual team {2} versus {3} {4}", player_name, not, team_key(player_team_id), keys_join(p.string_list), return_val)); return return_val; case PartEnum.Ping: // test "Ping N" int current_ping = players.ping(player_name); return_val = p.negated ? current_ping < p.int1 : current_ping >= p.int1; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Ping {2} versus limit {3} {4}", player_name, not, current_ping, p.int1, return_val)); return return_val; case PartEnum.Teamsize: // test "Teamsize N" int min_teamsize = players.min_teamsize(); return_val = p.negated ? min_teamsize > p.int1 : min_teamsize <= p.int1; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Teamsize {2} versus limit {3} {4}", player_name, not, min_teamsize, p.int1, return_val)); return return_val; case PartEnum.Map: // test map name or filename contains string1 return_val = p.negated ? !map_match(p.string_list) : map_match(p.string_list); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Actual map {2} versus {3} {4}", player_name, not, current_map.PublicLevelName + " or " + current_map.FileName, keys_join(p.string_list), return_val)); return return_val; case PartEnum.MapMode: // test "mapmode rush|conquest" return_val = p.negated ? !mapmode_match(p.string_list) : mapmode_match(p.string_list); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}Actual MapMode {2} versus {3} {4}", player_name, not, current_map_mode, keys_join(p.string_list), return_val)); return return_val; case PartEnum.Kit: case PartEnum.Weapon: case PartEnum.Spec: case PartEnum.Damage: // test "Kit Recon 2" etc if (rule.trigger == TriggerEnum.Spawn) // will check *player* item as well as team count (spawn) return test_spawn_item(player_team_id, player_name, p); else // will also test kill item for TeamKill and Suicide return test_kill_item(k, p); case PartEnum.TeamKit: case PartEnum.TeamWeapon: case PartEnum.TeamSpec: case PartEnum.TeamDamage: return test_spawned_count(player_team_id, p); case PartEnum.Range: // test "Range > int1" return_val = p.negated ? !(k.Distance < p.int1) : k.Distance > p.int1; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}range {2} > limit {3} {4}", player_name, not, k.Distance, p.int1, return_val)); return return_val; case PartEnum.Count: case PartEnum.PlayerCount: // check how many times PLAYER has triggered this rule int current_count = count_rule(player_name, rule.id); bool count_valid = current_count > p.int1; return_val = p.negated ? !count_valid : count_valid; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}PlayerCount {2} (actual {3}) {4}", player_name, not, p.int1, current_count, return_val)); return return_val; case PartEnum.TeamCount: // check how many times PLAYER'S TEAM has triggered this rule int current_team_count = count_team_rule(players.team_id(player_name), rule.id); bool count_team_valid = current_team_count > p.int1; return_val = p.negated ? !count_team_valid : count_team_valid; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}TeamCount {2} (actual {3}) {4}", player_name, not, p.int1, current_team_count, return_val)); return return_val; case PartEnum.ServerCount: // check how many times ALL PLAYERS have triggered this rule int current_server_count = count_server_rule(rule.id); bool count_server_valid = current_server_count > p.int1; return_val = p.negated ? !count_server_valid : count_server_valid; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}ServerCount {2} (Actual {3}) {4}", player_name, not, p.int1, current_server_count, return_val)); return return_val; case PartEnum.Rate: // check condition "Rate X Y" i.e. X hits on this rule in Y seconds add_rate(player_name, rule.id); bool rate_valid = check_rate(player_name, rule.id, p.int1, p.int2); return p.negated ? !rate_valid : rate_valid; case PartEnum.Text: // check say text condition e.g. "Text ofc 4 ever,teamwork is everything" int index = -1; foreach (string t in p.string_list) { index = msg.ToLower().IndexOf(t.ToLower()); if (index >= 0 && keywords[SubstEnum.Text] != null && keywords[SubstEnum.Text].Length >= t.Length + 2) { // set up TargetText for TargetPlayer keywords[SubstEnum.TargetText] = keywords[SubstEnum.Text].Substring(index + t.Length).Trim(); } if (index >= 0) break; } return_val = p.negated ? index == -1 : index != -1; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}text {2} {3}", player_name, not, keys_join(p.string_list), return_val)); return return_val; case PartEnum.TargetPlayer: // check TargetPlayer condition, i.e. can we extract a playername from the say text // updated from v33 for find_players to return a LIST of player names // if only ONE playername matches, then automatically add TargetConfirm to action list... WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] checking TargetPlayer[{1}]", player_name, keywords[SubstEnum.Text])); List<string> player_names = new List<string>(); if (p.string_list != null && p.string_list.Count != 0) { // here the 'targettext' is specified in the rule e.g. "TargetPlayer bambam" player_names = find_players(rulz_vars.replace_vars(player_name, replace_keys(p.string_list[0], keywords))); } // note only 1 playername is allowed in condition else // because it could contain rulz_item_separator { // here the targettext from a previous "Text" condition will be used // if successful, we will modify TargetText to be AFTER the playername match string string[] t_words = null; if (keywords.ContainsKey(SubstEnum.TargetText)) { t_words = quoted_split(keywords[SubstEnum.TargetText]); } if (t_words != null && t_words.Length > 0) { player_names = find_players(t_words[0]); if (keywords[SubstEnum.TargetText].Length - t_words[0].Length > 1) { keywords[SubstEnum.TargetText] = keywords[SubstEnum.TargetText].Substring(t_words[0].Length + 1); } else { keywords[SubstEnum.TargetText] = ""; } } } return_val = p.negated ? player_names.Count == 0 : player_names.Count == 1; keywords[SubstEnum.Target] = player_names.Count == 0 ? "" : player_names[0]; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1}TargetPlayer {2} {3} with {4}", player_name, not, keys_join(p.string_list), return_val, String.Join(",", player_names.ToArray()))); return return_val; case PartEnum.Set: // set rulz variable rulz_vars.set_value(player_name, p.string_list[0], p.string_list[1], keywords); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] Set {1} {2}", player_name, keys_join(p.string_list), true)); return true; // set always succeeds case PartEnum.Incr: rulz_vars.incr(player_name, p.string_list[0], keywords); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] Increment {1} {2}", player_name, p.string_list[0], true)); return true; // Incr always succeeds case PartEnum.Decr: rulz_vars.decr(player_name, p.string_list[0], keywords); WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] Decrement {1} {2}", player_name, p.string_list[0], true)); return true; // Decr always succeeds case PartEnum.Test: // aka If // test var1 compare var2 (c.string_list[0..2]) WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] IF %c% is [{1}]", player_name, keywords[SubstEnum.Count])); return_val = rulz_vars.test(player_name, p.string_list[0], p.string_list[1], p.string_list[2], keywords); if (p.negated) return_val = !return_val; WriteDebugInfo(String.Format("ProconRulz: check_condition [{0}] {1} IF {2} {3}", player_name, not, keys_join(p.string_list), return_val)); return return_val; default: take_action(player_name, p, keywords); return true; } } catch (Exception ex) { WriteConsole("ProconRulz: recoverable exception in process_part (ProconRulz will continue...)"); WriteConsole("ProconRulz: process_part rule.unparsed_rule = " + ((rule == null) ? "(rule=null)" : (rule.unparsed_rule == null ? "(null)" : "[" + rule.unparsed_rule + "]") ) ); WriteConsole("ProconRulz: process_part player_name = " + ((player_name == null) ? "(null)" :"[" + player_name + "]")); WriteConsole("ProconRulz: process_part p.part_type = " + ((p == null) ? "(p=null)" : (p.part_type == null ? "(null)" : p.part_type.ToString()) ) ); WriteConsole("ProconRulz: process_part k.Killer.SoldierName = " + ((k == null) ? "(k=null)" : ((k.Killer == null) ? "(k.Killer=null)" : ((k.Killer.SoldierName==null) ? "(null)" : ("["+k.Killer.SoldierName+"]")) ) ) ); PrintException(ex); return false; } }
public JsonResult GetSomeData(string subject = "Access", string depart = "生态学院", string Class = "环境生态15", string year = "20", string time = "1") { User u = (User)Session["User"]; Score[] sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score >= 90).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score >= 90).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score >= 90).ToArray(); } List <PartClass> partList = new List <PartClass>(); //90分以上的 PartClass p1 = new PartClass(); p1.name = "grade90"; p1.stu_num = sList.Length; p1.stu_id = new string[p1.stu_num]; p1.stu_name = new string[p1.stu_num]; for (int i = 0; i < sList.Length; i++) { p1.stu_id[i] = sList[i].stu_id; p1.stu_name[i] = sList[i].stu_name; } partList.Add(p1); // sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 90 && s.score >= 80).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 90 && s.score >= 80).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 90 && s.score >= 80).ToArray(); } PartClass p2 = new PartClass(); p2.name = "grade80"; p2.stu_num = sList.Length; p2.stu_id = new string[p2.stu_num]; p2.stu_name = new string[p2.stu_num]; for (int i = 0; i < sList.Length; i++) { p2.stu_id[i] = sList[i].stu_id; p2.stu_name[i] = sList[i].stu_name; } partList.Add(p2); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 80 && s.score >= 70).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 80 && s.score >= 70).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 80 && s.score >= 70).ToArray(); } PartClass p3 = new PartClass(); p3.name = "grade70"; p3.stu_num = sList.Length; p3.stu_id = new string[p3.stu_num]; p3.stu_name = new string[p3.stu_num]; for (int i = 0; i < sList.Length; i++) { p3.stu_id[i] = sList[i].stu_id; p3.stu_name[i] = sList[i].stu_name; } partList.Add(p3); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 70 && s.score >= 60).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 70 && s.score >= 60).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 70 && s.score >= 60).ToArray(); } PartClass p4 = new PartClass(); p4.name = "grade60"; p4.stu_num = sList.Length; p4.stu_id = new string[p4.stu_num]; p4.stu_name = new string[p4.stu_num]; for (int i = 0; i < sList.Length; i++) { p4.stu_id[i] = sList[i].stu_id; p4.stu_name[i] = sList[i].stu_name; } partList.Add(p4); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 60 && s.score >= 50).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 60 && s.score >= 50).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 60 && s.score >= 50).ToArray(); } PartClass p5 = new PartClass(); p5.name = "grade50"; p5.stu_num = sList.Length; p5.stu_id = new string[p5.stu_num]; p5.stu_name = new string[p5.stu_num]; for (int i = 0; i < sList.Length; i++) { p5.stu_id[i] = sList[i].stu_id; p5.stu_name[i] = sList[i].stu_name; } partList.Add(p5); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 50 && s.score >= 40).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 50 && s.score >= 40).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 50 && s.score >= 40).ToArray(); } PartClass p6 = new PartClass(); p6.name = "grade40"; p6.stu_num = sList.Length; p6.stu_id = new string[p6.stu_num]; p6.stu_name = new string[p6.stu_num]; for (int i = 0; i < sList.Length; i++) { p6.stu_id[i] = sList[i].stu_id; p6.stu_name[i] = sList[i].stu_name; } partList.Add(p6); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 40 && s.score >= 30).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 40 && s.score >= 30).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 40 && s.score >= 30).ToArray(); } PartClass p7 = new PartClass(); p7.name = "grade30"; p7.stu_num = sList.Length; p7.stu_id = new string[p7.stu_num]; p7.stu_name = new string[p7.stu_num]; for (int i = 0; i < sList.Length; i++) { p7.stu_id[i] = sList[i].stu_id; p7.stu_name[i] = sList[i].stu_name; } partList.Add(p7); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 30 && s.score >= 20).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 30 && s.score >= 20).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 30 && s.score >= 20).ToArray(); } PartClass p8 = new PartClass(); p8.name = "grade20"; p8.stu_num = sList.Length; p8.stu_id = new string[p8.stu_num]; p8.stu_name = new string[p8.stu_num]; for (int i = 0; i < sList.Length; i++) { p8.stu_id[i] = sList[i].stu_id; p8.stu_name[i] = sList[i].stu_name; } partList.Add(p8); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 20 && s.score >= 10).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 20 && s.score >= 10).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 20 && s.score >= 10).ToArray(); } PartClass p9 = new PartClass(); p9.name = "grade10"; p9.stu_num = sList.Length; p9.stu_id = new string[p9.stu_num]; p9.stu_name = new string[p9.stu_num]; for (int i = 0; i < sList.Length; i++) { p9.stu_id[i] = sList[i].stu_id; p9.stu_name[i] = sList[i].stu_name; } partList.Add(p9); sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 10).ToArray(); if (u.user_kind == "haed") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 10).ToArray(); } if (u.user_kind == "teacher") { sList = sc.ScoreList.Where(s => s.subject == subject && s.stu_class == Class && u.user_subject == subject && u.user_class.Contains(Class) && s.updatetime.StartsWith(year) && s.uploadtime == time && s.score < 10).ToArray(); } PartClass p10 = new PartClass(); p10.name = "grade0"; p10.stu_num = sList.Length; p10.stu_id = new string[p10.stu_num]; p10.stu_name = new string[p10.stu_num]; for (int i = 0; i < sList.Length; i++) { p10.stu_id[i] = sList[i].stu_id; p10.stu_name[i] = sList[i].stu_name; } partList.Add(p10); return(Json(partList)); }
// test for an item on a KILL private bool test_kill_item(Kill k, PartClass c) { try { if (k == null) return false; string weapon_key = k.DamageType; if (weapon_key == "") weapon_key = null; Weapon weapon_used; try { if (weapon_key == null) weapon_used = null; else weapon_used = weaponDefines[weapon_key]; } catch { weapon_used = null; } string weapon_descr = weapon_desc(weapon_key); string weapon_kit; try { if (weapon_used == null) weapon_kit = "No weapon kit"; else weapon_kit = item_key(weapon_used.KitRestriction); } catch { weapon_kit = "No weapon kit"; } string damage; try { damage = item_key(weapon_used.Damage); } catch { damage = "No damage key"; } switch (c.part_type) { case PartEnum.Weapon: WriteDebugInfo(String.Format("ProconRulz: Test kill item [WEAPON {0}]", keys_join(c.string_list))); if (weapon_key == null) return c.negated; if (keys_match(weapon_key, c.string_list)) { WriteDebugInfo(String.Format("ProconRulz: Test kill item [WEAPON {0}] found", weapon_key)); break; } // not found, so return false unless c.negated return c.negated; case PartEnum.Damage: WriteDebugInfo(String.Format("ProconRulz: Test kill item [DAMAGE {0}]", keys_join(c.string_list))); if (keys_match(damage, c.string_list)) { WriteDebugInfo(String.Format("ProconRulz: Test kill item [DAMAGE {0}] found", damage)); break; } return c.negated; case PartEnum.Kit: WriteDebugInfo(String.Format("ProconRulz: Test kill item [KIT {0}]", keys_join(c.string_list))); string test_kit = weapon_kit; // either use the kit type of the weapon, or the kit the player spawned with if (player_kit.ContainsKey(k.Killer.SoldierName)) test_kit = player_kit[k.Killer.SoldierName]; if (keys_match(test_kit, c.string_list)) { WriteDebugInfo(String.Format("ProconRulz: Test kill item [KIT {0}] found", test_kit)); break; } return c.negated; default: // item type can be None WriteDebugInfo(String.Format("ProconRulz: Test kill item [ignored] OK")); return true; } // end switch on item type bool success; if (c.int1 == 0) { success = true; if (c.negated) success = !success; WriteDebugInfo(String.Format("ProconRulz: Test kill item {0}", success)); // The item is being counted, and the count is above the limit in the rule return success; } // check the item_limit value WriteDebugInfo(String.Format("ProconRulz: Test kill item [{0}] has {1}({2}) versus rule limit {3}", k.Killer.SoldierName, keys_join(c.string_list), count_kill_items(k.Killer.SoldierName, c.string_list), c.int1)); success = count_kill_items(k.Killer.SoldierName, c.string_list) > c.int1; if (c.negated) success = !success; return success; } catch (Exception ex) { WriteConsole("ProconRulz: recoverable exception in test_kill_item"); PrintException(ex); return false; } }
public Head(String partName, PartClass partRank, EnemyScanAbility enemyScanAbility, float missileInterceptionRate) : base(partName, partRank) { this.missileInterceptionRate = missileInterceptionRate; this.enemyScanAbility = enemyScanAbility; }
// test for an item at SPAWN // not_test is added to do a "Not Kit Recon" type test private bool test_spawn_item(string team_id, string player_name, PartClass c) { // e.g. "Kit Recon 2" => c.part_type = Kit, c.string1 = "Recon", c.int1 = 2 bool found = spawn_counts.has_item(c.string_list, player_name); WriteDebugInfo(String.Format("ProconRulz: Test spawn item [KIT {0}] {1}", keys_join(c.string_list), found ? "Found" : "Not Found")); // if we have NOT found the item then return FALSE for a regular condition, // or TRUE for a 'Not' condition: if (!found) return c.negated; // item found // if no count specified in condition then we can return now // (success for normal rule, failure for 'Not' rule) if (c.int1 == 0) return !c.negated; // proceed to check item count return test_spawned_count(team_id, c); }
public Part(String partName, PartClass partRank) { this.partName = partName; this.partRank = partRank; }