public static void UnassignParentGroupForGroup(AnimalGroup group)
{
if (group.leader.parent.isPlayer)
{
foreach (AnimalGroup childGroup in group.childGroups)
{
AssignParentToGroup(group.leader.parent, childGroup);
}
group.childGroups.Clear();
}
else
{
group.parentGroup.childGroups.Remove(group);
foreach (AnimalGroup childGroup in group.childGroups)
{
AssignParentToGroup(group.leader.parent, childGroup);
}
}
group.leader.depth = 998;
foreach (Animal animal in group.herdAnimals)
{
animal.depth = 999;
}
group.leader.parent = null;
group.currentState = AnimalGroup.GroupState.Disenfranchised;
}
/// <summary>
/// Returns the valid fleece-free weight range associated with stock of a given
/// age etc, along with expected basal weight assuming that the current weight
///
/// is the highest weight reached so far(BWFA, or "base weight for age").
/// This is complicated in younger animals by the fact that a given condition
/// score may be relative to any of a range of normal weights.
/// </summary>
/// <param name="mainParams"></param>
/// <param name="BreedInfo"></param>
/// <param name="iGenotype"></param>
/// <param name="Repro"></param>
public void ValidFFWeightRange(AnimalParamSet mainParams,
SingleGenotypeInits[] BreedInfo,
int iGenotype,
GrazType.ReproType Repro,
int AgeDays,
double dLowBC, double dHighBC,
out double LowWt, out double HighWt)
{
GrazType.ReproType[] SexRepro = { GrazType.ReproType.Castrated, GrazType.ReproType.Empty };
int[] MatureMonths = { 24, 36 };
AnimalParamSet Genotype;
double MaxNormWt,
MinNormWt;
Genotype = stock.ParamsFromGenotypeInits(mainParams, BreedInfo, iGenotype);
MaxNormWt = AnimalGroup.GrowthCurve(AgeDays, Repro, Genotype);
if ((AgeDays < MatureAge[(int)Genotype.Animal]) && (dLowBC <= 1.0)) // Allow for the possibility of a sub-
{
MinNormWt = 0.7 * MaxNormWt; // optimal normal weight in young
}
else // animals
{
MinNormWt = MaxNormWt;
}
LowWt = MinNormWt * (dLowBC - 0.5 * BC_STEP);
HighWt = MaxNormWt * (dHighBC + 0.499 * BC_STEP);
if ((Repro == GrazType.ReproType.EarlyPreg) || (Repro == GrazType.ReproType.LatePreg)) // Allowance for conceptus in ewes & cows
{
HighWt = HighWt * 1.15;
}
}
protected override void PrepareInsertUpdateCommand(DbCommand command, AnimalGroup animalGroup)
{
SqlCommand sqlCommand = (SqlCommand)command;
sqlCommand.Parameters.Add("@p_id", SqlDbType.Int).Value = animalGroup.Id;
sqlCommand.Parameters.Add("@p_description", SqlDbType.VarChar).Value = animalGroup.Description;
}
public AnimalBasicInfo(string species, AnimalGroup group)
{
this.AvailableMedicines = new HashSet <Medicine>();
this.AssignedAnimals = new HashSet <Animal>();
this.Species = species;
this.Group = group;
}
private void CollectCandidates(Vector2 direction, AnimalGroup candidate, List <AnimalGroup> removeCandidates, Vector2 size)
{
var candidateId = candidate.Id.Data;
var nextCoord = candidate.Coord.Value;
var animals = GetEntities <AnimalGroup>();
var condition = Math.Abs(direction.x) > 0.001f
? new Func <Vector2, Vector2, bool>((coord, s) => coord.x >= 0 && coord.x < s.x)
: (coord, s) => coord.y >= 0 && coord.y < s.y;
nextCoord += direction;
bool breakOccured = false;
while (condition(nextCoord, size) && breakOccured == false)
{
foreach (var animal in animals)
{
if (animal.Coord.Value != nextCoord)
{
continue;
}
if (animal.Id.Data == candidateId)
{
removeCandidates.Add(animal);
}
else
{
breakOccured = true;
}
break;
}
nextCoord += direction;
}
}
public static void CollectInput(Farm farm, IGrazing animal)
{
foreach (GrazingField field in farm.GrazingFields)
{
if (field.Animals.Count < field.Capacity)
{
StringBuilder output = new StringBuilder();
output.Append($"{farm.GrazingFields.IndexOf(field)+1}. Grazing Field (");
if (field.Animals.Count == 0)
{
output.Append("0");
}
else
{
//group by
List <TypeCounter> animalCount = (
from ruminant in field.Animals
group ruminant by ruminant.Type into AnimalGroup
select new TypeCounter {
Type = AnimalGroup.Key,
Count = AnimalGroup.Count()
}
).ToList();
foreach (TypeCounter entry in animalCount)
{
// TODO: remove trailing comma
output.Append($"{entry.Count} {entry.Type},");
}
}
output.Append($" of {field.Capacity} animals)");
Console.WriteLine(output);
}
}
// STRETCH: realign numbers for facility listing when it skips full ones
// put available fields in a new temporary List<>? then foreach the list?
// use linq directives to pull available fields?
Console.WriteLine();
// How can I output the type of animal chosen here?
Console.WriteLine($"Place the animal where?");
Console.Write("> ");
int choice = Int32.Parse(Console.ReadLine());
try {
farm.GrazingFields[choice - 1].AddResource(farm, animal);
} catch (ArgumentOutOfRangeException) {
Console.WriteLine($"Invalid option: {choice}");
Console.WriteLine("Press any key to go back to main menu.");
Console.ReadLine();
}
/*
* Couldn't get this to work. Can you?
* Stretch goal. Only if the app is fully functional.
*/
// farm.PurchaseResource<IGrazing>(animal, choice);
}
void OnButtonClicked(object sender, EventArgs e)
{
GroupedAnimalsViewModel viewModel = BindingContext as GroupedAnimalsViewModel;
AnimalGroup group = viewModel.Animals.FirstOrDefault(a => a.Name == "Monkeys");
Animal monkey = group.FirstOrDefault(m => m.Name == "Proboscis Monkey");
collectionView.ScrollTo(monkey, group, (ScrollToPosition)enumPicker.SelectedItem, animateSwitch.IsToggled);
}
public static bool isGroup(this Animal animal, AnimalGroup groupNumber)
{
if ((AnimalGroup)animal == groupNumber)
{
return(true);
}
return(false);
}
protected override void PrepareInsertUpdateCommand(DbCommand command, AnimalGroup animalGroup)
{
OracleCommand oracleCommand = (OracleCommand)command;
oracleCommand.BindByName = true;
oracleCommand.Parameters.Add("p_id", OracleDbType.Int32).Value = animalGroup.Id;
oracleCommand.Parameters.Add("p_description", OracleDbType.Varchar2).Value = animalGroup.Description;
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
AnimalGroup animalGroup = await db.AnimalGroups.FindAsync(id);
db.AnimalGroups.Remove(animalGroup);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public static void AssignNearbyGroupsToPlayer(Animal player, List <GameObject> groups)
{
List <GameObject> nearbyIdle = NearbyGroups(player.transform.position, 7f, groups, AnimalGroup.GroupState.Idle);
foreach (GameObject groupObj in nearbyIdle)
{
AnimalGroup group = groupObj.GetComponent <AnimalGroup>();
AssignParentToGroup(player, group);
}
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Name")] AnimalGroup animalGroup)
{
if (ModelState.IsValid)
{
db.Entry(animalGroup).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(animalGroup));
}
public int Insert(AnimalGroup animalGroup)
{
db.Connect();
DbCommand command = db.CreateCommand(GetInsertSql());
PrepareInsertUpdateCommand(command, animalGroup);
int ret = db.ExecuteNonQuery(command);
db.Close();
return(ret);
}
public BreederStationDataLayer.Orm.Dto.AnimalGroup mapDomainToDtoObject(AnimalGroup animalGroup)
{
BreederStationDataLayer.Orm.Dto.AnimalGroup dtoAnimalGroup = new BreederStationDataLayer.Orm.Dto.AnimalGroup
{
Id = animalGroup.Id,
Description = animalGroup.Description,
AnimalsInfo = animalGroup.AnimalsInfo,
BreedersInfo = animalGroup.BreedersInfo
};
return(dtoAnimalGroup);
}
public static void FindParentsForIdleGroups(List <GameObject> groups)
{
foreach (GameObject groupObj in groups)
{
AnimalGroup group = groupObj.GetComponent <AnimalGroup>();
if (group.currentState == AnimalGroup.GroupState.Idle)
{
FindAFriend(group, groups);
}
}
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name")] AnimalGroup animalGroup)
{
if (ModelState.IsValid)
{
db.AnimalGroups.Add(animalGroup);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(animalGroup));
}
public AnimalGroup mapDtoToDomainObject(BreederStationDataLayer.Orm.Dto.AnimalGroup dtoAnimalGroup)
{
AnimalGroup aninalGroup = new AnimalGroup
{
Id = dtoAnimalGroup.Id,
Description = dtoAnimalGroup.Description,
AnimalsInfo = dtoAnimalGroup.AnimalsInfo,
BreedersInfo = dtoAnimalGroup.BreedersInfo
};
return(aninalGroup);
}
// GET: AnimalGroups/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AnimalGroup animalGroup = await db.AnimalGroups.FindAsync(id);
if (animalGroup == null)
{
return(HttpNotFound());
}
return(View(animalGroup));
}
public static void AssignParentToGroup(Animal parent, AnimalGroup group)
{
group.currentState = AnimalGroup.GroupState.Stampeding;
group.stateTimer = 600;
group.parentGroup = parent.group;
if (group.parentGroup)
{
group.parentGroup.childGroups.Add(group);
}
group.leader.parent = parent;
group.leader.depth = parent.depth + 1;
foreach (Animal animal in group.herdAnimals)
{
animal.depth = group.leader.depth + 1;
}
}
public static List <GameObject> NearbyGroups(Vector3 position, float radius, List <GameObject> groups, AnimalGroup.GroupState groupState)
{
List <GameObject> nearby = new List <GameObject>();
foreach (GameObject groupObj in groups)
{
AnimalGroup group = groupObj.GetComponent <AnimalGroup>();
if (group.currentState != groupState)
{
continue;
}
float distance = Vector3.Distance(position, group.leader.transform.position);
if (distance < radius)
{
nearby.Add(groupObj);
}
}
return(nearby);
}
public static void FindAFriend(AnimalGroup group, List <GameObject> groups)
{
List <GameObject> nearbyStampeding = NearbyGroups(group.leader.transform.position, 10f, groups, AnimalGroup.GroupState.Stampeding);
List <Animal> animals = new List <Animal>();
foreach (GameObject groupObj in nearbyStampeding)
{
AnimalGroup _group = groupObj.GetComponent <AnimalGroup>();
if (group == _group)
{
continue;
}
animals.AddRange(_group.herdAnimals);
}
if (animals.Count == 0)
{
return;
}
AssignParentToGroup(animals[Random.Range(0, animals.Count)], group);
}
/// <summary>
/// Populate metabolizable energy use array
/// Note: these are an* ME* partition
/// </summary>
/// <param name="model">The animal model</param>
/// <param name="energyValues">The energy use returned</param>
public static void MakeEnergyUse(StockList model, ref EnergyUse[] energyValues)
{
double ME_Metab;
double ME_MoveGraze;
int idx;
for (idx = 1; idx <= model.Count(); idx++)
{
AnimalGroup group = model.At(idx);
ME_Metab = group.AnimalState.EnergyUse.Metab / group.AnimalState.Efficiency.Maint;
ME_MoveGraze = group.AnimalState.EnergyUse.Maint - ME_Metab - group.AnimalState.EnergyUse.Cold;
energyValues[idx].MaintBase = ME_Metab;
energyValues[idx].MaintMoveGraze = ME_MoveGraze; // Separating E(graze) and E(move) requires work in AnimGRP.pas...
energyValues[idx].MaintCold = group.AnimalState.EnergyUse.Cold;
energyValues[idx].Conceptus = group.AnimalState.EnergyUse.Preg;
energyValues[idx].Lactation = group.AnimalState.EnergyUse.Lact;
energyValues[idx].Fleece = group.AnimalState.EnergyUse.Wool / group.AnimalState.Efficiency.Gain;
energyValues[idx].Gain = group.AnimalState.EnergyUse.Gain / group.AnimalState.Efficiency.Gain;
}
}
protected override IList <AnimalGroup> Read(DbDataReader reader, bool allInfo)
{
IList <AnimalGroup> animalGroups = new List <AnimalGroup>();
OracleDataReader oracleReader = (OracleDataReader)reader;
while (oracleReader.Read())
{
int i = -1;
AnimalGroup animalGroup = new AnimalGroup();
animalGroup.Id = oracleReader.GetInt32(++i);
animalGroup.Description = oracleReader.GetString(++i);
if (allInfo)
{
animalGroup.BreedersInfo = oracleReader.GetString(++i);
animalGroup.AnimalsInfo = oracleReader.GetString(++i);
}
animalGroups.Add(animalGroup);
}
return(animalGroups);
}
public AnimalGroup Select(int animalGroupId)
{
db.Connect();
DbCommand command = db.CreateCommand(GetSelectAllInfoByIdSql());
PrepareGroupIdCommand(command, animalGroupId);
DbDataReader reader = db.Select(command);
IList <AnimalGroup> animalGroups = Read(reader, true);
AnimalGroup animalGroup = new AnimalGroup();
if (animalGroups.Count != 0)
{
animalGroup = animalGroups[0];
}
reader.Close();
db.Close();
return(animalGroup);
}
public bool AddAnimalGroup(AnimalGroup animalGroup)
{
return(animalGroupGateway.Insert(mapDomainToDtoObject(animalGroup)) > 0);
}
public bool UpdateAnimalGroup(AnimalGroup animalGroup)
{
return(animalGroupGateway.Update(mapDomainToDtoObject(animalGroup)) > 0);
}
protected abstract void PrepareInsertUpdateCommand(DbCommand command, AnimalGroup animalGroup);
public static void AssignParentGroupToGroup(AnimalGroup parentGroup, AnimalGroup group)
{
Animal newParent = parentGroup.herdAnimals[Random.Range(0, parentGroup.herdAnimals.Count)];
AssignParentToGroup(newParent, group);
}
