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;
}
