public void PaintTopInGame(ClipState clipState)
{
if (Hud.Render.UiHidden) return;
if (clipState != ClipState.BeforeClip) return;
RuleCalculator.CalculatePaintInfo(Hud.Game.Me);
if (RuleCalculator.PaintInfoList.Count == 0) return;
var x = Hud.Window.Size.Width * 0.5f + Hud.Window.Size.Height * PositionOffsetX - RuleCalculator.StandardIconSize / 2;
var h = Hud.Window.Size.Height * PositionOffsetH;
BuffPainter.PaintVerticalCenter(RuleCalculator.PaintInfoList, x, 0, h, RuleCalculator.StandardIconSize, RuleCalculator.StandardIconSpacing);
}
private void Verify(Db.Rule.Compare op
, String left
, String right
, bool expected
)
{
var msg = new System.Text.StringBuilder();
try
{
var rule = new Db.Rule(-1 // not in db, so no id
, -1 // not in db, so no step
, "variable name irrelevant for RC.Applies()"
, op
, left
, TestUtil.RANDOM.Next() // order also irrelvant for this test
, Step.NO_NEXT_STEP
);
msg.Append("Rule with operator ");
msg.Append(op);
msg.Append(" [");
msg.Append(left);
msg.Append("] vs [");
msg.Append(right);
msg.Append("] we expect to evaulate to ");
msg.Append(expected);
bool result = RuleCalculator.Applies(rule, right);
if (result != expected)
{
Console.WriteLine(msg);
}
Assert.That(result == expected, msg.ToString());
}
catch (Exception ex)
{
Console.WriteLine(msg);
Console.WriteLine("but it threw: " + ex);
throw;
}
}
public void PaintTopInGame(ClipState clipState)
{
if (Hud.Render.UiHidden)
{
return;
}
if (clipState != ClipState.BeforeClip)
{
return;
}
RuleCalculator.CalculatePaintInfo(Hud.Game.Me);
if (RuleCalculator.PaintInfoList.Count == 0)
{
return;
}
var y = Hud.Window.Size.Height * 0.5f + Hud.Window.Size.Height * PositionOffset;
BuffPainter.PaintHorizontalCenter(RuleCalculator.PaintInfoList, 0, y, Hud.Window.Size.Width, RuleCalculator.StandardIconSize, RuleCalculator.StandardIconSpacing);
}
/// <summary>
/// يک نمونه از کلاس "محاسبه گر قانون" برمي گرداند. اين نمونه براي تمامي
/// فراخواني هاي تابع يکسان است و تنها خصوصيات آن با مقادير ورودي
/// مقداردهي مي گردند
/// همچنین اگر تاریخ روزی که در حال محاسبه آن هستیم با محدوده تاریخی که قانون در آن تعریف شده است انطباق نداشته
/// باشد با برگرداندن "تهی" قانون نباید اجرا شود
/// </summary>
private void GetRuleCalculator(IEngineEnvironment engineEnvironment,
ref RuleCalculator RuleCalc,
Person person,
DateTime calculationDate,
AssignedRule categorisedRule,
DateRange calcDateZone)
{
///اگر تاریخی که در حال محاسبه ی آن هستیم از محدوده ی تعریف شده ی قانون برای شخص خارج شده قانون را اجرا نمیکنیم
if (calculationDate >= categorisedRule.FromDate &&
calculationDate <= categorisedRule.ToDate)
{
if (RuleCalc != null)
{
//RuleCalc.Person = person;
RuleCalc.AssignedRule = categorisedRule;
if (!RuleCalc.RuleCalculateDate.Equals(calculationDate))
{
RuleCalc.RuleCalculateDate = calculationDate;
RuleCalc.ConceptCalculateDate = calculationDate;
}
}
else
{
engineEnvironment.Person = person;
engineEnvironment.AssignedRule = categorisedRule;
engineEnvironment.ConceptCalculateDate = calculationDate;
engineEnvironment.RuleCalculateDate = calculationDate;
engineEnvironment.CalcDateZone = calcDateZone;
RuleCalc = new RuleCalculator(engineEnvironment);
}
}
else
{
RuleCalc = null;
}
}
public void RuleCalculatorTest()
{
var calculator = new RuleCalculator(_pictureRepository);
var ad = new AdVO {
Typology = "FLAT", Description = "Descripcion de prue", Pictures = new List <int> {
1
}, HouseSize = 100
};
var score = calculator.CalculateScore(ad);
Assert.True(score == 55);
var ad1 = new AdVO {
Typology = "FLAT", Description = "Descripcion de prueba", Pictures = new List <int> {
1
}, HouseSize = 100
};
Assert.True(calculator.CalculateScore(ad1) == 65);
var ad2 = new AdVO {
Typology = "FLAT", Description = "Descripcion de prueba céntrico siendo luminoso y nuevo pero no reformado en el ático del garaje", Pictures = new List <int> {
1
}, HouseSize = 100
};
Assert.True(calculator.CalculateScore(ad2) == 110);
var ad3 = new AdVO {
Typology = "FLAT", Description = "Descripcion de prueba céntrico siendo luminoso y nuevo pero no reformado en el ático del garaje", HouseSize = 100
};
score = calculator.CalculateScore(ad3);
Assert.True(score == 50);
}
public void PaintTopInGame(ClipState clipState)
{
if (clipState != ClipState.BeforeClip)
{
return;
}
if (HideWhenUiIsHidden && Hud.Render.UiHidden)
{
return;
}
try
{
if (Hud.Game.IsInTown || Hud.Game.Me.IsDead || IsGuardianDead)
{
if (TimerStarted)
{
aTimer.Enabled = false;
bTimer.Enabled = false;
CountTimer.Enabled = false;
TimerStarted = false;
Alarm = true;
}
return;
}
var player = Hud.Game.Me;
var buff = player.Powers.GetBuff(430674); //CoE Buff
if ((buff == null) || (buff.IconCounts[0] <= 0))
{
return;
}
var classSpecificRules = GetCurrentRules(player.HeroClassDefinition.HeroClass);
RuleCalculator.CalculatePaintInfo(player, classSpecificRules);
if (RuleCalculator.PaintInfoList.Count == 0)
{
return;
}
if (!RuleCalculator.PaintInfoList.Any(info => info.TimeLeft > 0))
{
return;
}
var highestElementalBonus = player.Offense.HighestElementalDamageBonus;
for (var i = 0; i < RuleCalculator.PaintInfoList.Count; i++) // RuleCalculator.PaintInfoList.Count = 4
{
var info = RuleCalculator.PaintInfoList[0];
if (info.TimeLeft <= 0)
{
RuleCalculator.PaintInfoList.RemoveAt(0);
RuleCalculator.PaintInfoList.Add(info);
}
else
{
break;
}
}
for (var orderIndex = 0; orderIndex < RuleCalculator.PaintInfoList.Count; orderIndex++)
{
var info = RuleCalculator.PaintInfoList[orderIndex];
var best = false;
switch (info.Rule.IconIndex)
{
case 1:
best = player.Offense.BonusToArcane == highestElementalBonus;
break;
case 2:
best = player.Offense.BonusToCold == highestElementalBonus;
break;
case 3:
best = player.Offense.BonusToFire == highestElementalBonus;
break;
case 4:
best = player.Offense.BonusToHoly == highestElementalBonus;
break;
case 5:
best = player.Offense.BonusToLightning == highestElementalBonus;
break;
case 6:
best = player.Offense.BonusToPhysical == highestElementalBonus;
break;
case 7:
best = player.Offense.BonusToPoison == highestElementalBonus;
break;
}
if (best && orderIndex > 0)
{
info.TimeLeft = (orderIndex - 1) * 4 + RuleCalculator.PaintInfoList[0].TimeLeft;
}
else
{
info.TimeLeftNumbersOverride = false;
}
if ((info.TimeLeft == TimeLeftBeforeAttack) && Alarm && best)
{
TimerStarted = true;
if (orderIndex == 0)
{
AlarmCount = 0;
CoEAttack_Action();
}
else if (orderIndex == 1)
{
// Timer Start
aTimer = new System.Timers.Timer();
aTimer.Elapsed += CoEReady;
aTimer.AutoReset = true;
aTimer.Enabled = true;
switch (Hud.Game.Me.HeroClassDefinition.HeroClass)
{
case HeroClass.Monk:
aTimer.Interval = 20000; // 5 elements *4 secs
break;
case HeroClass.Necromancer:
aTimer.Interval = 12000; // 3 elements
break;
case HeroClass.WitchDoctor:
case HeroClass.Wizard:
case HeroClass.Crusader:
case HeroClass.Barbarian:
case HeroClass.DemonHunter:
aTimer.Interval = 16000; // 4 elements
break;
}
// timer End
CoEReady_Action();
Alarm = false;
}
}
}
}
catch { }
}
/// <summary>
/// این تابع به عنوان تابع مجری برای نخ ها استفاده می شود.
/// برای ارسال پارمتر به این تابع حتما باید از کلاس "کمک کننده" استفاده شود
/// </summary>
/// <param name="state">حاوی "پرسنلی" است که محاسبات برای آن باید انجام شود</param>
public void Execute(decimal ExecutablePrsCalcId, decimal PersonId, DateTime FromDate, DateTime ToDate)
{
RuleCalculator RuleCalc = null;
Stopwatch MainStopWatch = new Stopwatch();
Stopwatch RuleStopWatch = new Stopwatch();
MainStopWatch.Start();
Person prs = Person.GetPersonRepository(false).GetById(PersonId, false);
IRuleRepository ruleRep = Rule.GetRuleRepository(false);
if (prs.Active)
{
try
{
DateRange CalcDateZone = null;
//در اينجا "تراکنش" نيازي نيست تنها به دليل اينکه در بازيابي داده ها
//اتصال" مدام باز و بسته نشود از "تراکنش" استفاده شده است"
using (NHibernateSessionManager.Instance.BeginTransactionOn(FlushMode.Never))
{
this.DateOfBeginYear = Utility.GetDateOfBeginYear(FromDate, BLanguage.CurrentSystemLanguage);
this.DateOfEndYear = Utility.GetDateOfEndYear(FromDate, BLanguage.CurrentSystemLanguage);
CalcDateZone = prs.InitializeForExecuteRule(FromDate, ToDate, this.DateOfBeginYear, this.DateOfEndYear);
IList <AssignedRuleParameter> ruleParameterList = ruleRep.GetAssginedRuleParamList(FromDate, ToDate);
var ruleUserDefinedList = ruleRep.GetRuleUserDefined();
foreach (DateTime dt in CalcDateZone)
{
#region Execute person's rules
foreach (AssignedRule AsgRule in prs.AssignedRuleList)
{
AsgRule.RuleParameterList = ruleParameterList;
this.GetRuleCalculator(this.engineEnvironment, ref RuleCalc, prs, dt, AsgRule, CalcDateZone);
if (RuleCalc != null)
{
try
{
if (ruleDurationDebug)
{
RuleStopWatch.Reset();
RuleStopWatch.Start();
}
if (ruleUserDefinedList.Any(x => x.IdentifierCode.Equals(AsgRule.IdentifierCode)))
{
try
{
string ruleName = "R" + AsgRule.IdentifierCode.ToString(CultureInfo.InvariantCulture);
//DesignedCalculator.DesignedRuleCalculator a = new DesignedCalculator.DesignedRuleCalculator();
Assembly asm = typeof(DesignedRuleCalculator).Assembly;
Type type = typeof(RuleCalculator);
MethodInfo info = type.GetExtensionMethod(asm, ruleName);
if (info != null)
{
info.Invoke(RuleCalc, new object[] { RuleCalc, AsgRule });
}
else
{
throw new BaseException(String.Format("قانون شماره {0} در فايل اسمبلي کاربر يافت نشد", AsgRule.IdentifierCode), "ExecuteRule.UserDefiendRule");
}
}
catch (ExecuteRuleException ex)
{
gtsRuleLogger.Error(prs.PersonCode, "UserDefiend ExecuteRule: " + ex.StackTrace, ex);
gtsRuleLogger.Flush();
//توسط صلواتي در خطا بايد محاسبات خاتمه پيدا کند
throw;
}
}
else
{
try
{
RuleCalc.ExecuteRule();
}
catch (ExecuteRuleException ex)
{
gtsRuleLogger.Error(prs.PersonCode, "ExecuteRule: " + ex.StackTrace, ex);
gtsRuleLogger.Flush();
//توسط صلواتي در خطا بايد محاسبات خاتمه پيدا کند
throw;
}
}
if (ruleDurationDebug)
{
gtsRuleLogger.Info(prs.BarCode, String.Format("Rule:R{0}, Duration:{1}, Date:{2}", RuleCalc.AssignedRule.IdentifierCode, RuleStopWatch.Elapsed.ToString(), dt));
}
}
catch (BaseException ex)
{
if (ex.InnerException != null && ex.InnerException is BaseException && ((BaseException)ex.InnerException).InsertedLog)
{
ex.InsertedLog = true;
}
BaseException.GetLog(gtsRuleLogger, prs.PersonCode, ex);
//gtsRuleLogger.Error(prs.PersonCode, "ExecuteRule: " + ex.StackTrace, ex);
//gtsRuleLogger.Flush();
throw;
}
finally
{
RuleCalc.Dispose();
}
}
}
#endregion
}
NHibernateSessionManager.Instance.CommitTransactionOn();
}
using (NHibernateSessionManager.Instance.BeginTransactionOn(FlushMode.Auto))
{
try
{
mut.WaitOne();
IPersonRepository PrsRepository = Person.GetPersonRepository(false);
PrsRepository.DeleteScndCnpValue(prs.ID, CalcDateZone.FromDate, CalcDateZone.ToDate);
prs.ScndCnpValueList.DoInsert(NHibernateSessionManager.Instance.GetSession().Connection, NHibernateSessionManager.Instance.GetTransaction().GetDbTransaction);
PrsRepository.RunSQL(prs.ScndCnpValueList.UpdateQuery);
UpdateExecutablePersonCalculation(ExecutablePrsCalcId, PersonId, ToDate);
//throw new Exception("اين خطا براي تست عقب گرد تراکنش ايجاد شده است");
NHibernateSessionManager.Instance.CommitTransactionOn();
}
catch (Exception ex)
{
try
{
BaseException.GetLog(gtsRuleLogger, prs.BarCode, ex, "Rollback -- ExecuteRule(Insert Results): " + ex.StackTrace);
//gtsRuleLogger.Error(prs.PersonCode, "Rollback -- ExecuteRule(Insert Results): " + ex.StackTrace, ex);
//gtsRuleLogger.Flush();
NHibernateSessionManager.Instance.RollbackTransactionOn();
}
catch (Exception except)
{
BaseException.GetLog(gtsRuleLogger, prs.BarCode, except, ex.StackTrace);
//gtsRuleLogger.Error(prs.BarCode, except.StackTrace, except);
//gtsRuleLogger.Flush();
}
throw;
}
finally
{
mut.ReleaseMutex();
}
}
}
catch (Exception ex)
{
BaseException.GetLog(gtsRuleLogger, prs.BarCode, ex);
//gtsRuleLogger.Error(prs.BarCode, ex.StackTrace, ex);
//gtsRuleLogger.Flush();
throw;
}
}
MainStopWatch.Stop();
gtsRuleLogger.Info(prs.BarCode, String.Format("Person {0} Duration : {1}", prs.BarCode, MainStopWatch.Elapsed.ToString()));
gtsRuleLogger.Flush();
}
