public static void Execute(Context ctx, StateMachine machine)
{
var pokemons = ctx.Inventory.GetPokemons().Result;
foreach (var pokemon in pokemons)
{
var perfection = Math.Round(PokemonInfo.CalculatePokemonPerfection(pokemon));
var pokemonName = pokemon.PokemonId.ToString();
if (pokemonName.Length > 10 - perfection.ToString().Length)
{
pokemonName = pokemonName.Substring(0, 10 - perfection.ToString().Length);
}
var newNickname = $"{pokemonName}_{perfection}";
if (perfection > ctx.LogicSettings.KeepMinIvPercentage && newNickname != pokemon.Nickname && ctx.LogicSettings.RenameAboveIv)
{
var result = ctx.Client.Inventory.NicknamePokemon(pokemon.Id, newNickname).Result;
machine.Fire(new NoticeEvent
{
Message = $"Pokemon {pokemon.PokemonId} ({pokemon.Id}) renamed from {pokemon.Nickname} to {newNickname}."
});
}
else if (newNickname == pokemon.Nickname && !ctx.LogicSettings.RenameAboveIv)
{
var result = ctx.Client.Inventory.NicknamePokemon(pokemon.Id, pokemon.PokemonId.ToString());
machine.Fire(new NoticeEvent
{
Message = $"Pokemon {pokemon.PokemonId} ({pokemon.Id}) renamed from {pokemon.Nickname} to {pokemon.PokemonId}."
});
}
}
}
public static void Execute(Context ctx, StateMachine machine)
{
if (ctx.LogicSettings.UseLuckyEggsWhileEvolving)
{
UseLuckyEgg(ctx.Client, ctx.Inventory, machine);
}
var pokemonToEvolveTask = ctx.Inventory.GetPokemonToEvolve(ctx.LogicSettings.PokemonsToEvolve);
pokemonToEvolveTask.Wait();
var pokemonToEvolve = pokemonToEvolveTask.Result;
foreach (var pokemon in pokemonToEvolve)
{
var evolveTask = ctx.Client.Inventory.EvolvePokemon(pokemon.Id);
evolveTask.Wait();
var evolvePokemonOutProto = evolveTask.Result;
machine.Fire(new PokemonEvolveEvent
{
Id = pokemon.PokemonId,
Exp = evolvePokemonOutProto.ExperienceAwarded,
Result = evolvePokemonOutProto.Result
});
Thread.Sleep(3000);
}
}
private static void Main()
{
Logger.SetLogger(new ConsoleLogger(LogLevel.Info));
var machine = new StateMachine();
var stats = new Statistics();
stats.DirtyEvent += () => Console.Title = stats.ToString();
var aggregator = new StatisticsAggregator(stats);
var listener = new ConsoleEventListener();
machine.EventListener += listener.Listen;
machine.EventListener += aggregator.Listen;
machine.SetFailureState(new LoginState());
GlobalSettings settings = GlobalSettings.Load("\\config\\config.json");
var context = new Context(new ClientSettings(settings), new LogicSettings(settings));
context.Client.Login.GoogleDeviceCodeEvent += LoginWithGoogle;
machine.AsyncStart(new VersionCheckState(), context);
Console.ReadLine();
}
public IState Execute(Context ctx, StateMachine machine)
{
RenamePokemonTask.Execute(ctx, machine);
if (ctx.LogicSettings.EvolveAllPokemonAboveIv || ctx.LogicSettings.EvolveAllPokemonWithEnoughCandy)
{
EvolvePokemonTask.Execute(ctx, machine);
}
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.UseGpxPathing)
{
FarmPokestopsGpxTask.Execute(ctx, machine);
}
else
{
FarmPokestopsTask.Execute(ctx, machine);
}
machine.RequestDelay(10000);
return this;
}
public IState Execute(Context ctx, StateMachine machine)
{
if (!IsLatest())
{
machine.Fire(new WarnEvent
{
Message = "There is a new version available: https://github.com/WooAf/PoGoBoT"
});
}
return new LoginState();
}
public IState Execute(Context ctx, StateMachine machine)
{
var coordsPath = Directory.GetCurrentDirectory() + "\\Configs\\Coords.ini";
if (File.Exists(coordsPath))
{
var latLngFromFile = LoadPositionFromDisk(machine);
if (latLngFromFile != null)
{
var distance = LocationUtils.CalculateDistanceInMeters(latLngFromFile.Item1, latLngFromFile.Item2,
ctx.Settings.DefaultLatitude, ctx.Settings.DefaultLongitude);
var lastModified = File.Exists(coordsPath) ? (DateTime?) File.GetLastWriteTime(coordsPath) : null;
if (lastModified != null)
{
var hoursSinceModified = (DateTime.Now - lastModified).HasValue
? (double?) ((DateTime.Now - lastModified).Value.Minutes/60.0)
: null;
if (hoursSinceModified != null && hoursSinceModified != 0)
{
var kmph = distance/1000/(double) hoursSinceModified;
if (kmph < 80) // If speed required to get to the default location is < 80km/hr
{
File.Delete(coordsPath);
machine.Fire(new WarnEvent
{
Message = "Detected realistic Traveling , using UserSettings.settings"
});
}
else
{
machine.Fire(new WarnEvent
{
Message = "Not realistic Traveling at " + kmph + ", using last saved Coords.ini"
});
}
}
}
}
}
machine.Fire(new WarnEvent
{
Message =
$"Make sure Lat & Lng are right. Exit Program if not! Lat: {ctx.Client.CurrentLatitude} Lng: {ctx.Client.CurrentLongitude}"
});
machine.RequestDelay(3000);
return new FarmState();
}
public static void Execute(Context ctx, StateMachine machine)
{
var items = ctx.Inventory.GetItemsToRecycle(ctx.Settings).Result;
foreach (var item in items)
{
ctx.Client.Inventory.RecycleItem(item.ItemId, item.Count).Wait();
machine.Fire(new ItemRecycledEvent {Id = item.ItemId, Count = item.Count});
Thread.Sleep(500);
}
ctx.Inventory.RefreshCachedInventory().Wait();
}
public static void UseLuckyEgg(Client client, Inventory inventory, StateMachine machine)
{
var inventoryContent = inventory.GetItems().Result;
var luckyEggs = inventoryContent.Where(p => p.ItemId == ItemId.ItemLuckyEgg);
var luckyEgg = luckyEggs.FirstOrDefault();
if (luckyEgg == null || luckyEgg.Count <= 0)
return;
client.Inventory.UseItemXpBoost().Wait();
luckyEgg.Count -= 1;
machine.Fire(new UseLuckyEggEvent {Count = luckyEgg.Count});
Thread.Sleep(2000);
}
public IState Execute(Context ctx, StateMachine machine)
{
try
{
switch (ctx.Settings.AuthType)
{
case AuthType.Ptc:
try
{
ctx.Client.Login.DoPtcLogin(ctx.Settings.PtcUsername, ctx.Settings.PtcPassword).Wait();
}
catch (System.AggregateException ae)
{
throw ae.Flatten().InnerException;
}
break;
case AuthType.Google:
ctx.Client.Login.DoGoogleLogin().Wait();
break;
default:
machine.Fire(new ErrorEvent {Message = "wrong AuthType"});
return null;
}
}
catch (PtcOfflineException)
{
machine.Fire(new ErrorEvent
{
Message = "PTC Servers are probably down OR your credentials are wrong. Try google"
});
machine.Fire(new NoticeEvent {Message = "Trying again in 20 seconds..."});
machine.RequestDelay(20000);
return this;
}
catch (AccountNotVerifiedException)
{
machine.Fire(new ErrorEvent {Message = "Account not verified. - Exiting"});
return null;
}
DownloadProfile(ctx, machine);
return new PositionCheckState();
}
public static void Execute(Context ctx, StateMachine machine)
{
var duplicatePokemons =
ctx.Inventory.GetDuplicatePokemonToTransfer(ctx.LogicSettings.KeepPokemonsThatCanEvolve, ctx.LogicSettings.PrioritizeIvOverCp,
ctx.LogicSettings.PokemonsNotToTransfer).Result;
var pokemonSettings = ctx.Inventory.GetPokemonSettings().Result;
var pokemonFamilies = ctx.Inventory.GetPokemonFamilies().Result;
foreach (var duplicatePokemon in duplicatePokemons)
{
if (duplicatePokemon.Cp >= ctx.LogicSettings.KeepMinCp ||
PokemonInfo.CalculatePokemonPerfection(duplicatePokemon) > ctx.LogicSettings.KeepMinIvPercentage)
{
continue;
}
ctx.Client.Inventory.TransferPokemon(duplicatePokemon.Id).Wait();
ctx.Inventory.DeletePokemonFromInvById(duplicatePokemon.Id);
var bestPokemonOfType = ctx.LogicSettings.PrioritizeIvOverCp
? ctx.Inventory.GetHighestPokemonOfTypeByIv(duplicatePokemon).Result
: ctx.Inventory.GetHighestPokemonOfTypeByCp(duplicatePokemon).Result;
if (bestPokemonOfType == null)
bestPokemonOfType = duplicatePokemon;
var setting = pokemonSettings.Single(q => q.PokemonId == duplicatePokemon.PokemonId);
var family = pokemonFamilies.Single(q => q.FamilyId == setting.FamilyId);
family.Candy++;
machine.Fire(new TransferPokemonEvent
{
Id = duplicatePokemon.PokemonId,
Perfection = PokemonInfo.CalculatePokemonPerfection(duplicatePokemon),
Cp = duplicatePokemon.Cp,
BestCp = bestPokemonOfType.Cp,
BestPerfection = PokemonInfo.CalculatePokemonPerfection(bestPokemonOfType),
FamilyCandies = family.Candy
});
}
}
//Please do not change GetPokeStops() in this file, it's specifically set
//to only find stops within 40 meters
//this is for gpx pathing, we are not going to the pokestops,
//so do not make it more than 40 because it will never get close to those stops.
public static void Execute(Context ctx, StateMachine machine)
{
var pokestopList = GetPokeStops(ctx);
while (pokestopList.Any())
{
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
ctx.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Wait();
var fortSearch =
ctx.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Result;
if (fortSearch.ExperienceAwarded > 0)
{
machine.Fire(new FortUsedEvent
{
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded)
});
}
Thread.Sleep(1000);
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
}
}
private static Tuple<double, double> LoadPositionFromDisk(StateMachine machine)
{
if (File.Exists(Directory.GetCurrentDirectory() + "\\Configs\\Coords.ini") &&
File.ReadAllText(Directory.GetCurrentDirectory() + "\\Configs\\Coords.ini").Contains(":"))
{
var latlngFromFile = File.ReadAllText(Directory.GetCurrentDirectory() + "\\Configs\\Coords.ini");
var latlng = latlngFromFile.Split(':');
if (latlng[0].Length != 0 && latlng[1].Length != 0)
{
try
{
var latitude = Convert.ToDouble(latlng[0]);
var longitude = Convert.ToDouble(latlng[1]);
if (Math.Abs(latitude) <= 90 && Math.Abs(longitude) <= 180)
{
return new Tuple<double, double>(latitude, longitude);
}
machine.Fire(new WarnEvent
{
Message = "Coordinates in \"Coords.ini\" file are invalid, using the default coordinates"
});
return null;
}
catch (FormatException)
{
machine.Fire(new WarnEvent
{
Message = "Coordinates in \"Coords.ini\" file are invalid, using the default coordinates"
});
return null;
}
}
}
return null;
}
public static void Execute(Context ctx, StateMachine machine)
{
Logger.Write("Looking for pokemon..", LogLevel.Debug);
var pokemons = GetNearbyPokemons(ctx);
foreach (var pokemon in pokemons)
{
if (ctx.LogicSettings.UsePokemonToNotCatchFilter &&
ctx.LogicSettings.PokemonsNotToCatch.Contains(pokemon.PokemonId))
{
Logger.Write("Skipped " + pokemon.PokemonId);
continue;
}
var distance = LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, pokemon.Latitude, pokemon.Longitude);
Thread.Sleep(distance > 100 ? 15000 : 500);
var encounter = ctx.Client.Encounter.EncounterPokemon(pokemon.EncounterId, pokemon.SpawnPointId).Result;
if (encounter.Status == EncounterResponse.Types.Status.EncounterSuccess)
{
CatchPokemonTask.Execute(ctx, machine, encounter, pokemon);
}
else
{
machine.Fire(new WarnEvent {Message = $"Encounter problem: {encounter.Status}"});
}
// If pokemon is not last pokemon in list, create delay between catches, else keep moving.
if (!Equals(pokemons.ElementAtOrDefault(pokemons.Count() - 1), pokemon))
{
Thread.Sleep(ctx.LogicSettings.DelayBetweenPokemonCatch);
}
}
}
public void DownloadProfile(Context ctx, StateMachine machine)
{
ctx.Profile = ctx.Client.Player.GetPlayer().Result;
machine.Fire(new ProfileEvent {Profile = ctx.Profile});
}
public static void Execute(Context ctx, StateMachine machine, EncounterResponse encounter, MapPokemon pokemon)
{
CatchPokemonResponse caughtPokemonResponse;
var attemptCounter = 1;
do
{
var probability = encounter?.CaptureProbability?.CaptureProbability_?.FirstOrDefault();
var pokeball = GetBestBall(ctx, encounter);
if (pokeball == ItemId.ItemUnknown)
{
machine.Fire(new NoPokeballEvent
{
Id = pokemon.PokemonId,
Cp = encounter?.WildPokemon?.PokemonData?.Cp ?? 0
});
return;
}
var isLowProbability = probability.HasValue && probability.Value < 0.35;
var isHighCp = encounter != null && encounter.WildPokemon?.PokemonData?.Cp > 400;
var isHighPerfection = PokemonInfo.CalculatePokemonPerfection(encounter?.WildPokemon?.PokemonData) >=
ctx.LogicSettings.KeepMinIvPercentage;
if ((isLowProbability && isHighCp) || isHighPerfection)
{
UseBerry(ctx, machine, pokemon.EncounterId, pokemon.SpawnPointId);
}
var distance = LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, pokemon.Latitude, pokemon.Longitude);
caughtPokemonResponse =
ctx.Client.Encounter.CatchPokemon(pokemon.EncounterId, pokemon.SpawnPointId, pokeball).Result;
var evt = new PokemonCaptureEvent {Status = caughtPokemonResponse.Status};
if (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchSuccess)
{
var totalExp = 0;
foreach (var xp in caughtPokemonResponse.CaptureAward.Xp)
{
totalExp += xp;
}
var profile = ctx.Client.Player.GetPlayer().Result;
evt.Exp = totalExp;
evt.Stardust = profile.PlayerData.Currencies.ToArray()[1].Amount;
var pokemonSettings = ctx.Inventory.GetPokemonSettings().Result;
var pokemonFamilies = ctx.Inventory.GetPokemonFamilies().Result;
var setting = pokemonSettings.FirstOrDefault(q => q.PokemonId == pokemon.PokemonId);
var family = pokemonFamilies.FirstOrDefault(q => q.FamilyId == setting.FamilyId);
if (family != null)
{
family.Candy += caughtPokemonResponse.CaptureAward.Candy.Sum();
evt.FamilyCandies = family.Candy;
}
else
{
evt.FamilyCandies = caughtPokemonResponse.CaptureAward.Candy.Sum();
}
}
if (encounter?.CaptureProbability?.CaptureProbability_ != null)
{
evt.Id = pokemon.PokemonId;
evt.Level = PokemonInfo.GetLevel(encounter.WildPokemon?.PokemonData);
evt.Cp = encounter.WildPokemon?.PokemonData?.Cp ?? 0;
evt.MaxCp = PokemonInfo.CalculateMaxCp(encounter.WildPokemon?.PokemonData);
evt.Perfection =
Math.Round(PokemonInfo.CalculatePokemonPerfection(encounter.WildPokemon?.PokemonData));
evt.Probability =
Math.Round(Convert.ToDouble(encounter.CaptureProbability?.CaptureProbability_.First())*100, 2);
evt.Distance = distance;
evt.Pokeball = pokeball;
evt.Attempt = attemptCounter;
machine.Fire(evt);
}
attemptCounter++;
Thread.Sleep(2000);
} while (caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchMissed ||
caughtPokemonResponse.Status == CatchPokemonResponse.Types.CatchStatus.CatchEscape);
}
private static void UseBerry(Context ctx, StateMachine machine, ulong encounterId, string spawnPointId)
{
var inventoryBalls = ctx.Inventory.GetItems().Result;
var berries = inventoryBalls.Where(p => p.ItemId == ItemId.ItemRazzBerry);
var berry = berries.FirstOrDefault();
if (berry == null || berry.Count <= 0)
return;
ctx.Client.Encounter.UseCaptureItem(encounterId, ItemId.ItemRazzBerry, spawnPointId).Wait();
berry.Count -= 1;
machine.Fire(new UseBerryEvent {Count = berry.Count});
Thread.Sleep(1500);
}
public static void Execute(Context ctx, StateMachine machine)
{
var distanceFromStart = LocationUtils.CalculateDistanceInMeters(
ctx.Settings.DefaultLatitude, ctx.Settings.DefaultLongitude,
ctx.Client.CurrentLatitude, ctx.Client.CurrentLongitude);
// Edge case for when the client somehow ends up outside the defined radius
if (ctx.LogicSettings.MaxTravelDistanceInMeters != 0 &&
distanceFromStart > ctx.LogicSettings.MaxTravelDistanceInMeters)
{
Logger.Write(
$"You're outside of your defined radius! Walking to start ({distanceFromStart}m away) in 5 seconds. Is your Coords.ini file correct?",
LogLevel.Warning);
Thread.Sleep(5000);
ctx.Navigation.HumanLikeWalking(
new GeoCoordinate(ctx.Settings.DefaultLatitude, ctx.Settings.DefaultLongitude),
ctx.LogicSettings.WalkingSpeedInKilometerPerHour, null).Wait();
}
var pokestopList = GetPokeStops(ctx);
var stopsHit = 0;
if (pokestopList.Count <= 0)
{
Logger.Write("No usable PokeStops found in your area. Is your maximum distance too small?",
LogLevel.Warning);
}
while (pokestopList.Any())
{
//resort
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
var distance = LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, pokeStop.Latitude, pokeStop.Longitude);
var fortInfo = ctx.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Result;
machine.Fire(new FortTargetEvent {Name = fortInfo.Name, Distance = distance});
ctx.Navigation.HumanLikeWalking(new GeoCoordinate(pokeStop.Latitude, pokeStop.Longitude),
ctx.LogicSettings.WalkingSpeedInKilometerPerHour,
() =>
{
CatchNearbyPokemonsTask.Execute(ctx, machine);
return true;
}).Wait();
var fortSearch = ctx.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Result;
if (fortSearch.ExperienceAwarded > 0)
{
machine.Fire(new FortUsedEvent
{
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded)
});
}
Thread.Sleep(1000);
if (++stopsHit%5 == 0) //TODO: OR item/pokemon bag is full
{
stopsHit = 0;
RenamePokemonTask.Execute(ctx, machine);
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.EvolveAllPokemonWithEnoughCandy || ctx.LogicSettings.EvolveAllPokemonAboveIv)
{
EvolvePokemonTask.Execute(ctx, machine);
}
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
}
}
}
public static void Execute(Context ctx, StateMachine machine)
{
var tracks = GetGpxTracks(ctx);
var curTrkPt = 0;
var curTrk = 0;
var maxTrk = tracks.Count - 1;
var curTrkSeg = 0;
while (curTrk <= maxTrk)
{
var track = tracks.ElementAt(curTrk);
var trackSegments = track.Segments;
var maxTrkSeg = trackSegments.Count - 1;
while (curTrkSeg <= maxTrkSeg)
{
var trackPoints = track.Segments.ElementAt(0).TrackPoints;
var maxTrkPt = trackPoints.Count - 1;
while (curTrkPt <= maxTrkPt)
{
var nextPoint = trackPoints.ElementAt(curTrkPt);
var distance = LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, Convert.ToDouble(nextPoint.Lat, CultureInfo.InvariantCulture),
Convert.ToDouble(nextPoint.Lon, CultureInfo.InvariantCulture));
if (distance > 5000)
{
machine.Fire(new ErrorEvent
{
Message =
$"Your desired destination of {nextPoint.Lat}, {nextPoint.Lon} is too far from your current position of {ctx.Client.CurrentLatitude}, {ctx.Client.CurrentLongitude}"
});
break;
}
var pokestopList = GetPokeStops(ctx);
while (pokestopList.Any())
{
pokestopList =
pokestopList.OrderBy(
i =>
LocationUtils.CalculateDistanceInMeters(ctx.Client.CurrentLatitude,
ctx.Client.CurrentLongitude, i.Latitude, i.Longitude)).ToList();
var pokeStop = pokestopList[0];
pokestopList.RemoveAt(0);
ctx.Client.Fort.GetFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Wait();
var fortSearch =
ctx.Client.Fort.SearchFort(pokeStop.Id, pokeStop.Latitude, pokeStop.Longitude).Result;
if (fortSearch.ExperienceAwarded > 0)
{
machine.Fire(new FortUsedEvent
{
Exp = fortSearch.ExperienceAwarded,
Gems = fortSearch.GemsAwarded,
Items = StringUtils.GetSummedFriendlyNameOfItemAwardList(fortSearch.ItemsAwarded)
});
}
Thread.Sleep(1000);
RecycleItemsTask.Execute(ctx, machine);
if (ctx.LogicSettings.TransferDuplicatePokemon)
{
TransferDuplicatePokemonTask.Execute(ctx, machine);
}
}
ctx.Navigation.HumanPathWalking(trackPoints.ElementAt(curTrkPt),
ctx.LogicSettings.WalkingSpeedInKilometerPerHour, () =>
{
CatchNearbyPokemonsTask.Execute(ctx, machine);
UseNearbyPokestopsTask.Execute(ctx, machine);
return true;
}
).Wait();
if (curTrkPt >= maxTrkPt)
curTrkPt = 0;
else
curTrkPt++;
} //end trkpts
if (curTrkSeg >= maxTrkSeg)
curTrkSeg = 0;
else
curTrkSeg++;
} //end trksegs
if (curTrk >= maxTrkSeg)
curTrk = 0;
else
curTrk++;
} //end tracks
}