void TileEffects(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin, TileClass _currentTile, BattlefieldScript _bfs)
{
switch (tileEffect)
{
case (TileEffect.Broken):
{
//_currentTile.tileEffect = tileEffect;
_currentTile.CheckEffect(tileEffect);
//_properties.cardHolder.RemoveFirst();
break;
}
case (TileEffect.Steal):
{
_currentTile.ChangeAlignment(_bfs.standardColours[0], TileAlignment.Friendly);
//_properties.cardHolder.RemoveFirst();
break;
}
}
}
void SpawnMiniature(SpellCard _spellCard, bool _loadAdvancedSpell = false, int offset = 0)
{
GameObject _spawnedMiniature = objectPooler.SpawnFromPool("CombatMiniature", Vector3.zero, Quaternion.identity, playerScript.playerCanvas.transform);
_spawnedMiniature.transform.localPosition = Vector3.forward * (offset * 0.01f);
_spawnedMiniature.transform.localRotation = Quaternion.Euler(Vector3.zero);
SpellVisuals _spawnedMiniatureSpell = _spawnedMiniature.GetComponent <SpellVisuals>();
CombatMiniatureProperties _miniatureProperties = _spawnedMiniature.GetComponent <CombatMiniatureProperties>();
_spawnedMiniature.GetComponent <SpriteRenderer>().sprite = null;
//Load combat spell visuals and logic
if (_loadAdvancedSpell == false)
{
_spawnedMiniatureSpell.spell = _spellCard;
_spawnedMiniatureSpell.LoadSpell(_spellCard);
combatMenu.MoveCardToDestination(_spellCard, CardDestination.Hand, CardDestination.Combat);
}
else
{
SpellCard _tempAdvancedSpell = _spellCard.advancedSpellComponents[0].advancedSpell;
_spawnedMiniatureSpell.spell = _tempAdvancedSpell;
_spawnedMiniatureSpell.LoadSpell(_tempAdvancedSpell);
combatMenu.MoveCardToDestination(_tempAdvancedSpell, CardDestination.Hand, CardDestination.Combat);
}
_miniatureProperties.OnSpellLogicChange(_spawnedMiniature.GetComponent <SpellVisuals>().spell.spellLogic);
cardHolder.spellMiniatures.Add(_spawnedMiniature);
}
public override void Execute(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin)
{
tilePattern.Clear();
patternBehaviours.Clear();
_properties.cardHolder.RemoveFirst();
BattlefieldScript _bfs = _properties.bfs;
GeneratePattern(_properties, _user, _userStatus, _shotOrigin, _bfs);
/*if (directionImage == null)
* {
* foreach (TileClass _affectedTile in tilePattern)
* {
* TileEffects(_properties, _user, _userStatus, _shotOrigin, _affectedTile, _bfs);
* }
* }
* else
* {
* var sortedOrderList = patternBehaviours.OrderBy(o => o.order);
* List<TilePatternBehaviour> _tempList = sortedOrderList.ToList();
* objectPooler.StartCoroutine(AdvancedTileEffect(_properties,_user,_userStatus, _tempList, _bfs));
* }*/
var sortedOrderList = patternBehaviours.OrderBy(o => o.order);
List <TilePatternBehaviour> _tempList = sortedOrderList.ToList();
_tempList.Reverse();
coroutineScript = CoroutineScript.Instance;
coroutineScript.StartRemoteCoroutine(AdvancedTileEffect(_properties, _user, _userStatus, _tempList, _bfs));
}
void FindOrigin(CombatMiniatureProperties _properties, GameObject _user, int x, int y)
{
Color pixelColor = patternImage.GetPixel(x, y);
if (pixelColor.a == 0)
{
return;
}
foreach (ColourToPattern colourMapping in colourToPatterns)
{
if (colourMapping.color.Equals(pixelColor))
{
switch (colourMapping.patternType)
{
case (PatternType.Origin):
{
patternOrigin = new Vector2Int(x, y);
x = patternImage.width;
y = patternImage.height;
break;
}
}
}
}
}
public override void Execute(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin)
{
playerScript = PlayerScript.Instance;
SpellCard _tempSpell = _properties.gameObject.GetComponent <SpellVisuals>().spell;
if (objectPooler == null)
{
objectPooler = ObjectPooler.Instance;
}
ProjectileScript _pScript = objectPooler.SpawnFromPool(projectile.name, _shotOrigin.position, Quaternion.Euler(0, 0, 90), _user.transform, projectile).GetComponent <ProjectileScript>();
_pScript.damageDealt = _properties.power;
if (_userStatus.directionFacing == Facing.Left)
{
_pScript.speed = System.Math.Abs(_pScript.speed) * -1;
}
else if (_userStatus.directionFacing == Facing.Right)
{
_pScript.speed = System.Math.Abs(_pScript.speed);
}
if (_tempSpell.exileOnUse == false)
{
_properties.combatMenu.MoveCardToDestination(_tempSpell, CardDestination.Combat, CardDestination.Graveyard);
}
else
{
_properties.combatMenu.MoveCardToDestination(_tempSpell, CardDestination.Combat, CardDestination.Exile);
}
_properties.cardHolder.RemoveFirst();
}
public void UseSpell(GameObject _user, EntityStatus _userStatus, Transform _shotOrigin)
{
GameObject _tempMiniature;
_tempMiniature = spellMiniatures[0];
CombatMiniatureProperties _tempMiniatureProperties = _tempMiniature.GetComponent <CombatMiniatureProperties>();
_tempMiniatureProperties.cardHolder = this;
_tempMiniatureProperties.spellLogic.Execute(_tempMiniatureProperties, _user, _userStatus, _shotOrigin);
}
void GeneratePattern(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin, BattlefieldScript _bfs)
{
for (int x = 0; x < patternImage.width; x++)
{
for (int y = 0; y < patternImage.height; y++)
{
FindOrigin(_properties, _user, x, y);
}
}
offsetOrigin = _properties.bfs.playerPosition - patternOrigin;
for (int x = 0; x < patternImage.width; x++)
{
for (int y = 0; y < patternImage.height; y++)
{
GenerateTileEffect(x, y, _properties, _bfs);
}
}
}
IEnumerator AdvancedTileEffect(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, List <TilePatternBehaviour> _tiles, BattlefieldScript _bfs)
{
float _nextOrderNumber = 1;
int _currentListItem = 0;
foreach (TilePatternBehaviour tpb in _tiles)
{
if (_tiles.Count > _currentListItem + 1)
{
_nextOrderNumber = _tiles[_currentListItem + 1].order;
}
if (tpb.tileClass != null)
{
switch (tileEffect)
{
case (TileEffect.Broken):
{
//tpb.tileClass.tileEffect = tileEffect;
tpb.tileClass.CheckEffect(tileEffect);
break;
}
case (TileEffect.Steal):
{
tpb.tileClass.ChangeAlignment(_bfs.standardColours[0], TileAlignment.Friendly);
break;
}
case (TileEffect.Cracked):
{
tpb.tileClass.CheckEffect(tileEffect);
break;
}
default:
{
Debug.Log("Something wrong with tile effect spell");
break;
}
}
}
/*if(tpb.type == PatternType.Continuous)
* {
* TilePatternBehaviour _tpb = new TilePatternBehaviour();
* _tpb.direction = tpb.direction;
* _tpb.order = tpb.order - 0.01f;
* _tpb.type = tpb.type;
* if( tpb.tileClass.tileNeighbours.TryGetValue(tpb.direction, out GameObject _tileObject))
* {
* _tpb.tileClass = _tileObject.GetComponent<TileClass>();
* }
*
* _tiles.Insert(_currentListItem + 1, _tpb);
* }*/
if (_nextOrderNumber != tpb.order)
{
yield return(new WaitForSeconds(0.2f));
}
_currentListItem++;
}
}
void GenerateTileEffect(int x, int y, CombatMiniatureProperties _properties, BattlefieldScript _bfs)
{
TilePatternBehaviour _tpb = new TilePatternBehaviour();
#region direction
if (directionImage != null)
{
Color directionColor = directionImage.GetPixel(x, y);
Color directionColorFullAlpha = new Color(directionColor.r, directionColor.g, directionColor.b, 1);
if (directionColor.a == 0)
{
return;
}
_tpb.order = directionColor.a;
foreach (ColourToDirection directionMapping in colourToDirection)
{
if (directionMapping.color.Equals(directionColorFullAlpha))
{
_tpb.direction = directionMapping.direction;
}
}
}
#endregion
Color pixelColor = patternImage.GetPixel(x, y);
if (pixelColor.a == 0)
{
return;
}
foreach (ColourToPattern colourMapping in colourToPatterns)
{
if (colourMapping.color.Equals(pixelColor))
{
switch (colourMapping.patternType)
{
case (PatternType.Standard):
{
Vector2Int _offsetVector = new Vector2Int(x, y) + offsetOrigin;
if (IsValidTile(_offsetVector.x, _offsetVector.y, _bfs))
{
_tpb.type = PatternType.Standard;
_tpb.tileClass = _bfs.battleTilesGrid[_offsetVector.x, _offsetVector.y].GetComponent <TileClass>();
tilePattern.Add(_bfs.battleTilesGrid[_offsetVector.x, _offsetVector.y].GetComponent <TileClass>());
break;
}
else
{
break;
}
}
case (PatternType.OriginIndependent):
{
_tpb.type = PatternType.OriginIndependent;
_tpb.tileClass = _bfs.battleTilesGrid[x, y].GetComponent <TileClass>();
tilePattern.Add(_bfs.battleTilesGrid[x, y].GetComponent <TileClass>());
break;
}
case (PatternType.Continuous):
{
bool canContinue = true;
Vector2Int _directionalOffset = new Vector2Int(x, y);
Vector2Int _offsetVector = _directionalOffset + offsetOrigin;
if (IsValidTile(_offsetVector.x, _offsetVector.y, _bfs))
{
_tpb.type = PatternType.Continuous;
_tpb.tileClass = _bfs.battleTilesGrid[_offsetVector.x, _offsetVector.y].GetComponent <TileClass>();
tilePattern.Add(_bfs.battleTilesGrid[_offsetVector.x, _offsetVector.y].GetComponent <TileClass>());
int i = 0;
float _orderOffset = 0;
TilePatternBehaviour _previousTPB = new TilePatternBehaviour();
_previousTPB.order = 2;
while (canContinue == true)
{
TilePatternBehaviour _continuousTPB = new TilePatternBehaviour();
_orderOffset += 0.01f;
if (_previousTPB.order > 1)
{
_previousTPB.tileClass = _tpb.tileClass;
_previousTPB.direction = _tpb.direction;
_previousTPB.type = _tpb.type;
_previousTPB.order = _tpb.order;
}
if (_previousTPB.tileClass.tileNeighbours[_previousTPB.direction].GetComponent <TileClass>() != null)
{
_continuousTPB.tileClass = _previousTPB.tileClass.tileNeighbours[_previousTPB.direction].GetComponent <TileClass>();
_continuousTPB.direction = _previousTPB.direction;
_continuousTPB.type = _previousTPB.type;
_continuousTPB.order = _previousTPB.order - _orderOffset;
_directionalOffset = (EnumScript.EnumMethods.DirectionToCoords(_continuousTPB.direction));
_offsetVector = _continuousTPB.tileClass.gridLocation + _directionalOffset;
if (IsValidTile(_continuousTPB.tileClass.gridLocation.x, _continuousTPB.tileClass.gridLocation.y, _bfs))
{
tilePattern.Add(_bfs.battleTilesGrid[_continuousTPB.tileClass.gridLocation.x, _continuousTPB.tileClass.gridLocation.y].GetComponent <TileClass>());
patternBehaviours.Add(_continuousTPB);
_previousTPB = _continuousTPB;
}
else
{
canContinue = false;
}
}
else
{
canContinue = false;
}
if (i > 20)
{
canContinue = false;
}
i++;
if (_offsetVector.x >= _bfs.xMax | _offsetVector.y >= _bfs.yMax | _offsetVector.x < 0 | _offsetVector.y < 0)
{
canContinue = false;
}
}
}
break;
}
default:
{
break;
}
}
}
}
patternBehaviours.Add(_tpb);
}
public abstract void Execute(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin);
public override void Execute(CombatMiniatureProperties _properties, GameObject _user, EntityStatus _userStatus, Transform _shotOrigin)
{
playerScript = PlayerScript.Instance;
SpellCard _tempSpell = _properties.gameObject.GetComponent <SpellVisuals>().spell;
int _currentBuffNumber = 0;
foreach (BuffType b in buffs)
{
switch (b)
{
case BuffType.Health:
if (power[_currentBuffNumber] < 0)
{
_userStatus.DealDamage(-power[_currentBuffNumber], -1.4f, 0.05f, BulletAlignement.Friendly);
}
else
{
if (_userStatus.hp + power[_currentBuffNumber] < _userStatus.maxHp)
{
_userStatus.hp += power[_currentBuffNumber];
}
}
if (_userStatus.hp + power[_currentBuffNumber] > _userStatus.maxHp)
{
_userStatus.hp = _userStatus.maxHp;
}
_userStatus.UpdateUI();
break;
case BuffType.MaxHealth:
if (power[_currentBuffNumber] > 0)
{
_userStatus.maxHp += power[_currentBuffNumber];
}
else
{
if (_userStatus.maxHp + power[_currentBuffNumber] <= _userStatus.hp)
{
int _dmg = (int)(_userStatus.maxHp - _userStatus.hp) + power[_currentBuffNumber];
_userStatus.maxHp += power[_currentBuffNumber];
_userStatus.DealDamage(-_dmg, -1.4f, 0.05f, BulletAlignement.Friendly);
}
else
{
_userStatus.maxHp += power[_currentBuffNumber];
_userStatus.DealDamage(0, -1.4f, 0.05f, BulletAlignement.Friendly);
}
}
_userStatus.UpdateUI();
break;
}
_currentBuffNumber++;
}
if (_tempSpell.exileOnUse == false)
{
_properties.combatMenu.MoveCardToDestination(_tempSpell, CardDestination.Combat, CardDestination.Graveyard);
}
else
{
_properties.combatMenu.MoveCardToDestination(_tempSpell, CardDestination.Combat, CardDestination.Exile);
}
_properties.cardHolder.RemoveFirst();
}
