public void Submit(Adaptation.BodySlot bodyType)
{
exPanel.ActivateEvoPanel();
if (currentSlotType != bodyType)
{
if (bodyType == Adaptation.BodySlot.BODY)
{
tree.SetPanelStateBODY();
}
else if (bodyType == Adaptation.BodySlot.HEAD)
{
tree.SetPanelStateHEAD();
}
else if (bodyType == Adaptation.BodySlot.LIMBS)
{
tree.SetPanelStateLIMBS();
}
else if (bodyType == Adaptation.BodySlot.TAIL)
{
tree.SetPanelStateTAIL();
}
currentSlotType = bodyType;
}
mainPanel.Deactivate();
}
public void ToBuffer(ref TSMessagePackWriter writer)
{
writer.WriteByte(SyncByte);
//TransportErrorIndicator PayloadUnitStartIndicator TransportPriority PID
//0 1 0 0000 0000 0000 0
//writer.WriteUInt16((ushort)((0b_0100_0000_0000_0000 & (PayloadUnitStartIndicator<<14)) | PID));
writer.WriteUInt16((ushort)((TransportErrorIndicator << 15) | (PayloadUnitStartIndicator << 14) | PID));
writer.WriteByte((byte)((byte)AdaptationFieldControl | ContinuityCounter));
if (PackageType == PackageType.PAT ||
PackageType == PackageType.PMT ||
PackageType == PackageType.Data_Start ||
PackageType == PackageType.Data_End ||
PackageType == PackageType.SDT)
{
if (Adaptation != null)
{
writer.Skip(1, out int AdaptationLengthPosition);
Adaptation.ToBuffer(ref writer);
writer.WriteByteReturn((byte)(writer.GetCurrentPosition() - AdaptationLengthPosition - 1), AdaptationLengthPosition);
}
else
{
writer.WriteByte(0);
}
}
}
public string Post()
{
DBConnect conn = new DBConnect();
try
{
Adaptation show = conn.GetShow().Find(Show => Show.Id == int.Parse(Request.Form["showId"]));
Season season = new Season(-5, show, Request.Form["title"]);
if (Request.Form.ContainsKey("id"))
{
season.Id = int.Parse(Request.Form["id"]);
}
if (Request.Form.ContainsKey("originalTitle"))
{
season.OriginalTitle = Request.Form["originalTitle"];
}
if (Request.Form.ContainsKey("description"))
{
season.Description = Request.Form["description"];
}
conn.AddSeason(season);
}
catch (Exception exception)
{
return(exception.Message);
}
return("OK");
}
public void Activate(Critter critter, Adaptation.BodySlot newType)
{
gameObject.SetActive(true);
InitializeSlots(critter, newType);
PopulatePanel();
}
public void Activate(Adaptation newEvo)
{
text = GetComponentInChildren<Text>();
evo = newEvo;
value = evo.cost;
text.text = value + "";
}
public void Activate(Adaptation evo)
{
if (evo != selectedEvo)
{
gameObject.SetActive(true);
PopulateInfo(evo);
}
}
public IResult Update(Adaptation adaptation)
{
if (adaptation.HizmetinGecKurum == null)
{
return(new ErrorResult(Messages.UpdateNegative));
}
_adaptationDal.Update(adaptation);
return(new SuccessResult(Messages.UpdatePositive));
}
public IResult Add(Adaptation adaptation)
{
if (adaptation.HizmetinGecKurum == null)
{
return(new ErrorDataResult <Adaptation>(Messages.Error));
}
_adaptationDal.Add(adaptation);
return(new SuccessResult(Messages.AddPositive));
}
public void Activate(Adaptation evo, Adaptation.BodySlot newType)
{
Initialize();
evoButton = evo.GetEvoButton().GetComponent<AdaptationButton>();
Icon.sprite = evo.GetIcon();
Icon.color = new Color32(255, 255, 255, 255);
Background.color = evoButton.GetHexColor();
}
public void Initialize(Critter owner, int index, Adaptation.BodySlot type)
{
critter = owner;
number = index;
slotType = type;
if(index == 0){
isActive = true;
}
else{
isActive = false;
}
}
public void Deactivate()
{
if (!SimpleInfo)
{
selectedEvo = null;
if (!SimpleInfo) {
bobbleCounter.DeactivateBobbles();
}
}
gameObject.SetActive(false);
}
public string Post()
{
DBConnect conn = new DBConnect();
try
{
Adaptation adaptation = new Adaptation(-5, Request.Form["title"], "");
if (Request.Form.ContainsKey("id"))
{
adaptation.Id = int.Parse(Request.Form["id"]);
}
if (Request.Form.ContainsKey("originalTitle"))
{
adaptation.OriginalTitle = Request.Form["originalTitle"];
}
if (Request.Form.ContainsKey("description"))
{
adaptation.Description = Request.Form["description"];
}
if (Request.Form.ContainsKey("franchiseId"))
{
adaptation.Franchise = conn.GetFranchise().Find(Franchise => Franchise.Id == int.Parse(Request.Form["franchiseId"]));
}
if (Request.Form.ContainsKey("genre"))
{
// Array will be converted in string
// name;name;...
string genres = Request.Form["genre"];
string[] genreArr = genres.Split(';');
List <Genre> genreList = new List <Genre>();
foreach (var genre in genreArr)
{
genreList.Add(new Genre(genre));
}
adaptation.Genre = genreList;
}
conn.AddAdaptation(adaptation);
}
catch (Exception exception)
{
return(exception.Message);
}
return("OK");
}
public void InitializeSlots(Critter newCritter, Adaptation.BodySlot type)
{
SlotData[] allSlots = newCritter.GetSlots().ToArray();
currentSlotType = type;
slots = new SlotData[3];
foreach (SlotData item in allSlots)
{
if (item.GetSlotType() == type)
{
slots[item.GetNumber()] = item;
}
}
}
private void BuildIcons(Adaptation evo)
{
boonIcons = evo.GetBoonSprites();
baneIcons = evo.GetBaneSprites();
boonColors = evo.GetBoonColors();
baneColors = evo.GetBaneColors();
if (evo.isMajor)
{
spcIcon = evo.GetSpecialSprite();
spcColor = evo.GetSpecialColor();
restrictIcon = evo.GetRestictionSprite();
restictColor = evo.GetRestrictColor();
}
}
public void PopulateSlot()
{
slot = player.GetCritter().GetSpecificSlot(type, index);
if(!slot.GetEvo()){
activeEvo = null;
Icon.sprite = null;
Icon.color = new Color32(255, 255, 255, 0);
}
else{
activeEvo = slot.GetEvo();
Icon.sprite = slot.GetEvo().GetIcon();
Icon.color = new Color32(255, 255, 255, 255);
}
}
public void EquipSlot(Adaptation newEvo)
{
if(isActive){
if (newEvo.slot == slotType)
{
if (evo)
{
evo.Unequip(critter, this);
}
evo = newEvo;
critter.equipedEvos.Add(evo);
isFilled = true;
}
}
}
public void CheckState(Adaptation startEvo, Adaptation endEvo)
{
Adaptation.playerBuyState startState = startEvo.GetCurrentBuyState();
Adaptation.playerBuyState endState = endEvo.GetCurrentBuyState();
if(startState == Adaptation.playerBuyState.UNLOCKED){
currentState = Adaptation.playerBuyState.LOCKED;
}
else{
currentState = endState;
}
SetColor(currentState);
}
public void Activate(Adaptation evo)
{
header = GetComponentInChildren<Text>();
ClearLists();
targetEvo = evo;
if (targetEvo)
{
header.text = targetEvo.name;
BuildIcons(targetEvo);
SetIconImages(targetEvo);
}
}
public void GenerateLine(GameObject end, GameObject start)
{
startEvo = start;
endEvo = end;
Vector3 dif = startEvo.transform.localPosition - endEvo.transform.localPosition;
gameObject.transform.localPosition = startEvo.transform.localPosition;
transform.rotation = Quaternion.LookRotation(Vector3.forward, dif);
float hyp = Mathf.Sqrt(dif.x * dif.x + dif.y * dif.y);
gameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(10, hyp);
startAdaptation = start.GetComponent<AdaptationButton>().GetAdaptation();
endAdaptation = end.GetComponent<AdaptationButton>().GetAdaptation();
CheckState(startAdaptation, endAdaptation);
}
public string Get(int id)
{
DBConnect conn = new DBConnect();
List <Adaptation> showList = conn.GetShow();
Adaptation s = null;
foreach (var show in showList)
{
if (show.Id == id)
{
s = show;
}
}
string output = JsonConvert.SerializeObject(s);
return(output);
}
public static void PopulateTraitPanel()
{
activeEvo = EvoDescriptionPanel.GetSelectedEvo();
if (activeEvo)
{
Adaptation.BodySlot slot = activeEvo.slot;
PopulateSlots(slot);
if (activeSlot) {
if (activeSlot.activeEvo) {
slotEvo = activeSlot.activeEvo;
}
else
{
slotEvo = null;
}
}
else
{
slotEvo = null;
}
SlotCheck();
if (traitDetails && slotEvo)
{
if (activeEvo.isMajor)
{
if (!traitDetails.gameObject.activeInHierarchy)
{
traitDetails.Activate(slotEvo);
}
traitDetails.PopulateInfo(slotEvo);
}
else
{
traitDetails.Deactivate();
}
}
}
}
public void SetSlotType(Adaptation.BodySlot newtype)
{
type = newtype;
AssignSlot();
if (!slot.GetIsActive())
{
Deactivate();
}
else if (slot.GetIsActive())
{
if (!isActive)
{
Activate();
}
}
PopulateSlot();
}
//Runs preview to observe changes that will result from buy/equipping viewed adaptation
public void PreviewChanges(Adaptation testEvo)
{
lockState lockLoco = lockState.NONE;
lockState lockRest = lockState.NONE;
if (TraitsPanel.GetSelectedSlot())
{
equippedEvo = TraitsPanel.GetSelectedSlot().activeEvo;
}
else
{
equippedEvo = null;
}
lockLoco = LocoLock(testEvo, equippedEvo);
lockRest = RestrictionLock(CalculateNewRestrictions(critter, testEvo, equippedEvo).ToArray());
//print(testEvo.name + ": RestrictionLock = " + lockRest + "\r\n");
SetLocks(lockLoco, lockRest);
}
private void SetColor(Adaptation.playerBuyState newState)
{
sprites = GetComponentsInChildren<Image>();
Image spriteLight = sprites[1];
if(newState == Adaptation.playerBuyState.LOCKED){
spriteLight.color = lockedLineColor;
}
else if(newState == Adaptation.playerBuyState.UNLOCKED){
spriteLight.color = unlockedLineColor;
}
else if(newState == Adaptation.playerBuyState.ACTIVE){
spriteLight.color = activeLineColor;
}
else if(newState == Adaptation.playerBuyState.NOREFUND){
spriteLight.color = disabledColor;
}
else if(newState == Adaptation.playerBuyState.CANEQUIP){
spriteLight.color = activeLineColor;
}
else if(newState == Adaptation.playerBuyState.EQUIPED){
spriteLight.color = activeLineColor;
}
}
float EvoSurvivalCheck(Adaptation evo)
{
float score = 0;
int biome;
int climate;
int geo;
int temp;
foreach(Hex habitat in habitats){
biome = (int)habitat.GetBiome();
climate = (int)habitat.GetClimate();
geo = (int)habitat.GetGeography();
temp = (int)habitat.GetTemp();
foreach(Adaptation.BiomeAdaptition item in evo.BiomeBoons){
if(item == ((Adaptation.BiomeAdaptition)biome)){
score++;
}
}
foreach(Adaptation.BiomeAdaptition item in evo.BiomeBanes){
if(item == ((Adaptation.BiomeAdaptition)biome)){
score--;
}
}
foreach(Adaptation.ClimateAdaptation item in evo.ClimateBoons){
if(item == ((Adaptation.ClimateAdaptation)climate)){
score++;
}
}
foreach(Adaptation.ClimateAdaptation item in evo.ClimateBanes){
if(item == ((Adaptation.ClimateAdaptation)climate)){
score--;
}
}
foreach(Adaptation.GeoAdaptation item in evo.GeoBoons){
if(item == ((Adaptation.GeoAdaptation)geo)){
score++;
}
}
foreach(Adaptation.GeoAdaptation item in evo.GeoBanes){
if(item == ((Adaptation.GeoAdaptation)geo)){
score--;
}
}
foreach(Adaptation.TempAdaptation item in evo.TempBoons){
if(item == ((Adaptation.TempAdaptation)temp)){
score++;
}
}
foreach(Adaptation.TempAdaptation item in evo.TempBanes){
if(item == ((Adaptation.TempAdaptation)temp)){
score--;
}
}
}
score /= 4;
score /= habitats.Count;
if (score > 1)
{
score = 1;
}
return score;
}
public ActionResult AdaptationAdd(Adaptation adaptation)
{
_adaptationService.Add(adaptation);
return(RedirectToAction(""));
}
public override bool Find(IMap map, IHeuristic heuristic)
{
if (Mutate == null || Crossover == null || Fitness == null || Selection == null)
{
throw new System.Exception("GA cant run without all operators");
}
if (Fitness.Heuristic == null)
{
Fitness.Heuristic = heuristic;
}
var Adaptation = new Adaptation(map);
var rand = RandomFactory.Rand;
var startNode = map.StartNode;
var endNode = map.EndNode;
for (int i = 0; i < PopulationSize; i++)
{
Populations.Add(new Genome(map));
}
CalcFitness();
var step = 0;
OnStart(BuildArgs(step, map));
for (int i = 0; i < GenerationLimit; i++)
{
var newpopulations = new List <IGenome>();
Populations = Populations.OrderBy(o => o.Fitness).ToList();
for (int j = 0; j < BestSolutionToPick; j++)
{
Populations[j].Fitness = Fitness.Calc(Populations[j]);
newpopulations.Add(Populations[j]);
}
var ran = rand.Next(1, Populations.Count);
var best = Populations.First().ListNodes;
var best2 = Selection.Select(Populations).ListNodes;
endNode = best.Last();
if (endNode.Equals(map.EndNode))
{
endNode.Direction = DirectionMovement.None;
map.EndNode = endNode;
map.UpdateClosedList(new List <Node>());
map.UpdateOpenList(new List <Node>());
//if (!best.First().Equals(map.StartNode))
OnEnd(BuildArgs(step, map, true));
Generations = i;
return(true);
}
map.UpdateClosedList(best);
map.UpdateOpenList(best2);
while (newpopulations.Count < Populations.Count)
{
// Selection
var nodemom = Selection.Select(Populations);
var nodedad = Selection.Select(Populations);
// CrossOver
var cross = Crossover.Calc(new CrossoverOperation(nodemom, nodedad));
//if (!cross.Mom.ListNodes.First().Equals(map.StartNode)) { }
//if (!cross.Dad.ListNodes.First().Equals(map.StartNode)) { }
// Mutation
nodemom = Mutate.Calc(cross.Mom);
nodedad = Mutate.Calc(cross.Dad);
//if (!nodemom.ListNodes.First().Equals(map.StartNode)) { }
//if (!nodedad.ListNodes.First().Equals(map.StartNode)) { }
// Adaptation
nodemom = Adaptation.Calc(nodemom);
nodedad = Adaptation.Calc(nodedad);
nodemom.Fitness = Fitness.Calc(nodemom);
nodedad.Fitness = Fitness.Calc(nodedad);
//if (!nodemom.ListNodes.First().Equals(map.StartNode)) { }
//if (!nodedad.ListNodes.First().Equals(map.StartNode)) { }
// Add in new population
newpopulations.Add(nodemom);
newpopulations.Add(nodedad);
}
Populations = newpopulations.ToList();
OnStep(BuildArgs(step++, map));
}
Generations = GenerationLimit;
OnEnd(BuildArgs(step, map, false));
return(false);
}
public List <Event> ICSStringToEventsObj(string _icalString, Adaptation adaptation)
{
var _separator = "";
if (_icalString.Contains("\r\n"))
{
_separator = "\r\n";
}
else
{
_separator = "\r";
}
var _lines = _icalString.Split(_separator).ToList();
var _events = new List <Event>();
bool _newEvent = false;
var _tempEvent = new Event();
_lines.ForEach(x =>
{
if (x == "BEGIN:VEVENT")
{
_newEvent = true;
_tempEvent = new Event();
}
if (x == "END:VEVENT")
{
_newEvent = false;
if (adaptation == Adaptation.C_Trace_De)
{
var _splitEvent = _tempEvent.Name.Split("/");
_splitEvent.ToList().ForEach(y =>
{
var _newTempEvent = new Event()
{
Name = y.Trim(),
Start = _tempEvent.Start
};
_events.Add(_newTempEvent);
});
}
else
{
_events.Add(_tempEvent);
}
}
if (_newEvent)
{
if (x.StartsWith("DTSTART"))
{
_tempEvent.Start = DateTime.ParseExact(x.Split(":")[1], "yyyyMMdd", CultureInfo.InvariantCulture);
}
else if (x.StartsWith("SUMMARY"))
{
_tempEvent.Name = x.Split(":")[1];
if (adaptation == Adaptation.C_Trace_De)
{
_tempEvent.Name = x.Split(":")[2];
}
}
}
});
return(_events);
}
public void DecreaseGeoPref(Adaptation.GeoAdaptation geo)
{
if (geo == Adaptation.GeoAdaptation.SaltWater) { geoPref[0] -= 1; }
if (geo == Adaptation.GeoAdaptation.Islands) { geoPref[1] -= 1; }
if (geo == Adaptation.GeoAdaptation.Flat) { geoPref[2] -= 1; }
if (geo == Adaptation.GeoAdaptation.Hills) { geoPref[3] -= 1; }
if (geo == Adaptation.GeoAdaptation.Mountains) { geoPref[4] -= 1; }
}
public void DecreaseBiomePref(Adaptation.BiomeAdaptition biome)
{
biomePref[(int)biome] -= 1;
}
public IResult Delete(Adaptation adaptation)
{
throw new NotImplementedException();
}
//Adds a lead for each special effect in 'specials' List<T>
public void AddLeads(Adaptation leadHolder)
{
foreach (Adaptation.specialEffect item in leadHolder.specials)
{
AddLead(item);
}
leads.TrimExcess();
}
//Populates leads to all prerequisite adaptations to indicate that they will telegraph this abilitiy.
public void TelegraphLeads(Adaptation mother, int rounds)
{
rounds -= 1;
foreach (Adaptation item in Prerequisites1)
{
item.AddLeads(mother);
if (rounds >= 0)
{
item.TelegraphLeads(mother, rounds);
}
}
foreach (Adaptation item in Prerequisites2)
{
item.AddLeads(mother);
if (rounds >= 0)
{
item.TelegraphLeads(mother, rounds);
}
}
}
private void Evolve()
{
if (!nextEvo)
{
if(unlockedEvos.Count > 0){
DetermineNextEvo(DetermineNextEvoType());
}
else{nextEvo = null;}
}
else if (nextEvo)
{
if (evoPts >= nextEvo.cost)
{
nextEvo.BuyEvo(this);
unlockedEvos.TrimExcess();
nextEvo = null;
if(unlockedEvos.Count > 0){
DetermineNextEvo(DetermineNextEvoType());
}
}
}
tokenDensity = (200 / gameControl.tokenDensity) * size;
}
private Adaptation DetermineNextEvo(Adaptation.Type type)
{
Adaptation.BodySlot[] openSlots = GetOpenSlotsTypes();
NextEvoOptions.Clear();
NextEvoOptions.TrimExcess();
foreach (Adaptation item in unlockedEvos)
{
if (item.type == type)
{
if (item.isMajor)
{
if (item.PositiveEquipCheck(this))
{
NextEvoOptions.Add(item);
NextEvoOptions.Add(item);
}
else if (openSlots.Length > 0)
{
for (int i = 0; i < openSlots.Length; i++)
{
if (openSlots[i] == item.slot)
{
NextEvoOptions.Add(item);
NextEvoOptions.Add(item);
}
}
}
}
else
{
NextEvoOptions.Add(item);
}
}
}
if (NextEvoOptions.Count > 0)
{
nextEvo = FinalizeNextEvo(type, NextEvoOptions);
}
else{ nextEvo = null;}
NextEvoOptions.Clear();
NextEvoOptions.TrimExcess();
return nextEvo;
}
public void UnequipSpecials(Adaptation evo)
{
GenerateDiet();
GenerateLocomotion();
}
public ActionResult AdaptationUpdate(Adaptation adaptation)
{
_adaptationService.Update(adaptation);
return(RedirectToAction(""));
}
//Adds lead if not already in the 'leads' List<T>
private void AddLead(Adaptation.specialEffect newLead)
{
if (!leads.Contains(newLead))
{
leads.Add(newLead);
}
}
private Adaptation FinalizeNextEvo(Adaptation.Type type, List<Adaptation> options)
{
Adaptation evo;
int evoIndex;
if(type == Adaptation.Type.SURVIVAL){
evo = PickSurvivalEvo(options);
}
else if (type == Adaptation.Type.DIET)
{
evo = PickFeedingEvo(options);
}
else if (type == Adaptation.Type.HUNTING)
{
evo = PickFeedingEvo(options);
}
else if (type == Adaptation.Type.MOBILITY)
{
evo = PickLocomotionEvo(options);
}
else
{
evoIndex = Random.Range(0, options.Count);
evo = options[evoIndex];
}
return evo;
}
private void AddSlot(Adaptation.BodySlot slotType)
{
int index = 0;
SlotData newSlot = new SlotData();
foreach(SlotData item in slots){
if(item.GetSlotType() == slotType){
index++;
}
}
if(index < 3){
newSlot.Initialize(this, index, slotType);
slots.Add(newSlot);
slots.TrimExcess();
}
}
public void DeactivateSlot(Adaptation.BodySlot slotType)
{
for(int i = slots.Count - 1; i >= 0; i--){
if(slots[i].GetSlotType() == slotType){
if(slots[i].GetIsActive() == true){
SlotData targetSlot = slots[i];
if(targetSlot.GetIsFilled())
{
Adaptation evo = targetSlot.GetEvo();
if (evo) {
evo.Unequip(this, targetSlot);
}
}
targetSlot.Deactivate();
break;
}
}
}
}
