public DiscScript GetDiscFromPool(DiscType discType)
{
if (allDiscPools.ContainsKey(discType))
{
DiscScript newDisc = null;
if (allDiscPools[discType].Count > 0)
{
newDisc = allDiscPools[discType].Dequeue();
newDisc.gameObject.SetActive(true);
}
else
{
newDisc = Instantiate(discTypeToPrefab[discType], discTypeToPoolParent[discType]);
newDisc.SetUpModifiers();
newDisc.SetDiscType(discType);
newDisc.gameObject.SetActive(true);
}
inGameDiscs.Add(newDisc);
return(newDisc);
}
return(null);
}
public void UpdateUnityBoard()
{
foreach (Move m in movesFlipped)
{
string discName = m.Row + "," + m.Col;
GameObject disc = GameObject.Find(discName);
if (!disc)
{
continue;
}
DiscScript discScript = disc.GetComponent <DiscScript>();
// backwards because issues with putting this in other functions due to recursion of minmax
// can't place after setUpforNewTurn, so it will always be opposite
if (Settings.currentPlayer == Settings.ComputerName)
{
discScript.Flip(DiscScript.PieceColor.BLACK);
}
else
{
discScript.Flip(DiscScript.PieceColor.WHITE);
}
}
movesFlipped = new ArrayList();
}
public void DestroyDisc(DiscScript disc)
{
if (throwedDiscs.Contains(disc))
{
//FxManager.Instance.CreateFx(FxType.discDestroyed, disc.transform.position);
throwedDiscs.Remove(disc);
}
ReturnDiscInPool(disc);
}
public void CheckForLootedDisc()
{
if (_lootedDiscType != DiscType.None)
{
DiscScript newDisc = DiscManager.Instance.GetDiscFromPool(_lootedDiscType);
if (newDisc != null)
{
newDisc.transform.position = transform.position;
}
}
}
public static List <DiscScript> GetSortedInRangeDiscs(int numberOfDiscsToRecall, DiscsOrder discsRecallOrder, bool canRecallUnthrowedDiscs, List <DiscScript> throwedDiscs, List <DiscScript> inRangeDiscs)
{
List <DiscScript> finalList = new List <DiscScript>();
int remainingNumberOfDiscsToRecall = numberOfDiscsToRecall;
bool recallAll = remainingNumberOfDiscsToRecall == 0;
int currentDiscIndex = (discsRecallOrder == DiscsOrder.FromNewestToOldest ? throwedDiscs.Count - 1 : 0);
while ((recallAll || remainingNumberOfDiscsToRecall > 0) && throwedDiscs.Count > 0)
{
DiscScript currentDisc = throwedDiscs[currentDiscIndex];
if (!inRangeDiscs.Contains(currentDisc))
{
currentDiscIndex += (discsRecallOrder == DiscsOrder.FromNewestToOldest ? -1 : 1);
if (currentDiscIndex < 0 || currentDiscIndex >= throwedDiscs.Count)
{
break;
}
continue;
}
finalList.Add(currentDisc);
currentDiscIndex += (discsRecallOrder == DiscsOrder.FromNewestToOldest ? -1 : 1);
remainingNumberOfDiscsToRecall--;
if (currentDiscIndex < 0 || currentDiscIndex >= throwedDiscs.Count)
{
break;
}
}
if ((remainingNumberOfDiscsToRecall > 0 || recallAll) && canRecallUnthrowedDiscs)
{
foreach (DiscScript disc in inRangeDiscs)
{
if (throwedDiscs.Contains(disc))
{
continue;
}
finalList.Add(disc);
remainingNumberOfDiscsToRecall--;
if (remainingNumberOfDiscsToRecall == 0)
{
break;
}
}
}
return(finalList);
}
public void RemoveDiscFromInUse(DiscScript disc)
{
if (currentlyInUseDiscs.Contains(disc))
{
currentlyInUseDiscs.Remove(disc);
}
if (currentlyInUseDiscs.Count == 0)
{
EndCompetenceUsability();
}
}
private void OnTriggerEnter(Collider other)
{
if (knockbackReceiptionSystem.IsBeingKnockbacked || moving)
{
if (other.gameObject.layer == 11)
{
DiscScript hitDisc = other.GetComponent <DiscScript>();
if (hitDisc != null)
{
hitDisc.RetreiveByPlayer();
}
}
}
}
public void StartRecallDisc(DiscScript disc)
{
DiscTrajectoryParameters trajectoryParameters =
DiscTrajectoryFactory.GetTrajectory(recallCompetence,
disc.transform.position, _player.transform.position,
DiscManager.Instance.GetAllThrowedDiscs, DiscManager.Instance.GetInRangeDiscs, disc);
disc.SetIsBeingRecalled(true);
disc.StartTrajectory(trajectoryParameters, null);
currentlyInUseDiscs.Add(disc);
disc.OnTrajectoryStopped += RemoveDiscFromInUse;
OnSpecialLaunch?.Invoke();
}
public void StartThrowPreparation()
{
aboutToThrowDisc = DiscManager.Instance.PeekNextThrowDisc();
Vector3 trueTargetPosition = GetInRangeThrowTargetPosition(currentWorldMouseResult.mouseWorldPosition);
//Vector3 trueTargetPosition = GetInRangeThrowTargetPosition(GameManager.Instance.GetDebugPos);
DiscTrajectoryParameters trajectoryParameters =
DiscTrajectoryFactory.GetTrajectory(throwCompetence, _player.transform.position, trueTargetPosition,
DiscManager.Instance.GetAllThrowedDiscs, DiscManager.Instance.GetInRangeDiscs, aboutToThrowDisc);
Dictionary <DiscScript, DiscTrajectoryParameters> trajectories = new Dictionary <DiscScript, DiscTrajectoryParameters>();
trajectories.Add(aboutToThrowDisc, trajectoryParameters);
PreviewCompetencesManager.Instance.StartThrowPreview(trajectories, _player.transform.position);
PreviewCompetencesManager.Instance.UpdateThrowPreview(trajectories);
}
public void ReturnDiscInPool(DiscScript disc)
{
DiscType discType = disc.GetDiscType;
disc.gameObject.SetActive(false);
inGameDiscs.Remove(disc);
if (allDiscPools.ContainsKey(discType))
{
allDiscPools[discType].Enqueue(disc);
}
else
{
Destroy(disc.gameObject);
}
}
public void PlayerRetreiveDisc(DiscScript retreivedDisc)
{
SoundManager.Instance.PlaySound(Sound.RecallDisc, player.transform.position);
throwedDiscs.Remove(retreivedDisc);
ReturnDiscInPool(retreivedDisc);
if (possessedDiscs.Count < maxNumberOfPossessedDiscs)
{
possessedDiscs.Push(retreivedDisc.GetDiscType);
OnDiscAdded?.Invoke(retreivedDisc);
OnDiscUpdate?.Invoke(possessedDiscs);
}
else
{
DiscType retreivedDiscType = retreivedDisc.GetDiscType;
DiscOverload(retreivedDiscType);
//Debug.Log("TOO MUCH DISCS, NOT ADDED BUT SUPPOSED TO BE SOMETHING");
}
GameManager.Instance.CheckForCompetencesUsability();
}
public DiscScript TakeFirstDiscFromPossessedDiscs()
{
if (possessedDiscs.Count == 0)
{
return(null);
}
DiscType newDiscType = possessedDiscs.Pop();
DiscScript newDisc = GetDiscFromPool(newDiscType);
if (newDisc != null)
{
throwedDiscs.Add(newDisc);
OnDiscConsommed?.Invoke();
OnDiscUpdate?.Invoke(possessedDiscs);
SoundManager.Instance.PlaySound(Sound.ThrowDisc, newDisc.transform.position);
FxManager.Instance.CreateFxThrow(FxType.discThrow, player.GetThrowSocket, player.transform.rotation);
}
return(newDisc);
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.layer == 11 && !haveDisc && isPlaying)
{
DiscScript touchedDisc = other.GetComponent <DiscScript>();
if (touchedDisc != null)
{
if (!touchedDisc.isAttacking)
{
FxManager.Instance.CreateFx(FxType.discDestroyed, touchedDisc.transform.position);
Debug.Log("Test !!!");
myAnimator.SetBool("Walking", false);
myAnimator.SetBool("DestroyingDisc", true);
animationEventContainer.SetEvent2(EndDestroyDisc);
DiscManager.Instance.DestroyDisc(touchedDisc);
playingDiscDestroyAnimation = true;
haveDisc = true;
}
}
}
}
public void LaunchThrowCompetenceForReal()
{
currentlyInUseDiscs = new List <DiscScript>();
DiscScript newDisc = DiscManager.Instance.TakeFirstDiscFromPossessedDiscs();
if (newDisc == null)
{
//Debug.LogWarning("NO DISK TO THROW");
return;
}
DiscTrajectoryParameters trajectoryParameters =
DiscTrajectoryFactory.GetTrajectory(throwCompetence,
_player.transform.position, GetInRangeThrowTargetPosition(currentThrowPosition),
DiscManager.Instance.GetAllThrowedDiscs, DiscManager.Instance.GetInRangeDiscs, newDisc);
newDisc.SetIsBeingRecalled(false);
newDisc.SetRetreivableByPlayer(false);
newDisc.StartTrajectory(trajectoryParameters, currentObjLauncher);
currentlyInUseDiscs.Add(newDisc);
newDisc.OnTrajectoryStopped += RemoveDiscFromInUse;
newDisc.OnReachedTrajectoryEnd += RemoveDiscFromInUse;
}
void Refresh(Stack <DiscType> _allDisc)
{
if (_allDisc.Count == 0)
{
discIconHolder.transform.parent.gameObject.SetActive(false);
return;
}
else
{
discIconHolder.transform.parent.gameObject.SetActive(true);
}
foreach (DiscElement discElement in AllDiscElement)
{
discElement.transform.parent.gameObject.SetActive(false);
}
int i = 0;
foreach (DiscType discType in _allDisc)
{
DiscScript peekedDisc = DiscManager.Instance.PeekDiscFromPool(discType);
if (i >= AllDiscElement.Count)
{
break;
}
DiscElement de = AllDiscElement[i];
de.SetIcon((int)discType, peekedDisc.GetCurrentDamage);
AllDiscElement[i].transform.parent.gameObject.SetActive(true);
i++;
}
}
public void SetUpPools()
{
allDiscPools = new Dictionary <DiscType, Queue <DiscScript> >();
discTypeToPrefab = new Dictionary <DiscType, DiscScript>();
discTypeToPoolParent = new Dictionary <DiscType, Transform>();
DiscScript newDisc = null;
Queue <DiscScript> newDiscQueue = new Queue <DiscScript>();
Transform newPoolParent = null;
foreach (DiscPoolParameters discPoolParameters in allDiscPoolParameters)
{
if (!allDiscPools.ContainsKey(discPoolParameters.discType))
{
newPoolParent = new GameObject().transform;
newPoolParent.SetParent(poolsParent);
newPoolParent.name = discPoolParameters.discType + "DiscsPool";
newPoolParent.transform.localPosition = new Vector3();
discTypeToPrefab.Add(discPoolParameters.discType, discPoolParameters.discPrefab);
discTypeToPoolParent.Add(discPoolParameters.discType, newPoolParent);
newDiscQueue = new Queue <DiscScript>();
for (int i = 0; i < discPoolParameters.baseNumberOfElements; i++)
{
newDisc = Instantiate(discPoolParameters.discPrefab, newPoolParent);
newDisc.SetUpModifiers();
newDisc.gameObject.SetActive(false);
newDisc.SetDiscType(discPoolParameters.discType);
newDiscQueue.Enqueue(newDisc);
}
allDiscPools.Add(discPoolParameters.discType, newDiscQueue);
}
}
}
public DiscScript PeekDiscFromPool(DiscType discType)
{
if (allDiscPools.ContainsKey(discType))
{
DiscScript peekedDisc = null;
if (allDiscPools[discType].Count > 0)
{
peekedDisc = allDiscPools[discType].Peek();
}
else
{
peekedDisc = Instantiate(discTypeToPrefab[discType], discTypeToPoolParent[discType]);
peekedDisc.SetUpModifiers();
peekedDisc.SetDiscType(discType);
peekedDisc.gameObject.SetActive(false);
allDiscPools[discType].Enqueue(peekedDisc);
}
return(peekedDisc);
}
return(null);
}
void AddNewDisc(DiscScript newDisc)
{
Stack <DiscType> allDisc = DiscManager.Instance.GetPossessedDiscs;
Refresh(allDisc);
}
public static DiscTrajectoryParameters GetTrajectory(CompetenceDisc competence, Vector3 startPosition, Vector3 targetPosition, List <DiscScript> throwedDiscs, List <DiscScript> inRangeDiscs, DiscScript currentDisc)
{
DiscTrajectoryParameters discTrajectoryParameters = new DiscTrajectoryParameters();
discTrajectoryParameters.disc = currentDisc;
List <Vector3> trajectoryPositions = new List <Vector3>();
Vector3 totalDirection = (targetPosition - startPosition).normalized;
List <TrajectoryModifier> trajectoryModifiers = competence.GetTrajectoryModifiers;
DiscsOrder linkedDiscsTrajectory = DiscsOrder.None;
TrajectoryModifierCurved curvedModifier = null;
foreach (TrajectoryModifier modifier in trajectoryModifiers)
{
if (linkedDiscsTrajectory == DiscsOrder.None)
{
TrajectoryModifierLinkedDiscs linkedDiscModifier = modifier as TrajectoryModifierLinkedDiscs;
if (linkedDiscModifier != null)
{
linkedDiscsTrajectory = linkedDiscModifier.GetLinkedDiscTrajectoryType;
}
}
if (curvedModifier == null)
{
TrajectoryModifierCurved foundCurvedModifier = modifier as TrajectoryModifierCurved;
if (foundCurvedModifier != null)
{
curvedModifier = foundCurvedModifier;
}
}
}
trajectoryPositions.Add(startPosition);
#region Discs Link
switch (linkedDiscsTrajectory)
{
case DiscsOrder.FromOldestToNewest:
for (int i = 0; i < throwedDiscs.Count; i++)
{
DiscScript linkDisc = throwedDiscs[i];
if (linkDisc != currentDisc)
{
if (inRangeDiscs.Contains(linkDisc))
{
trajectoryPositions.Add(linkDisc.transform.position);
}
}
}
break;
case DiscsOrder.FromNewestToOldest:
for (int i = throwedDiscs.Count - 1; i >= 0; i--)
{
DiscScript linkDisc = throwedDiscs[i];
if (linkDisc != currentDisc)
{
if (inRangeDiscs.Contains(linkDisc))
{
trajectoryPositions.Add(linkDisc.transform.position);
}
}
}
break;
}
#endregion
#region
if (curvedModifier != null)
{
trajectoryPositions.Add(targetPosition);
List <Vector3> curvedTrajectoryPositions = new List <Vector3>();
for (int i = 0; i < trajectoryPositions.Count - 1; i++)
{
curvedTrajectoryPositions.Add(trajectoryPositions[i]);
AddCurvedTrajectoryBetweenTwoPoints(ref curvedTrajectoryPositions, trajectoryPositions[i], trajectoryPositions[i + 1], curvedModifier);
}
trajectoryPositions = curvedTrajectoryPositions;
}
#endregion
trajectoryPositions.Add(targetPosition);
discTrajectoryParameters.trajectoryPositions = trajectoryPositions;
return(discTrajectoryParameters);
}
