private void InitializeAlgorithm()
{
BaseAlgorithmInputValues inputValues;
switch (SelectedAlgorithm)
{
case KindOfAlgorithm.CheckAllSolution:
_algorithm = new CheckAllSolutionsAlgorithm(_individualLength, ClusteredDataObjects);
break;
case KindOfAlgorithm.Genetic:
inputValues = PrepareGeneticInputValues();
_algorithm = new GeneticAlgorithm(_individualLength, ClusteredDataObjects, inputValues);
break;
case KindOfAlgorithm.TabuSearch:
inputValues = PrepareTabuSearchInputValues();
_algorithm = new TabuSearchAlgorithm(_individualLength, ClusteredDataObjects, inputValues);
break;
case KindOfAlgorithm.BeesColony:
inputValues = PrepareBeesColonyInputValues();
_algorithm = new BeesColonyAlgorithm(_individualLength, ClusteredDataObjects, inputValues);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void CalcBlendPctByFunc(BaseAlgorithm.EViewTargetBlendFunction inIndirectViewSightFunc, float inIndirectViewSightExp, float DurationPct, out float BlendPct)
{
BlendPct = 0f;
switch (inIndirectViewSightFunc)
{
case BaseAlgorithm.EViewTargetBlendFunction.VTBlend_Linear:
BlendPct = BaseAlgorithm.Lerp(0f, 1f, DurationPct);
break;
case BaseAlgorithm.EViewTargetBlendFunction.VTBlend_Cubic:
BlendPct = BaseAlgorithm.CubicInterp(0f, 0f, 1f, 0f, DurationPct);
break;
case BaseAlgorithm.EViewTargetBlendFunction.VTBlend_EaseIn:
BlendPct = BaseAlgorithm.FInterpEaseIn(0f, 1f, DurationPct, inIndirectViewSightExp);
break;
case BaseAlgorithm.EViewTargetBlendFunction.VTBlend_EaseOut:
BlendPct = BaseAlgorithm.FInterpEaseOut(0f, 1f, DurationPct, inIndirectViewSightExp);
break;
case BaseAlgorithm.EViewTargetBlendFunction.VTBlend_EaseInOut:
BlendPct = BaseAlgorithm.FInterpEaseInOut(0f, 1f, DurationPct, inIndirectViewSightExp);
break;
}
}
public Maze(Point coords, Point size, Point startCoords, int tunnelWidth, int wallWidth, int algorithmID, int variant, Func <Point, bool> PeekFunc, Func <Rect, bool> NukeFunc)
{
mazeData = new MazeData(coords, size, startCoords, tunnelWidth, wallWidth, variant);
if (allAlgorithms.Count == 0)
{
allAlgorithms.Add(GrowingTree.name, new GrowingTree(PeekFunc, NukeFunc));
allAlgorithms.Add(Braid.name, new Braid(PeekFunc, NukeFunc));
allAlgorithms.Add(GTBraided.name, new GTBraided(PeekFunc, NukeFunc));
}
switch (algorithmID)
{
case 2:
this.mazeAlgorithm = new Braid(PeekFunc, NukeFunc);
break;
case 1:
this.mazeAlgorithm = new GTBraided(PeekFunc, NukeFunc);
break;
default:
this.mazeAlgorithm = new GrowingTree(PeekFunc, NukeFunc);
break;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------
private void onNextPlayer(Object aSender, Move aLastMove = null)
{
Colors winner = Colors.NO_COLOR;
Boolean isCheckmateOrDraw = isGameOver(ref winner);
if (isCheckmateOrDraw)
{
gameOver(this, winner);
return;
}
if (mIsBoardEnabled)
{
mIsBoardEnabled = false;
setIsEnable(this, mIsBoardEnabled);
}
BaseAlgorithm currentAlgorithm = (mCurrentColor == mPlayer1Color ? mPlayer1Algorithm : mPlayer2Algorithm);
if (!currentAlgorithm.isActive) // Human
{
mIsBoardEnabled = true;
setIsEnable(this, mIsBoardEnabled);
}
else // Algorithm
{
currentAlgorithm.refreshTree(chessBoard, whiteFigures, blackFigures, aLastMove);
Move lastMove = currentAlgorithm.move(chessBoard, whiteFigures, blackFigures);
refreshBlackWhiteFigures(lastMove);
mFigureToMove = lastMove.itemFrom;
moveFigureTo(lastMove.itemTo);
}
}
private void DisplayInfoFromSort(BaseAlgorithm <int> sort)
{
SortDatarichTextBox.Text = $"Time: {sort.Time};";
SortDatarichTextBox.Text += $"\nCount: { sort.Items.Count};";
SortDatarichTextBox.Text += $"\nSwapCount: { sort.SwapCount};";
SortDatarichTextBox.Text += $"\nCompareCount: { sort.CompareCount};";
if (IsBig)
{
ChangeValuesAfterSort(sort.Items);
}
}
public void BaseSortTest()
{
//arrange
var baseSort = new BaseAlgorithm <int>(dataList, "Base");
//act
baseSort.Sort();
//assert
for (int i = 0; i < count; i++)
{
Assert.AreEqual(sortedItems[i], baseSort.Items[i]);
}
}
public static float FInterpEaseInOut(float A, float B, float Alpha, float Exp)
{
float alpha;
if (Alpha < 0.5f)
{
alpha = 0.5f * Mathf.Pow(2f * Alpha, Exp);
}
else
{
alpha = 1f - 0.5f * Mathf.Pow(2f * (1f - Alpha), Exp);
}
return(BaseAlgorithm.Lerp(A, B, alpha));
}
public APosterioriAlgorithm(BaseAlgorithm <TObservation, TState> baseAlgorithm) : base(baseAlgorithm)
{
c = new double[T];
alpha = new Dictionary <TState, double[]>();
foreach (var state in StateSpace)
{
alpha[state] = new double[T];
}
beta = new Dictionary <TState, double[]>();
foreach (var state in StateSpace)
{
beta[state] = new double[T];
}
}
private void BtnClick(BaseAlgorithm <SortedItem> algorithm)
{
RefreshItems();
for (int i = 0; i < algorithm.Items.Count; i++)
{
algorithm.Items[i].SetPosition(i);
}
panel2.Refresh();
algorithm.CompareEvent += AlgorithmCompareEvent;
algorithm.SwopEvent += AlgorithmSwopEvent;
algorithm.SetEvent += AlgorithmSetEvent;
var time = algorithm.Sort();
TimeLbl.Text = "Lead time: " + time.Seconds;
SwopLbl.Text = "Number of exchanges: " + algorithm.SwopCount;
CompareLbl.Text = "Number of comparisons: " + algorithm.CompareCount;
}
public IMidSurface Run(ISolverData solverdata)
{
IMidSurface midsurface = new MidSurface();
maxLengthModel = FindMaxLength(solverdata.GetContours(), 0.01);
BaseAlgorithm baseAlgorithm = new BaseAlgorithm();
List <IMSPoint> msPoints = baseAlgorithm.Run(solverdata, splitterAccuracy * maxLengthModel,
detalizerAccuracy * maxLengthModel);
//Graph msGraph = ConstructGraph(msPoints);
//msGraph.RemoveCycles(maxCycleSize);
//List<Point> points = msGraph.GetPath();
////Точки для работы
//List<IMSPoint> new_mspoints = ConvertPointToMSPoint(points, msPoints);
IJoinMSPoints jointpoints = new JoinMSPoints();
return(jointpoints.Join(msPoints));
}
private void ButtonCalculate_Click(object sender, EventArgs e)
{
Clear();
var function = comboBoxAlgorithm.SelectedItem;
if (function == null)
{
MessageBox.Show("Fonksiyon boş geçilemez.", "Fonksiyon Seçiniz!", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
_functionName = (FunctionNames)function;
var generation = (int)numericUpDownGeneration.Value;
var populationSize = (int)numericUpDownPopulation.Value;
switch (_algorithmType)
{
case AlgorithmTypes.GA:
_algorithm = new GeneticAlgorithm(_functionName, populationSize, generation)
.SetValues(mutationRate: (double)numericUpDownRate.Value);
break;
case AlgorithmTypes.PSO:
//_algorithm = new PSO(_functionName, populationSize, generation)
// .SetValues(c1: (double)numericUpDownRate.Value, c2: (double)numericUpDownRate2.Value);
MessageBox.Show("PSO is WIP", "WIP", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
case AlgorithmTypes.ABC:
_algorithm = new ABC(_functionName, populationSize, generation);
break;
}
_algorithm.AlgorithmStarted += OnAlgoritmStarted;
_algorithm.AlgorithmEnded += OnAlgorithmEnded;
_algorithm.GenerationEnded += OnGenerationEnded;
_algorithm.RunAsync();
}
private void TriggerAction(AGE.Action _action, ref PoolObjHandle <ActorRoot> target)
{
if (this.attackActor != 0)
{
int num;
uint objID = target.handle.ObjID;
if (this.collideCountMap.TryGetValue(objID, out num))
{
num++;
this.collideCountMap[objID] = num;
}
else
{
this.collideCountMap.Add(objID, 1);
}
int num3 = 0;
if (this.collideTimeMap.TryGetValue(objID, out num3))
{
this.collideTimeMap[objID] = this.localTime;
}
else
{
this.collideTimeMap.Add(objID, this.localTime);
}
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if ((refParamObject != null) && (_action.refParams.GetRefParamObject <BaseSkill>("SkillObj") != null))
{
refParamObject.EffectCount++;
if (!this.bTriggerMode)
{
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_1, false);
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_2, false);
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_3, false);
}
else
{
if ((refParamObject.Originator != 0) && (this.SelfSkillCombineID_1 > 0))
{
STriggeredBuffContext inPoint = new STriggeredBuffContext {
actor = refParamObject.Originator,
buffId = this.SelfSkillCombineID_1
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint))
{
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_1, false);
}
}
if ((refParamObject.Originator != 0) && (this.SelfSkillCombineID_2 > 0))
{
STriggeredBuffContext context3 = new STriggeredBuffContext {
actor = refParamObject.Originator,
buffId = this.SelfSkillCombineID_2
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, context3))
{
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_2, false);
}
}
if ((refParamObject.Originator != 0) && (this.SelfSkillCombineID_3 > 0))
{
STriggeredBuffContext context4 = new STriggeredBuffContext {
actor = refParamObject.Originator,
buffId = this.SelfSkillCombineID_3
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, context4))
{
this.attackActor.handle.SkillControl.SpawnBuff(refParamObject.Originator, refParamObject, this.SelfSkillCombineID_3, false);
}
}
}
if (target != 0)
{
this.hit = true;
if ((target.handle.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) && !this.bHitTargetHero)
{
this.bHitTargetHero = true;
this.HitTargetHeroPos = target.handle.location;
}
refParamObject.EffectDir = this.attackActor.handle.forward;
bool flag = false;
if (!this.bTriggerMode)
{
bool introduced12 = this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_1, this.bExtraBuff);
flag = introduced12 | this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_2, this.bExtraBuff);
flag |= this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_3, this.bExtraBuff);
}
else
{
if (this.TargetSkillCombine_1 > 0)
{
STriggeredBuffContext context5 = new STriggeredBuffContext {
actor = target,
buffId = this.TargetSkillCombine_1
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, context5))
{
this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_1, false);
}
flag = true;
}
if (this.TargetSkillCombine_2 > 0)
{
STriggeredBuffContext context6 = new STriggeredBuffContext {
actor = target,
buffId = this.TargetSkillCombine_2
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, context6))
{
this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_2, false);
}
flag = true;
}
if (this.TargetSkillCombine_3 > 0)
{
STriggeredBuffContext context7 = new STriggeredBuffContext {
actor = target,
buffId = this.TargetSkillCombine_3
};
if (BaseAlgorithm.AddUniqueItem <STriggeredBuffContext>(this.TriggeredBuffContextList, context7))
{
this.attackActor.handle.SkillControl.SpawnBuff(target, refParamObject, this.TargetSkillCombine_3, false);
}
flag = true;
}
}
if (flag)
{
target.handle.ActorControl.BeAttackHit(this.attackActor);
}
}
if ((this.bTriggerBullet && (this.BulletActionName != null)) && (this.BulletActionName.Length > 0))
{
refParamObject.AppointType = SkillRangeAppointType.Target;
refParamObject.TargetActor = target;
this.attackActor.handle.SkillControl.SpawnBullet(refParamObject, this.BulletActionName, false, this.bAgeImmeExcute);
}
}
}
}
public void AddAlgorithm(BaseAlgorithm algorithm)
{
_algorithms.Add(algorithm);
}
protected PredictionAlgorithm(BaseAlgorithm <TObservation, TState> baseAlgorithm) : base(baseAlgorithm)
{
}
public bool IsNear(VInt2 point)
{
return(BaseAlgorithm.IsNearlyZero(this.m_point - point, 10));
}
public bool Equals(FowLos.SPolylineVertex rhs)
{
return(BaseAlgorithm.IsNearlyZero(this.m_point - rhs.m_point, 10) && this.m_belongBlockId == rhs.m_belongBlockId && this.m_belongSegNoList == rhs.m_belongSegNoList && this.m_bNative == rhs.m_bNative);
}
public void ExploreCellsInternal <TSetCellVisible>(ref TSetCellVisible setCellVisible, VInt2 newSurfPos, VInt3 unitLoc, int surfSightRange, GameFowManager pFowMgr, COM_PLAYERCAMP camp, FowLos.EViewExploringMode ViewExploringMode, bool bDrawDebugLines) where TSetCellVisible : ISetCellVisible
{
if (pFowMgr == null || pFowMgr.m_pFieldObj == null)
{
return;
}
if (ViewExploringMode != FowLos.EViewExploringMode.EViewExploringMode_ShadowCast)
{
if (ViewExploringMode == FowLos.EViewExploringMode.EViewExploringMode_DistOnly)
{
for (int i = -surfSightRange - 1; i <= surfSightRange + 1; i++)
{
for (int j = -surfSightRange - 1; j <= surfSightRange + 1; j++)
{
VInt2 b = new VInt2(i, j);
VInt2 inPos = newSurfPos + b;
if (pFowMgr.IsInsideSurface(inPos.x, inPos.y) && b.sqrMagnitude < surfSightRange * surfSightRange)
{
setCellVisible.SetVisible(inPos, camp, true);
}
}
}
}
else if (ViewExploringMode != FowLos.EViewExploringMode.EViewExploringMode_WatchTower && ViewExploringMode == FowLos.EViewExploringMode.EViewExploringMode_RayCast)
{
int sightSqr = surfSightRange * surfSightRange;
int num = newSurfPos.x - surfSightRange;
int num2 = newSurfPos.x + surfSightRange;
int num3 = newSurfPos.y - surfSightRange;
int num4 = newSurfPos.y + surfSightRange;
num = Mathf.Clamp(num, 0, pFowMgr.m_pFieldObj.NumX - 1);
num2 = Mathf.Clamp(num2, 0, pFowMgr.m_pFieldObj.NumX - 1);
num3 = Mathf.Clamp(num3, 0, pFowMgr.m_pFieldObj.NumY - 1);
num4 = Mathf.Clamp(num4, 0, pFowMgr.m_pFieldObj.NumY - 1);
byte viewBlockId = pFowMgr.m_pFieldObj.LevelGrid.GetGridCell(newSurfPos).m_viewBlockId;
FieldObj.SViewBlockAttr sViewBlockAttr = default(FieldObj.SViewBlockAttr);
pFowMgr.m_pFieldObj.QueryAttr(newSurfPos, out sViewBlockAttr);
FowLos.CRaycastQuadrant cRaycastQuadrant = new FowLos.CRaycastQuadrant();
cRaycastQuadrant.min = new VInt2(num, num3);
cRaycastQuadrant.max = new VInt2(num2, num4);
if (pFowMgr.m_pFieldObj.ViewBlockArrayImpl != null)
{
List <FowLos.SBlockWalls> .Enumerator enumerator = pFowMgr.m_pFieldObj.ViewBlockArrayImpl.GetEnumerator();
while (enumerator.MoveNext())
{
FowLos.SBlockWalls current = enumerator.get_Current();
int areaId = (int)current.m_areaId;
DebugHelper.Assert(areaId != 0);
FieldObj.SViewBlockAttr sViewBlockAttr2;
if (((int)viewBlockId != areaId || sViewBlockAttr.BlockType != 1) && (pFowMgr.m_pFieldObj.GrassBlockView || !pFowMgr.m_pFieldObj.ViewBlockAttrMap.TryGetValue((byte)areaId, ref sViewBlockAttr2) || sViewBlockAttr2.BlockType != 1) && this.ValidateViewBlock(current, cRaycastQuadrant.min.x, cRaycastQuadrant.max.x, cRaycastQuadrant.min.y, cRaycastQuadrant.max.y))
{
cRaycastQuadrant.viewBlockArrayFinal.Add(current);
Dictionary <byte, List <FowLos.SGridWall> > .Enumerator enumerator2 = current.m_wallsHorizontal.GetEnumerator();
while (enumerator2.MoveNext())
{
List <byte> wallsHorizontal = cRaycastQuadrant.wallsHorizontal;
KeyValuePair <byte, List <FowLos.SGridWall> > current2 = enumerator2.get_Current();
BaseAlgorithm.AddUniqueItem <byte>(wallsHorizontal, current2.get_Key());
}
enumerator2 = current.m_wallsVertical.GetEnumerator();
while (enumerator2.MoveNext())
{
List <byte> wallsVertical = cRaycastQuadrant.wallsVertical;
KeyValuePair <byte, List <FowLos.SGridWall> > current3 = enumerator2.get_Current();
BaseAlgorithm.AddUniqueItem <byte>(wallsVertical, current3.get_Key());
}
}
}
this.RaycastCheck <TSetCellVisible>(pFowMgr, cRaycastQuadrant, newSurfPos, unitLoc, sightSqr, camp, bDrawDebugLines, viewBlockId, ref setCellVisible);
}
cRaycastQuadrant.Clear();
}
}
}
public Harmony(BaseAlgorithm myContainer) : base(myContainer)
{
}
private void TriggerAction(Action _action, ref PoolObjHandle <ActorRoot> target)
{
if (!this.attackActor)
{
return;
}
uint objID = target.get_handle().ObjID;
int num;
if (this.collideCountMap.TryGetValue(objID, ref num))
{
num++;
this.collideCountMap.set_Item(objID, num);
}
else
{
this.collideCountMap.Add(objID, 1);
}
int num2 = 0;
if (this.collideTimeMap.TryGetValue(objID, ref num2))
{
this.collideTimeMap.set_Item(objID, this.localTime);
}
else
{
this.collideTimeMap.Add(objID, this.localTime);
}
if (this.skillContext == null)
{
return;
}
this.skillContext.EffectCount++;
this.skillContext.EffectCountInSingleTrigger++;
if (!this.bTriggerMode)
{
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_1, false);
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_2, false);
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_3, false);
}
else
{
if (this.skillContext.Originator && this.SelfSkillCombineID_1 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint.actor = this.skillContext.Originator;
inPoint.buffId = this.SelfSkillCombineID_1;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_1, false);
}
}
if (this.skillContext.Originator && this.SelfSkillCombineID_2 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint2 = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint2.actor = this.skillContext.Originator;
inPoint2.buffId = this.SelfSkillCombineID_2;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint2))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_2, false);
}
}
if (this.skillContext.Originator && this.SelfSkillCombineID_3 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint3 = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint3.actor = this.skillContext.Originator;
inPoint3.buffId = this.SelfSkillCombineID_3;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint3))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(this.skillContext.Originator, this.skillContext, this.SelfSkillCombineID_3, false);
}
}
}
if (target)
{
this.hit = true;
if (target.get_handle().TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero && !this.bHitTargetHero)
{
this.bHitTargetHero = true;
this.HitTargetHeroPos = target.get_handle().location;
}
this.skillContext.EffectDir = this.attackActor.get_handle().forward;
bool flag = false;
BuffSkill buffSkill = null;
BuffSkill buffSkill2 = null;
BuffSkill buffSkill3 = null;
if (!this.bTriggerMode)
{
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_1, ref buffSkill, this.bExtraBuff);
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_2, ref buffSkill2, this.bExtraBuff);
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_3, ref buffSkill3, this.bExtraBuff);
if ((buffSkill != null && buffSkill.cfgData.bNotGetHate == 0) || (buffSkill2 != null && buffSkill2.cfgData.bNotGetHate == 0) || (buffSkill3 != null && buffSkill3.cfgData.bNotGetHate == 0))
{
flag = true;
}
}
else
{
if (this.TargetSkillCombine_1 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint4 = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint4.actor = target;
inPoint4.buffId = this.TargetSkillCombine_1;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint4))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_1, ref buffSkill, false);
}
if (buffSkill != null && buffSkill.cfgData.bNotGetHate == 0)
{
flag = true;
}
}
if (this.TargetSkillCombine_2 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint5 = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint5.actor = target;
inPoint5.buffId = this.TargetSkillCombine_2;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint5))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_2, ref buffSkill2, false);
}
if (buffSkill2 != null && buffSkill2.cfgData.bNotGetHate == 0)
{
flag = true;
}
}
if (this.TargetSkillCombine_3 > 0)
{
HitTriggerDurationContext.STriggeredBuffContext inPoint6 = default(HitTriggerDurationContext.STriggeredBuffContext);
inPoint6.actor = target;
inPoint6.buffId = this.TargetSkillCombine_3;
if (BaseAlgorithm.AddUniqueItem <HitTriggerDurationContext.STriggeredBuffContext>(this.TriggeredBuffContextList, inPoint6))
{
this.attackActor.get_handle().SkillControl.SpawnBuff(target, this.skillContext, this.TargetSkillCombine_3, ref buffSkill3, false);
}
if (buffSkill3 != null && buffSkill3.cfgData.bNotGetHate == 0)
{
flag = true;
}
}
}
if (this.TargetSkillLeaveRemove_1 && buffSkill != null)
{
this.RemoveSkillList.Add(buffSkill);
}
if (this.TargetSkillLeaveRemove_2 && buffSkill2 != null)
{
this.RemoveSkillList.Add(buffSkill2);
}
if (this.TargetSkillLeaveRemove_3 && buffSkill3 != null)
{
this.RemoveSkillList.Add(buffSkill3);
}
if (flag)
{
target.get_handle().ActorControl.BeAttackHit(this.attackActor, this.skillContext.bExposing);
}
}
if (this.bTriggerBullet && this.BulletActionName != null && this.BulletActionName.get_Length() > 0)
{
this.skillContext.AppointType = 1;
this.skillContext.TargetActor = target;
this.attackActor.get_handle().SkillControl.SpawnBullet(this.skillContext, this.BulletActionName, false, this.bAgeImmeExcute, 0, 0);
}
}
public FSPSolution(BaseAlgorithm myContainer) : base(myContainer)
{
}
public static float FInterpEaseOut(float A, float B, float Alpha, float Exp)
{
return(BaseAlgorithm.Lerp(A, B, Mathf.Pow(Alpha, 1f / Exp)));
}
protected ProbabilityCalculatingAlgorithm(BaseAlgorithm <TObservation, TState> baseAlgorithm)
: base(baseAlgorithm)
{
}
public ViterbiAlgorithm(BaseAlgorithm <TObservation, TState> baseAlgorithm) : base(baseAlgorithm)
{
}
public PrefixAlgorithm(BaseAlgorithm <TObservation, TState> baseAlgorithm) : base(baseAlgorithm)
{
}
public Frog(BaseAlgorithm myContainer) : base(myContainer)
{
}
