public void UnblockGrave(Gravestone grave)
{
if (blockedGraves.Contains(grave))
{
blockedGraves.Remove(grave);
}
}
private void PlaceDownOffering()
{
if (_gravesCollider.GravesInCollider.Count > 0)
{
List <Gravestone> nearGraves = _gravesCollider.GravesInCollider;
float Distance = Vector2.Distance(playerRB.position, nearGraves[0].transform.position);
Gravestone closestGrave = nearGraves[0];
foreach (Gravestone grave in nearGraves)
{
if (!grave.currentOffering)
{
if (Vector2.Distance(playerRB.position, grave.transform.position) < Distance)
{
Distance = Vector2.Distance(playerRB.position, grave.transform.position);
closestGrave = grave;
}
}
}
if (!closestGrave.currentOffering)
{
Offering offering = collectedOfferings[0]; //take the first offering off our list
offering.gameObject.SetActive(true); //reenable this offering
offering.transform.position = closestGrave.OfferingPos.transform.position; //and move it our graves offering position
_placeDownSound.Play();
closestGrave.RaiseHappiness(offering.HealAmount); //heal our grave
offering.FadeAway(closestGrave); //slowly fade it away
collectedOfferings.RemoveAt(0); //remove the offering from our list
Events.current.PlaceDownOffering(offering);
LevelSceneManager.instance.timeSinceLastMiscPrompt = 0f;
}
}
}
public void UnblockGravestone(Gravestone grave)
{
if (GravestoneUnblocked != null)
{
GravestoneUnblocked(grave);
}
}
//GRAVESTONE STUFF
private bool FindNearestGravestone() //sets the reference to the nearest gravestone
{
bool undestroyedGraveAvailable = false; //checks to see if we all gravestones have been destroyed or not
float Distance = 100;
foreach (Gravestone grave in allPossibleGravestones) //check all possible gravestones
{
if (!grave._destroyed && !grave.IsBeingTargeted && !blockedGraves.Contains(grave)) //as long as the grave we are looking at isnt destroyed and not focused by another robber
{
if (Vector2.Distance(grave.transform.position, robberRB.transform.position) <= Distance) //..and the distance is closer than the last grave we checked
{
nearestGrave = grave; //override our nearest grave
positionToSeekOut = nearestGrave.gameObject;
Distance = Vector2.Distance(grave.transform.position, robberRB.transform.position);
}
undestroyedGraveAvailable = true; //change the value so we know we can actually find a new gravestone
}
}
if (undestroyedGraveAvailable) //only if we exited the previous loop having found a grave...
{
nearestGrave.IsBeingTargeted = true; //attack that grave, so others cant
UpdatePath(positionToSeekOut); //update our path to this gravestone
}
return(undestroyedGraveAvailable); //return wether or not undestroyed gravestones are actually available
}
private void UnblockGrave(Gravestone grave)
{
blockedGraves.Remove(grave);
foreach (GameObject robber in _graveRobbers)
{
robber.GetComponent <GraveRobber>().UnblockGrave(grave);
}
}
/// <summary>
/// Sets up each grave with a class and part type and adds text to the gravestone
/// </summary>
private void Setup()
{
int counter = 0;
int _knightCounter = 0;
int _bersCounter = 0;
int _thiefCounter = 0;
foreach (GameObject go in m_graveSpots)
{
Grave _grave = go.GetComponentInChildren <Grave>();
Gravestone _gravestone = go.GetComponentInChildren <Gravestone>();
int _idx = UnityEngine.Random.Range(0, Enum.GetValues(typeof(Part_Type)).Length);
Part_Type _pt = (Part_Type)_idx;
int idx = UnityEngine.Random.Range(0, Enum.GetValues(typeof(Class_Type)).Length);
Class_Type _ct = (Class_Type)idx;
switch (_ct)
{
case Class_Type.berserker:
_bersCounter++;
counter = _bersCounter;
break;
case Class_Type.knight:
_knightCounter++;
counter = _knightCounter;
break;
case Class_Type.thief:
_thiefCounter++;
counter = _thiefCounter;
break;
}
///Debug
// _ct = Class_Type.knight;
///Set text on grave
string _ctName = _ct.ToString();
string query = $"(//*[@id='FriendlyUnits']//*[@id='{_ctName}']//*[@id='GraveText'])[{counter}]";
string graveText = XMLManager.Instance.ReadSingleNodeData(query);
if (graveText == null)
{
Debug.LogError("text not found for: " + _ctName + " dummy text set.");
graveText = "Dummy Text for: " + _ctName;
}
_gravestone.SetCanvasText(graveText);
///Add body part to grave
_grave.SetBodyPart(_pt, _ct);
}
}
private IEnumerator PlayFadeAnimation(Gravestone grave)
{
for (int i = 0; i < FadeAnimation.Length; i++)
{
sprRend.sprite = FadeAnimation[i];
yield return(new WaitForSeconds(0.5f));
}
grave.currentOffering = null;
Destroy(gameObject);
}
private void BlockGrave(Gravestone grave)
{
blockedGraves.Add(grave);
if (_graveRobbers is object)
{
foreach (GameObject robber in _graveRobbers)
{
robber.GetComponent <GraveRobber>().BlockGrave(grave);
}
}
}
public void BlockGrave(Gravestone grave)
{
if (!blockedGraves.Contains(grave))
{
blockedGraves.Add(grave);
}
if (nearestGrave.Equals(grave))
{
nearestGrave.StopAttackingGrave();
nearestGrave = null;
isDigging = false;
animator.SetBool("Digging", false);
StopAllCoroutines();
FindNearestGravestone();
}
}
private void OnTriggerEnter2D(Collider2D other)
{
// Pega referencias
GameObject otherObject = other.gameObject;
Defender defender = other.GetComponent <Defender>();
Gravestone gravestone = other.GetComponent <Gravestone>();
// Define de acordo com tipo de defensor
if (gravestone)
{
animator.SetTrigger("jumpTrigger");
}
else if (defender)
{
attacker.Attack(otherObject);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
GameObject otherObject = collision.gameObject;
Gravestone graveston = otherObject.GetComponent <Gravestone>();
if (graveston)
{
animator.SetTrigger("IsJumping");
}
Defender defender = otherObject.GetComponent <Defender>();
if (!graveston)
{
attacker.Attack(otherObject, defender);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
GameObject otherObject = collision.gameObject;
Gravestone gravestone = otherObject.GetComponent <Gravestone>();
if (gravestone)
{
GetComponent <Animator>().SetTrigger(ANIMATOR_VAR_JUMP);
return;
}
Defender defender = otherObject.GetComponent <Defender>();
if (defender)
{
GetComponent <Attacker>().Attack(otherObject);
}
}
public void onMouseDown(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
for (int i = 0; i < 0x0F; i++)
{
Gravestone en = scene.ow.graves[i];
if (e.X >= en.xTilePos && e.X < en.xTilePos + 32 && e.Y >= en.yTilePos && e.Y < en.yTilePos + 32)
{
if (scene.mouse_down == false)
{
selectedGrave = en;
lastselectedGrave = en;
//scene.Invalidate(new Rectangle(scene.mainForm.panel5.HorizontalScroll.Value, scene.mainForm.panel5.VerticalScroll.Value, scene.mainForm.panel5.Width, scene.mainForm.panel5.Height));
scene.mouse_down = true;
}
}
}
}
}
private void OnTriggerEnter2D(Collider2D othercollider)
{
GameObject otherObject = othercollider.gameObject;
Defender defender = otherObject.GetComponent <Defender>();
if (defender)
{
Attacker attacker = GetComponent <Attacker>();
attacker.Attack(otherObject);
}
Gravestone gravestone = otherObject.GetComponent <Gravestone>();
if (gravestone)
{
GetComponent <Animator>().SetTrigger("jumpTrigger");
GetComponent <Animator>().SetBool("IsAttacking", false);
}
}
public void Draw(Graphics g)
{
int transparency = 200;
Pen bgrBrush = new Pen(Color.FromArgb(transparency, 222, 16, 145));
g.CompositingMode = CompositingMode.SourceOver;
for (int i = 0; i < scene.ow.graves.Length; i++)
{
Gravestone e = scene.ow.graves[i];
if (selectedGrave != null)
{
if (e == selectedGrave)
{
bgrBrush = new Pen(Color.FromArgb((int)transparency, 14, 224, 146));
//scene.drawText(g, e.xTilePos + 8, e.yTilePos + 8, "ID : " + i.ToString("X2"));
}
else
{
bgrBrush = new Pen(Color.FromArgb((int)transparency, 222, 16, 145));
}
}
g.DrawRectangle(bgrBrush, new Rectangle(e.xTilePos, e.yTilePos, 32, 32));
scene.drawText(g, e.xTilePos + 8, e.yTilePos + 8, i.ToString("X2"));
//scene.drawText(g, e.xTilePos + 8, e.yTilePos + 40, e.tilemapPos.ToString("X4"));
if (i == 0x0D) //stairs
{
scene.drawText(g, e.xTilePos + 8, e.yTilePos + 16, "SPECIAL STAIRS");
}
if (i == 0x0E) //hole
{
scene.drawText(g, e.xTilePos + 8, e.yTilePos + 16, "SPECIAL HOLE");
}
}
}
public void onMouseUp(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
if (selectedGrave != null)
{
if (scene.mapHover >= 64)
{
scene.mapHover -= 64;
}
int mx = (scene.mapHover - ((scene.mapHover / 8) * 8));
int my = ((scene.mapHover / 8));
byte xx = (byte)((selectedGrave.xTilePos - (mx * 512)) / 16);
byte yy = (byte)((selectedGrave.yTilePos - (my * 512)) / 16);
selectedGrave.tilemapPos = (ushort)((((yy) << 6) | (xx & 0x3F)) << 1);
lastselectedGrave = selectedGrave;
selectedGrave = null;
scene.mouse_down = false;
}
}
}
public void CorruptDate(string raw) => Assert.ThrowsAnyAsync <Exception>(() => Gravestone.ParseAsync(raw));
public void FadeAway(Gravestone grave)
{
grave.currentOffering = this;
disappearing = true;
StartCoroutine(PlayFadeAnimation(grave));
}
/// <summary>
/// Get formatted message for corresponding announcement.
/// </summary>
/// <param name="type">Announcement type.</param>
/// <param name="gravestone">Corresponding <see cref="Gravestone"/>.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="type"/> is not a valid type.</exception>
public static string FormatMessage(AnnouncementType type, Gravestone gravestone)
=> type switch
{
public Task CorrectGravestone(string raw) => Gravestone.ParseAsync(raw);
public async Task UnknownDeceasedType(string raw)
{
var gravestone = await Gravestone.ParseAsync(raw);
Assert.Equal(DeceasedType.Other, gravestone.DeceasedType);
}
