protected virtual bool IsPackageInstalled()
{
string errorMessage;
Version installedVersion = DeployHelper.GetInstalledPackageVersion(null, GetVersionFileMask(), out errorMessage);
if (installedVersion == null)
{
if (!(String.IsNullOrEmpty(errorMessage) || errorMessage.Contains("No such file")))
{
ErrorMessage = errorMessage;
OutputDeviceErrorMsg($"IsPackageInstalled({pkgName}) failed. " + errorMessage);
}
return(false);
}
System.Diagnostics.Debug.WriteLine($"Installed version of {pkgName}: {installedVersion}");
bool result = false;
if (installedVersion >= sdkPkgVersion)
{
result = true;
}
OutputDeviceErrorMsg($"IsPackageInstalled({pkgName}): {result}. Installed version: {installedVersion}. SDK version: {sdkPkgVersion}");
return(result);
}
private bool InstallPackage(string tarPath, out string errorMessage)
{
string sdkToolPath = sdbCapability.GetValueByKey("sdk_toolpath");
string errorString;
SDBLib.RunSdbShellCommand(null, $"rm -rf {sdkToolPath}/{pkgName}", null, out errorString); // remove old files (if any)
return(DeployHelper.ExtractTarGzip(null, tarPath, sdkToolPath, out errorMessage));
}
private bool PushXaml(string source, string dest)
{
string errorMessage;
if (DeployHelper.PushFile(_selectedDevice, source, dest, null, out errorMessage))
{
return(true);
}
ShowError(errorMessage);
return(false);
}
public static bool IsTizenVersionSupported(string tizenVersion, bool showDialogIfNot)
{
if (!DeployHelper.IsTizenVersionSupported(tizenVersion))
{
if (showDialogIfNot)
{
Instance.ShowError($"Target platform version {tizenVersion} is not supported");
}
return(false);
}
return(true);
}
private bool TargetHasTizenDotNET(SDBDeviceInfo device, out string lastErrorMessage)
{
bool isDotnetSupported = false;
try
{
var cap = new SDBCapability(device);
isDotnetSupported = DeployHelper.IsTizenVersionSupported(cap.GetValueByKey("platform_version"));
}
catch
{
}
lastErrorMessage = isDotnetSupported ? string.Empty
: "Failed to identify the .NET support on current platform version. Tizen .NET is supported on Tizen 4.0 or higher.";
return(isDotnetSupported);
}
private string FindProfctl() // temporary: support both profctl installed from rpm and from tar.gz
{
string result = $"{_sdkToolPath}/profctl/profctl";
string errorMessage;
if (!DeployHelper.FileExists(_selectedDevice, result, out errorMessage))
{
result = "/usr/bin/profctl";
if (!DeployHelper.FileExists(_selectedDevice, result, out errorMessage))
{
return(null);
}
}
DebugWriteToOutput($"Found 'profctl' utility: {result}");
return(result);
}
private bool PrepareAndCopyFilesToTarget()
{
if (!_isLiveProfiling)
{
if (!InstallTpk())
{
return(false);
}
}
string tempFileName = Path.GetTempFileName();
try
{
if (!WriteProfilerConfigFile(_sessionConfiguration.TargetDll, _sessionConfiguration.AppId, tempFileName))
{
WriteToOutput("[PrepareAndCopyFilesToTarget] WriteProfilerConfigFile failed");
return(false);
}
string destination = $"{_targetShareDirectory}/{ProfilerConfigName}";
DebugWriteToOutput($"Uploading \"{tempFileName}\" to {destination}...");
string errorMessage;
if (!DeployHelper.PushFile(_selectedDevice, tempFileName, destination, null, out errorMessage))
{
WriteToOutput(errorMessage);
return(false);
}
}
finally
{
try { File.Delete(tempFileName); } catch { }
}
return(true);
}
public override IEnumerable <int> AttackRoutine()
{
List <Point> deployPoints = new List <Point>();
Logger.Info("[Attack-DeadBase] Now deploying main attack wave.");
var analysisPoints = new List <Point>();
var mineRects = new List <Rectangle>();
var fiber = new Fiber <int>(DeployHelper.GenerateDeployPointsFromMines(analysisPoints, RedPoints, mineRects));
while (fiber.Run())
{
yield return(1);
}
deployPoints.AddRange(analysisPoints);
// Debug: show deploy points
using (var frame = Screenshot.Capture(true))
{
using (var g = Graphics.FromImage(frame))
{
foreach (var p in RedPoints)
{
g.RectWithOutline(p.ToRectangle(2, 2), Color.Red);
}
foreach (var m in mineRects)
{
g.RectWithOutline(m, Color.DarkOrange);
}
foreach (var p in deployPoints)
{
g.RectWithOutline(p.ToRectangle(4, 4), Color.White);
}
foreach (var m in mineRects)
{
var closure = m;
foreach (var closest in deployPoints.OrderBy(p => p.DistanceSq(closure.GetCenter())).Take(2))
{
g.DrawLine(Pens.Red, m.GetCenter(), closest);
}
}
}
if (UserSettings.SaveAttackAnalysisImage)
{
Screenshot.Save(frame, $"AttackAnalysis_Dead {deployPoints.Count} points {RedPoints.Count} red");
}
if (UserSettings.DisplayAttackAnalysisImage)
{
Screenshot.Show(frame);
}
}
_deployPoints = deployPoints.ToArray();
if (_deployPoints == null)
{
throw new ArgumentNullException("deployPoints");
}
if (_deployPoints.Length == 0)
{
throw new ArgumentException("deployPoints must contain at least one point");
}
// Get outer border to move ranges towards there if possible
List <Point> outerBorderPoints = DeployHelper.GetRectPoints(15);
if (surrenderOnFirstStar)
{
Logger.Info("[Deploy] Bot will surrender as soon as the first star is reached to save troops (Trophy Push Mode)");
}
var allDeployElements = Deploy.GetTroops();
var heroes = allDeployElements
.Where(u => (UserSettings.UseKing && u.ElementType == DeployElementType.HeroKing) ||
(UserSettings.UseQueen && u.ElementType == DeployElementType.HeroQueen) ||
(UserSettings.UseWarden && u.ElementType == DeployElementType.HeroWarden))
.ToList();
int deployPointCounter = 0;
int waveLimit = UserSettings.WaveSize;
double waitTimeSeconds = UserSettings.WaveDelay;
Random rng = new Random();
while (true)
{
Logger.Debug("Scan Troops");
// Scan available troops
var units = Deploy.GetTroops()
.Where(u => u.ElementType == DeployElementType.NormalUnit ||
(UserSettings.UseKing && u.ElementType == DeployElementType.HeroKing) ||
(UserSettings.UseQueen && u.ElementType == DeployElementType.HeroQueen) ||
(UserSettings.UseWarden && u.ElementType == DeployElementType.HeroWarden) ||
(UserSettings.UseClanTroops && u.ElementType == DeployElementType.ClanTroops))
.ToList();
// Remove king/queen
ExtractHeroes(units, heroes);
Logger.DebugDev("Deployable Troops: " + ToUnitString(units));
// Break if we don't have any left
if (units.Count == 0 || units.All(u => u.Count == 0))
{
break;
}
// Order units by priority
// Tank > Wallbreaker > Heal > Damage > Heroes
Logger.Debug("OrderTroops");
units.OrderForDeploy();
int waveCounter = 0;
foreach (var u in units)
{
if (u == null)
{
Logger.Info("Wave #{0} complete, short deploy delay now...", waveCounter);
yield return(rng.Next(900, 2000));
continue;
}
if (u.Count == 0)
{
continue;
}
// Select unit
Logger.Debug("[Deploy] Deploying '{0}'", u);
u.Select();
// Deploy them
while (true)
{
int unitCount = u.Count;
int totalDeployedThisWave = 0;
while (unitCount > 0)
{
//var line = deployLines[lineCounter++ % deployLines.Length];
//
//DeployHelper.ClickAlongLine(line.Item1, line.Item2, deployCount, 10);
var deployCount = Math.Min(u.Count, 4);
Logger.Debug("Deploy Start");
for (int i = 0; i < deployCount; i++)
{
if (surrenderOnFirstStar)
{
if (SurrenderIfWeHaveAStar())
{
yield return(500);
yield break;
}
}
if (deployPointCounter >= _deployPoints.Length)
{
deployPointCounter = 0;
}
Logger.Debug("deploy at point index {0} of {1}", deployPointCounter, _deployPoints.Length);
var point = _deployPoints[deployPointCounter++];
// If this unit is ranged, we deploy further back
if (u.IsRanged)
{
var borderPoint = outerBorderPoints.OrderBy(p => p.DistanceSq(point)).First();
var distance = (int)Math.Sqrt(borderPoint.DistanceSq(point));
if (distance > 10)
{
var maxMove = Math.Min(u.UnitData.Range * 16, distance);
var dir = borderPoint.Normalize();
// Clamp the distance to the max move distance so we dont deploy too far behind
borderPoint = new Point((int)(dir.Item1 * maxMove) + point.X, (int)(dir.Item2 * maxMove) + point.Y);
var t = (float)rng.Range(0.85, 1.05);
point = point.Lerp(borderPoint, t);
}
}
// Modify this point a bit so its not too ovbious
point.X += rng.Next(-12, 12);
point.Y += rng.Next(-12, 12);
Input.Click(point);
totalDeployedThisWave++;
if (totalDeployedThisWave >= waveLimit)
{
Logger.Info("WaveLimit {0} reached. Wait {1:0.0} sec.", waveLimit, waitTimeSeconds);
yield return((int)(waitTimeSeconds * 1000));
totalDeployedThisWave = 0;
}
Thread.Sleep(10);
Thread.Sleep(5);
}
Logger.Debug("Deploy End");
unitCount -= deployCount;
}
// Refresh unit count, if its really 0, break.
Logger.Debug("RecountA");
int countA = u.Count;
u.Recount();
int countB = u.Count;
Logger.Debug("RecountB");
if (countA != countB)
{
Logger.Info("Recount of '{0}'. {1}->{2}", u.PrettyName, countA, countB);
}
if (u.Count <= 0)
{
Logger.Info("Unit '{0}' depleted. Break.", u.PrettyName);
yield return(500);
break;
}
}
waveCounter++;
}
yield return(50);
}
if (heroes.Count > 0)
{
foreach (var y in DeployHeroes(heroes, _deployPoints))
{
if (surrenderOnFirstStar)
{
if (SurrenderIfWeHaveAStar())
{
break;
}
}
yield return(y);
}
}
Logger.Info("[Deploy] Deploy done.");
}
public override IEnumerable <int> AttackRoutine()
{
deployPoints = DeployHelper.GetRectPoints(15);
OrderPointsClockwise(deployPoints);
if (deployPoints == null)
{
throw new ArgumentNullException("deployPoints");
}
if (deployPoints.Count == 0)
{
throw new ArgumentException("deployPoints must contain at least one point");
}
// Get outer border to move ranges towards there if possible
List <Point> outerBorderPoints = DeployHelper.GetRectPoints(15);
if (_surrenderOnFirstStar)
{
Logger.Info("[Deploy] Bot will surrender as soon as the first star is reached to save troops (Trophy Push Mode)");
}
var allDeployElements = Deploy.GetTroops();
var heroes = allDeployElements
.Where(u => (UserSettings.UseKing && u.ElementType == DeployElementType.HeroKing) ||
(UserSettings.UseQueen && u.ElementType == DeployElementType.HeroQueen) ||
(UserSettings.UseWarden && u.ElementType == DeployElementType.HeroWarden))
.ToList();
int deployPointCounter = 0;
int waveLimit = UserSettings.WaveSize;
double waitTimeSeconds = UserSettings.WaveDelay;
Random rng = new Random();
while (true)
{
Logger.Debug("Scan Troops");
// Scan available troops
var units = Deploy.GetTroops()
.Where(u => u.ElementType == DeployElementType.NormalUnit ||
(UserSettings.UseKing && u.ElementType == DeployElementType.HeroKing) ||
(UserSettings.UseQueen && u.ElementType == DeployElementType.HeroQueen) ||
(UserSettings.UseWarden && u.ElementType == DeployElementType.HeroWarden) ||
(UserSettings.UseClanTroops && u.ElementType == DeployElementType.ClanTroops))
.ToList();
// Remove king/queen
ExtractHeroes(units, heroes);
Logger.DebugDev("Deployable Troops: " + ToUnitString(units));
// Break if we don't have any left
if (units.Count == 0 || units.All(u => u.Count == 0))
{
break;
}
// Order units by priority
// Tank > Wallbreaker > Heal > Damage > Heroes
Logger.Debug("OrderTroops");
units.OrderForDeploy();
int waveCounter = 0;
foreach (var u in units)
{
if (u == null)
{
Logger.Info("Wave #{0} complete, short deploy delay now...", waveCounter);
yield return(rng.Next(900, 2000));
continue;
}
if (u.Count == 0)
{
continue;
}
// Select unit
Logger.Debug("[Deploy] Deploying '{0}'", u);
u.Select();
// Deploy them
while (true)
{
int unitCount = u.Count;
int totalDeployedThisWave = 0;
while (unitCount > 0)
{
//var line = deployLines[lineCounter++ % deployLines.Length];
//
//DeployHelper.ClickAlongLine(line.Item1, line.Item2, deployCount, 10);
var deployCount = unitCount;
Logger.Debug("Deploy Start");
for (int i = 0; i < deployCount; i++)
{
if (_surrenderOnFirstStar)
{
if (SurrenderIfWeHaveAStar())
{
yield return(500);
yield break;
}
}
if (deployPointCounter >= deployPoints.Count)
{
deployPointCounter = 0;
}
Logger.Debug("deploy at point index {0} of {1}", deployPointCounter, deployPoints.Count);
// We want to deploy our units evenly around those points.
// Lets say we have 10 units, 100 points.
// Then we deploy a unit at 0, 10, 20, ...
double fraction = 1.618034;
int index = (int)((deployPointCounter * fraction * deployPoints.Count) % deployPoints.Count);
deployPointCounter++;
var point = deployPoints[index];
// If this unit is ranged, we deploy further back
if (u.IsRanged)
{
var borderPoint = outerBorderPoints.OrderBy(p => p.DistanceSq(point)).First();
var distance = (int)Math.Sqrt(borderPoint.DistanceSq(point));
if (distance > 10)
{
var maxMove = Math.Min(u.UnitData.Range * 16, distance);
var dir = borderPoint.Normalize();
// Clamp the distance to the max move distance so we dont deploy too far behind
borderPoint = new Point((int)(dir.Item1 * maxMove) + point.X, (int)(dir.Item2 * maxMove) + point.Y);
var t = (float)rng.Range(0.85, 1.05);
point = point.Lerp(borderPoint, t);
}
}
// Modify this point a bit so its not too ovbious
point.X += rng.Next(-12, 12);
point.Y += rng.Next(-12, 12);
Input.Click(point);
totalDeployedThisWave++;
if (totalDeployedThisWave >= waveLimit)
{
Logger.Info("WaveLimit {0} reached. Wait {1:0.0} sec.", waveLimit, waitTimeSeconds);
yield return((int)(waitTimeSeconds * 1000));
totalDeployedThisWave = 0;
}
Thread.Sleep(10);
Thread.Sleep(5);
}
Logger.Debug("Deploy End");
unitCount -= deployCount;
}
// Refresh unit count, if its really 0, break.
Logger.Debug("RecountA");
int countA = u.Count;
u.Recount();
int countB = u.Count;
Logger.Debug("RecountB");
if (countA != countB)
{
Logger.Info("Recount of '{0}'. {1}->{2}", u.PrettyName, countA, countB);
}
if (u.Count <= 0)
{
Logger.Info("Unit '{0}' depleted. Break.", u.PrettyName);
yield return(500);
break;
}
}
waveCounter++;
}
yield return(50);
}
if (heroes.Count > 0)
{
foreach (var y in DeployHeroes(heroes, deployPoints))
{
if (_surrenderOnFirstStar)
{
if (SurrenderIfWeHaveAStar())
{
break;
}
}
yield return(y);
}
}
Logger.Info("[Deploy] Deploy done.");
}
public override IEnumerable <int> AttackRoutine()
{
var allDeployElements = Deploy.GetTroops();
List <Point> redPoints = new List <Point>();
foreach (var s in AttackHelper.FindRedPoints(redPoints))
{
yield return(s);
}
var leftCorner = DeployHelper.DeployPointALeft;
var topCorner = DeployHelper.DeployPointATop;
double tankPaddingFraction = 0.35;
var tankDeployA = leftCorner.Lerp(topCorner, tankPaddingFraction);
var tankDeployB = leftCorner.Lerp(topCorner, 1 - tankPaddingFraction);
double wallBreakerFraction = 0.43;
var wallBreakDeployA = leftCorner.Lerp(topCorner, wallBreakerFraction);
var wallBreakDeployB = leftCorner.Lerp(topCorner, 1 - wallBreakerFraction);
double damageFraction = 0.15;
var damageDeployPointA = leftCorner.Lerp(topCorner, damageFraction);
var damageDeployPointB = leftCorner.Lerp(topCorner, 1 - damageFraction);
// We want to drag our deploy points to the closest redline point
// For that we get the vector from left to top, then we get its orthogonal vector (the one of both that points more towards the center)
// then we can order the redline points. we want the one whos direction is closest to the orthogonal vector.
var vecLeftTop = topCorner.Subtract(leftCorner).Normalize();
var ortho = GetOrthogonalDirection(tankDeployA, new Point((int)(vecLeftTop.Item1 * 30), (int)(vecLeftTop.Item2 * 30)), new PointF(0.5f, 0.5f).ToAbsolute());
tankDeployA = GetBestRedlinePoint(redPoints, tankDeployA, ortho);
tankDeployB = GetBestRedlinePoint(redPoints, tankDeployB, ortho);
wallBreakDeployA = GetBestRedlinePoint(redPoints, wallBreakDeployA, ortho);
wallBreakDeployB = GetBestRedlinePoint(redPoints, wallBreakDeployB, ortho);
var attackLine = DeployHelper.GetPointsForLine(damageDeployPointA, damageDeployPointB, 30).ToArray();
for (int i = 0; i < attackLine.Length; i++)
{
attackLine[i] = GetBestRedlinePoint(redPoints, attackLine[i], ortho);
}
attackLine = attackLine.Distinct().ToArray();
var validUnits = allDeployElements.Where(u => u.UnitData != null).ToArray();
var clanTroops = allDeployElements.FirstOrDefault(u => u.ElementType == DeployElementType.ClanTroops);
//Func<DeployElement, bool> isAir = e => e.UnitData.UnitType == UnitType.Air;
Func <DeployElement, bool> isBalloon = e => e.UnitData.NameSimple.Contains("balloon");
Func <DeployElement, bool> isMinion = e => e.UnitData.NameSimple.Contains("minion");
var tankUnits = validUnits.Where(u => u.UnitData.AttackType == AttackType.Tank).ToArray();
var wallBreakerUnits = validUnits.Where(u => u.UnitData.AttackType == AttackType.Wallbreak).ToArray();
var attackUnits = validUnits.Where(u => u.UnitData.AttackType == AttackType.Damage && !isMinion(u)).ToArray();
if (clanTroops != null && UserSettings.UseClanTroops)
{
attackUnits = attackUnits.Concat(new[] { clanTroops }).ToArray();
}
var healUnits = validUnits.Where(u => u.UnitData.AttackType == AttackType.Heal).ToArray();
var balloonUnits = validUnits.Where(isBalloon).ToArray();
var minionUnits = validUnits.Where(isMinion).ToArray();
// Deploy tank units
if (tankUnits.Any())
{
Logger.Debug($"{tankUnits.Length} tanking element{(tankUnits.Length > 1 ? "s" : "")} available to deploy.");
foreach (var s in DeployUnits(tankUnits, new[] { tankDeployA, tankDeployB }, 20))
{
yield return(s);
}
yield return(2000);
}
// Deploy wallbreakers
if (tankUnits.Any())
{
Logger.Debug("Wallbreakers available to deploy.");
foreach (var s in DeployUnits(wallBreakerUnits, new[] { wallBreakDeployA, wallBreakDeployB }, 40))
{
yield return(s);
}
yield return(1000);
}
// Check whether we got an air troopset and decide to perform an air attack or not
var balloonCount = balloonUnits.Sum(i => i.Count);
if (balloonCount > 10)
{
// Ok, we have an air troopset, so we will deploy the air units first according to different deploy rules.
attackUnits = attackUnits.Where(u => !isBalloon(u)).ToArray();
int spotCount = (int)Math.Ceiling(balloonCount / 4.0);
// We want to make x spots where balloons are deployed
var airPoints = DeployHelper.GetPointsForLine(damageDeployPointA, damageDeployPointB, spotCount);
for (int i = 0; i < airPoints.Count; i++)
{
airPoints[i] = GetBestRedlinePoint(redPoints, airPoints[i], ortho);
}
airPoints = airPoints.Distinct().ToList();
// Deploy those air units
foreach (var s in DeployUnits(balloonUnits, airPoints.ToArray(), firstCycleYield: 1000))
{
yield return(s);
}
}
// Deploy atackers
if (attackUnits.Any())
{
Logger.Debug($"{attackUnits.Length} attacking element{(attackUnits.Length > 1 ? "s" : "")} available to deploy.");
foreach (var s in DeployUnits(attackUnits, attackLine, 0, 5, 2500))
{
yield return(s);
}
yield return(500);
}
// Minions
if (minionUnits.Any())
{
foreach (var s in DeployUnits(minionUnits, attackLine))
{
yield return(s);
}
}
// Deploy healers
foreach (var s in DeployUnits(healUnits, attackLine))
{
yield return(s);
}
// Deploy heroes
var heroes = allDeployElements
.Where(u => (UserSettings.UseKing && u.ElementType == DeployElementType.HeroKing) ||
(UserSettings.UseQueen && u.ElementType == DeployElementType.HeroQueen) ||
(UserSettings.UseWarden && u.ElementType == DeployElementType.HeroWarden))
.ToList();
if (heroes.Count > 0)
{
foreach (var y in DeployHeroes(heroes, attackLine))
{
yield return(y);
}
}
}
protected virtual bool PushPackage(string source, string destination, out string errorMessage)
{
return(DeployHelper.PushFile(null, source, destination,
(isStdOut, line) => { OnMessage("SDK Tool Installing... ", line); return false; },
out errorMessage));
}
protected string GetPackageFileName()
{
return($"{pkgName}-{sdkPkgVersion}-{DeployHelper.GetPackageSuffix(GetTargetArch())}{pkgExtension}");
}
protected bool InstallTpk()
{
const string AppDir = "/opt/usr/globalapps/";
string tpkPath = _sessionConfiguration.GetTpkPath();
DebugWriteToOutput($"Checking Tizen package {tpkPath}...");
string signatureFileName = "signature1.xml";
string prefix = AppDir + _sessionConfiguration.AppId + '/';
string tmpFile = Path.GetTempFileName();
try
{
if (!DownloadFile(prefix + signatureFileName, tmpFile))
{
signatureFileName = "author-signature.xml";
if (!DownloadFile(prefix + signatureFileName, tmpFile))
{
signatureFileName = null;
}
}
if (signatureFileName != null)
{
string signatureFilePath = Path.Combine(Path.GetDirectoryName(tpkPath), "tpkroot", signatureFileName);
if (DeployHelper.AreFilesEqual(tmpFile, signatureFilePath))
{
DebugWriteToOutput($"Tizen package {tpkPath} is already installed");
return(true);
}
}
}
finally
{
try { File.Delete(tmpFile); } catch { }
}
// Install Tizen Package with binary
WriteToOutput($"Installing Tizen package \"{tpkPath}\"...");
bool success = false;
string errorMessage;
// TODO!! show wait dialog (see InstallTizenPackage in Tizen.VisualStudio.ProjectSystem.VS\Debug\Launcher.cs)
success = DeployHelper.InstallTpk(_selectedDevice, tpkPath,
(bool isStdOut, string line) =>
{
if (!isStdOut) // error output
{
WriteToOutput(line);
}
return(false);
},
out errorMessage,
TimeSpan.FromMinutes(5));
if (!success)
{
WriteToOutput($"[InstallTpk] {errorMessage}");
}
return(success);
}
