public void Update(Climber climber)
{
if (climber.Nickname != null)
{
this.Nickname = climber.Nickname;
}
}
public void AnalysedClimbersInRankOrder_GivenPriorRankings_ShouldReturnCorrectDelta()
{
// Arrange.
Climber[] climbers =
{
Climber.Create("Climber1", new[] { Route.Create("C1R1") }, null),
Climber.Create("Climber2", new[] { Route.Create("C2R1"), Route.Create("C2R2")}, null)
};
var priorAnalysisForClimber = Substitute.For <IClimberAnalysis>();
priorAnalysisForClimber.Climber.Name.Returns("Climber2");
priorAnalysisForClimber.Rank.Returns(2);
var priorAnalyses = new[]
{
priorAnalysisForClimber
};
// Act.
var testObject = new Scoreboard(climbers, priorAnalyses);
// Assert.
Assert.AreEqual(1, testObject.AnalysedClimbersInRankOrder[0].RankDelta);
}
public void RankingByClimber_GivenClimbersWithSameRouteCount_ShouldRankByRouteCount()
{
// Arrange.
var route1 = Route.Create("Route1");
var route2 = Route.Create("Route1");
var climberWith1Route = Climber.Create("Name1", new [] { route1 }, null);
var climberWith2Routes1 = Climber.Create("Name2", new [] { route1, route2 }, null);
var climberWith2Routes2 = Climber.Create("Name3", new [] { route1, route2 }, null);
var climbers = new List <Climber>
{
climberWith1Route,
climberWith2Routes1,
climberWith2Routes2
};
var testObject = new ClimberRanker(climbers);
// Act.
var result = testObject.RankingByClimber;
// Assert.
Assert.NotNull(result);
Assert.AreEqual(1, result[climberWith2Routes1]);
Assert.AreEqual(1, result[climberWith2Routes2]);
Assert.AreEqual(3, result[climberWith1Route]);
}
public void RankingByClimber_GivenClimbersWithOverrideScoreboardPosition_ShouldRankByOverrideAndThenRouteCount()
{
// Arrange.
var route1 = Route.Create("Route1");
var route2 = Route.Create("Route2");
var route3 = Route.Create("Route3");
var climberWith1Route = Climber.Create("Name1", new [] { route1 }, null);
var climberWith3Routes = Climber.Create("Name2", new [] { route1, route2, route3 }, 1);
var climberWith2Routes = Climber.Create("Name3", new [] { route1, route2 }, null);
var climbers = new List <Climber>
{
climberWith1Route,
climberWith3Routes,
climberWith2Routes
};
var testObject = new ClimberRanker(climbers);
// Act.
var result = testObject.RankingByClimber;
// Assert.
Assert.NotNull(result);
Assert.AreEqual(1, result[climberWith3Routes]);
Assert.AreEqual(2, result[climberWith2Routes]);
Assert.AreEqual(3, result[climberWith1Route]);
}
void updateHand(Climber Hand)
{
if (climbing && Hand == ActiveHand)
{
if (ToggleGripButton.GetStateUp(Hand.Hand))
{
CliberHandle.connectedBody = null;
climbing = false;
GetComponent <Rigidbody>().useGravity = true;
}
}
else
{
if (ToggleGripButton.GetStateDown(Hand.Hand) || Hand.grabbing)
{
Hand.grabbing = true;
if (Hand.TouchedCount > 0)
{
ActiveHand = Hand;
climbing = true;
CliberHandle.transform.position = Hand.transform.position;
GetComponent <Rigidbody>().useGravity = false;
CliberHandle.connectedBody = GetComponent <Rigidbody>();
Hand.grabbing = false;
}
}
}
}
public IActionResult UpdateComplete(long id, [FromBody] Climber requestClimber)
{
if (requestClimber == null || !requestClimber.Id.Equals(id))
{
return(BadRequest());
}
if (!requestClimber.IsComplete())
{
return(BadRequest());
}
Climber climber = this._context.Climbers.FirstOrDefault <Climber>(c => c.Id.Equals(id));
if (climber == null)
{
return(NotFound());
}
climber.Update(requestClimber);
this._context.Update(climber);
this._context.SaveChanges();
return(new NoContentResult());
}
// Start is called before the first frame update
void Start()
{
climber = GetComponent <Climber>();
rb = GetComponent <Rigidbody2D>();
towerMask = LayerMask.GetMask("Tower");
}
public void OnTriggerEnter(Collider other)
{
Climber climbing = other.gameObject.GetComponent <Climber>();
if (climbing)
{
climbing.AddClimbable(this);
}
}
public void AddClimber(Climber climber)
{
if (climber == null)
{
throw new ArgumentNullException(nameof(climber));
}
climber.Id = Guid.NewGuid();
_context.Climbers.Add(climber);
}
public IActionResult GetById(long id)
{
Climber climber = this._context.Climbers.FirstOrDefault <Climber>(c => c.Id.Equals(id));
if (climber == null)
{
return(NotFound());
}
return(new ObjectResult(climber));
}
public IActionResult Create([FromBody] Climber climber)
{
if (climber == null)
{
return(BadRequest());
}
this._context.Climbers.Add(climber);
this._context.SaveChanges();
return(CreatedAtRoute("[controller]GetById", new { id = climber.Id }, climber));
}
public void EndFitnessTest()
{
float score = GetFitnessScore(currentClimber);
Logger.Add("[" + currentPopulationIndex + "] fitness: " + score.ToString("0.00"));
isRunningFitnessTest = false;
currentClimber.Genetics.FitnessScore = score;
Destroy(currentClimber.transform.parent.gameObject);
currentClimber = null;
currentClimberObj = null;
currentPopulationIndex++;
}
public void GrabLadder(GameObject attemptedToGrab)
{
Debug.Log("Grabbed Ladder" + attemptedToGrab.GetComponent <Rigidbody2D>().velocity);
attemptedToGrab.GetComponent <Rigidbody2D>().velocity = Vector2.zero;
Climber tempClimb = new Climber(attemptedToGrab, attemptedToGrab.GetComponent <EntityMovement>().climbPoint.position);
//Debug.Log(attemptedToGrab + "attempted to grab ladder");
myClimbers.Add(tempClimb);
attemptedToGrab.GetComponent <Rigidbody2D>().gravityScale = 0;
attemptedToGrab.GetComponent <EntityMovement>().myClimber = tempClimb;
attemptedToGrab.GetComponent <EntityMovement>().isClimbing = true;
}
public void ClimbDown(Climber myClimber)
{
//Debug.Log(myClimber.climberPoint.y + " " + ladderBotEnd.position.y + " " + ladderTopEnd.position.y);
if (myClimber.climberPoint.y <= ladderTop && myClimber.climberPoint.y >= ladderBot)
{
//myClimber.climbObject.GetComponent<Rigidbody2D>().position = new Vector2(transform.position.x, myClimber.climbObject.transform.position.y);
}
else if (myClimber.climberPoint.y < ladderBot)
{
LetGoLadder(myClimber.climbObject);
}
myClimber.climberPoint = myClimber.climbObject.GetComponent <EntityMovement>().climbPoint.position;
}
private float GetFitnessScore(Climber climber)
{
return(climber.MaxY);
/*
* float climbScore = Mathf.Pow(climber.ClimbAmount * 10f, 1.2f);
* float nonGrabTimeScore = Mathf.Pow(climber.NonGrabTime * 10f, 1.2f);
* float maxYScore = Mathf.Pow(climber.MaxY, 2.5f);
* float score = climbScore + nonGrabTimeScore + maxYScore;
*
* highestFitness = Mathf.Max(highestFitness, score);
* return score;*/
}
public IActionResult Delete(long id)
{
Climber climber = this._context.Climbers.FirstOrDefault <Climber>(c => c.Id.Equals(id));
if (climber == null)
{
return(NotFound());
}
this._context.Climbers.Remove(climber);
this._context.SaveChanges();
return(new NoContentResult());
}
public void TrivialTest()
{
// Arrange
var user = new Climber()
{
FirstName = "Andy", Email = "*****@*****.**"
};
// Act
user.FirstName = "Changed";
//Assert
Assert.Equal("Changed", user.FirstName);
}
private void StartFitnessTest()
{
GameObject climberObj;
Climber climber;
ClimberGenetics genetics = population[currentPopulationIndex];
BodyShapeGene bodyShapeGene = (BodyShapeGene)genetics.Chromosome[0];
isRunningFitnessTest = true;
climberObj = Instantiate <GameObject>(ClimberPrefab);
climberObj.transform.parent = objectsContainer;
climberObj.transform.position = SpawnPosition - new Vector3(0f, bodyShapeGene.Height * 0.5f, 0f);
climber = climberObj.GetComponentInChildren <Climber>();
climber.Genetics = genetics;
currentClimber = climber;
currentClimberObj = climberObj;
}
IEnumerator DoMarketing()
{
// Prepare Dangler
GrapplingHook ghook = GameObject.Find("Dangle").GetComponent <GrapplingHook>();
ghook.DisableVisuals();
ghook.AimHook(1, Vector2.up);
ghook.ThrowHook(1);
ActivatePlayerGroup(GameObject.Find("StunPlayers"));
ActivatePlayerGroup(GameObject.Find("StartingPlayers"));
yield return(new WaitForSeconds(2.5f));
yield return(StartCoroutine(AdvanceCamera()));
ActivatePlayerGroup(GameObject.Find("GoldPlayers"));
yield return(new WaitForSeconds(3f));
yield return(StartCoroutine(AdvanceCamera()));
ActivatePlayerGroup(GameObject.Find("SpikePlayers"));
yield return(new WaitForSeconds(3.5f));
ActivatePlayerGroup(GameObject.Find("ClimbingPlayer"));
Climber climber = GameObject.Find("ClimbingPlayer/Player2D").GetComponent <Climber>();
climber.StartClimb();
yield return(StartCoroutine(AdvanceCamera()));
yield return(new WaitForSeconds(3f));
yield return(StartCoroutine(AdvanceCamera()));
yield return(new WaitForSeconds(0.5f));
ghook = GameObject.Find("StunPlayers/Player2D").GetComponent <GrapplingHook>();
ghook.DisableVisuals();
ghook.AimHook(1, new Vector2(1f, 0.25f));
ghook.ThrowHook(1);
yield return(new WaitForSeconds(2f));
yield return(StartCoroutine(AdvanceCamera()));
}
void Start()
{
cheatmode = FindObjectOfType <HotAirBalloon>();
viewer = FindObjectOfType <CameraMovement>().transform;
sidewaysSpeed = new AxisSpeed("X", 1, SpeedBuildup, SpeedFalloff);
forwardSpeed = new AxisSpeed("Y", 1, SpeedBuildup, SpeedFalloff);
directions = new List <AxisSpeed>();
directions.Add(sidewaysSpeed);
directions.Add(forwardSpeed);
rb = GetComponent <Rigidbody>();
c = GetComponent <Climber>();
g = GetComponentInChildren <GroundChecker>();
}
public void Create_GivenNoName_ShouldReturnNull()
{
// Arrange.
const string name = null;
Route[] routes =
{
Route.Create("Route1"),
Route.Create("Route2")
};
// Act.
Climber climber = Climber.Create(name, routes, null);
// Assert.
Assert.Null(climber);
}
public void SaveToClipboard(int minX)
{
// adjust startX and HomeX, without going outside of the screen
int shiftedStartX = StartX - minX;
if (shiftedStartX < 0)
{
shiftedStartX = 0;
}
int shiftedHomeX = HomeX - minX;
if (shiftedHomeX < 0)
{
shiftedHomeX = 0;
}
// start the string with the declaration of the map
string text = "\t{ // -------- LEVEL -----------" + GetEOL();
text += "\t\t" + shiftedStartX.ToString() + ", //StartX" + GetEOL();
text += "\t\t" + StartY.ToString() + ", //StartY" + GetEOL();
text += "\t\t" + shiftedHomeX.ToString() + ", //HomeX" + GetEOL();
text += "\t\t" + HomeY.ToString() + ", //HomeY" + GetEOL();
text += "\t\t" + m_TotalTimeIn10thSec.ToString() + ", //Time In Multiple Of 10 seconds" + GetEOL();
text += "\t\t" + m_SpawnLemCount.ToString() + ", //Available Lem Count in multiple of 5 (from 0 to 15 max!!)" + GetEOL();
text += "\t\t" + m_RequiredLemCount.ToString() + ", //RequiredLemCount in multiple of 5 (obviously less or equals than the previous number)" + GetEOL();
text += "\t\t" + MinDropSpeed.ToString() + ", //Min Drop Speed in rough seconds (more precisely in multiple of 27 frames) (from 0 to 15) (high value = slow)" + GetEOL();
text += "\t\t" + Walker.ToString() + ", //Nb of available Walker" + GetEOL();
text += "\t\t" + Blocker.ToString() + ", //Nb of available Blocker" + GetEOL();
text += "\t\t" + Bomber.ToString() + ", //Nb of available Bomber" + GetEOL();
text += "\t\t" + DiagDigger.ToString() + ", //Nb of available Diagonal Digger" + GetEOL();
text += "\t\t" + HorizDigger.ToString() + ", //Nb of available Horizontal Digger" + GetEOL();
text += "\t\t" + VertDigger.ToString() + ", //Nb of available Vertical Digger" + GetEOL();
text += "\t\t" + Stairer.ToString() + ", //Nb of available Stair Builder" + GetEOL();
text += "\t\t" + Climber.ToString() + ", //Nb of available Climber" + GetEOL();
text += "\t\t" + Parachuter.ToString() + ", //Nb of available Parachuter" + GetEOL();
text += "\t\t(const unsigned char *)" + m_LocaMapName + ", //SpriteLocalization" + GetEOL();
text += "\t\tsizeof(" + m_LocaMapName + "), //size of the Map in number of sprite columns" + GetEOL();
text += "\t\t(const unsigned int *)" + m_MapIdsName + " //SpriteIdList" + GetEOL();
text += "\t}," + GetEOL();
// copy the text to the clipboard
Clipboard.SetText(text);
}
public void RouteCount_GivenClimberWith3Routes_ShouldReturnReturn3()
{
// Arrange.
const string name = "Name123";
Route[] routes =
{
Route.Create("Route1"),
Route.Create("Route2"),
Route.Create("Route3")
};
// Act.
Climber climber = Climber.Create(name, routes, null);
// Assert.
Assert.AreEqual(routes.Length, climber.RouteCount);
}
public void AnalysedClimbersInRankOrder_GivenClimberWithOverrideScoreboardPositionValue_ShouldRankClimbersByRouteCountDescending()
{
// Arrange.
Climber[] climbers =
{
Climber.Create("Climber1", new[] { Route.Create("C1R1") }, null),
Climber.Create("Climber2", new[] { Route.Create("C2R1"), Route.Create("C2R2")}, 1),
Climber.Create("Climber3", new[] { Route.Create("C3R1"), Route.Create("C3R2"), Route.Create("C3R3")}, null)
};
// Act.
var testObject = new Scoreboard(climbers, null);
// Assert.
IClimberAnalysis firstClimberAnalysis = testObject.AnalysedClimbersInRankOrder.First();
Assert.AreEqual("Climber2", firstClimberAnalysis.Climber.Name);
}
public void AnalysedClimbersInRankOrder_GivenNoPriorRankings_ShouldReturnCorrectDelta()
{
// Arrange.
Climber[] climbers =
{
Climber.Create("Climber1", new[] { Route.Create("C1R1") }, null),
Climber.Create("Climber2", new[] { Route.Create("C2R1"), Route.Create("C2R2")}, null)
};
var priorAnalyses = new ClimberAnalysis[0];
// Act.
var testObject1 = new Scoreboard(climbers, priorAnalyses);
var testObject2 = new Scoreboard(climbers, null);
// Assert.
Assert.AreEqual(0, testObject1.AnalysedClimbersInRankOrder[0].RankDelta);
Assert.AreEqual(0, testObject2.AnalysedClimbersInRankOrder[0].RankDelta);
}
public void GradedRoutes_GivenRoutes_ShouldReturnOnlyGradedRoutes()
{
// Arrange.
const string name = "Name123";
Route[] routes =
{
Route.Create("Route1 (10)"),
Route.Create("Route2"),
Route.Create("Route3 (F3)")
};
// Act.
Climber climber = Climber.Create(name, routes, null);
// Assert.
Assert.True(climber.GradedRoutes.Any(r => r.Name == "Route1"));
Assert.True(climber.GradedRoutes.Any(r => r.Name == "Route3"));
Assert.False(climber.GradedRoutes.Any(r => r.Name == "Route2"));
}
public void Create_GivenValidData_ShouldReturnNewClimber()
{
// Arrange.
const string name = "Name123";
Route[] routes =
{
Route.Create("Route1"),
Route.Create("Route2")
};
// Act.
Climber climber = Climber.Create(name, routes, null);
// Assert.
Assert.NotNull(climber);
Assert.AreEqual(name, climber.Name);
Assert.AreEqual(routes[0], climber.Routes.First());
Assert.AreEqual(routes[1], climber.Routes.Last());
}
void Start()
{
rb2D = GetComponent <Rigidbody2D>();
if (config == null)
{
Debug.Log("<color=red>Entity Movement has no config!</color>");
}
else
{
currentDirection = config.Direction;
if (config.ClimbDownStairs)
{
climber = GetComponent <Climber>();
}
if (config.MovesInitially)
{
StartMoving();
}
}
}
public void AnalysedClimbersInRankOrder_GivenInputModel_ShouldRankClimbersByRouteCountDescending()
{
// Arrange.
Climber[] climbers =
{
Climber.Create("Climber1", new[] { Route.Create("C1R1") }, null),
Climber.Create("Climber2", new[] { Route.Create("C2R1"), Route.Create("C2R2")}, null),
Climber.Create("Climber3", new[] { Route.Create("C3R1"), Route.Create("C3R2"), Route.Create("C3R3")}, null)
};
// Act.
var testObject = new Scoreboard(climbers, null);
// Assert.
IClimberAnalysis firstClimberAnalysis = testObject.AnalysedClimbersInRankOrder.First();
IClimberAnalysis lastClimberAnalysis = testObject.AnalysedClimbersInRankOrder.Last();
Assert.AreEqual("Climber3", firstClimberAnalysis.Climber.Name);
Assert.AreEqual("Climber1", lastClimberAnalysis.Climber.Name);
Assert.AreEqual(3, firstClimberAnalysis.Climber.RouteCount);
Assert.AreEqual(1, lastClimberAnalysis.Climber.RouteCount);
}
Climber ProcessLicense(Person person, Team team)
{
if (person.ClimbersLicenses == null)
{
person.ClimbersLicenses = new List <Climber>();
}
var license = person.ClimbersLicenses.FirstOrDefault(l => l.TeamId == team.Iid);
if (license != null)
{
return(license);
}
person.ClimbersLicenses.Add(license = new Climber(Context)
{
CompetitionAppearances = new List <ClimberTeamOnCompetition>(),
Person = person,
PersonId = person.Iid,
Team = team,
TeamId = team.Iid
});
Context.SaveChanges();
return(Context.Climbers.First(l => l.Iid == license.Iid));
}
