public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
TileBase[] neighboringTiles = null;
var iden = Matrix4x4.identity;
foreach (TilingRule rule in m_TilingRules)
{
if (rule.m_Output == TilingRule.OutputSprite.Animation)
{
Matrix4x4 transform = iden;
GetMatchingNeighboringTiles(tilemap, position, ref neighboringTiles);
if (RuleMatches(rule, ref neighboringTiles, ref transform))
{
tileAnimationData.animatedSprites = rule.m_Sprites;
tileAnimationData.animationSpeed = rule.m_AnimationSpeed;
return(true);
}
}
}
return(false);
}
///<summary>
///Tile animation `data` expects its `animatedSprites` field populated by a list of sprites
///to be cycled through at a constant framerate.
///</summary>
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData data)
{
if (frames == null || frames.Length == 0)
{
return(false);
}
// Tiled supports individual frame durations per frame, but Unity doesn't. This is
// solved by finding the greatest divisor between all frame durations, using that for
// the fixed framerate, and replicating each frame enough times to match its original
// duration.
var duration = GreatestCommonDivisor(frames.Select(f => f.duration).ToArray());
var sprites = new List <Sprite>();
for (var i = 0; i < frames.Length; ++i)
{
for (var j = 0; j < frames[i].duration / duration; ++j)
{
sprites.Add(frames[i].sprite);
}
}
data.animatedSprites = sprites.ToArray();
data.animationSpeed = 1000f / duration;
data.animationStartTime = 0f;
return(true);
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tileMap, ref TileAnimationData tileAnimationData)
{
if (m_AnimatedSprites.Length > 0)
{
tileAnimationData.animatedSprites = m_AnimatedSprites;
tileAnimationData.animationSpeed = Speed;
tileAnimationData.animationStartTime = location.y + location.x;
return(true);
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
var info = GetTileInfo(tilemap, position);
if (info.SpriteType == Info.Type.Animated)
{
tileAnimationData.animatedSprites = info.Sprites;
tileAnimationData.animationSpeed = info.AnimationSpeed;
}
return(true);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
if (Rules.Count > 0)
{
TileBase[] neighbors = null;
GetNeighbors(tilemap, position, ref neighbors);
foreach (var rule in Rules)
{
if (RuleMatches(rule, neighbors, this))
{
if (rule.UseReference)
{
return(rule.Reference.GetTileAnimationData(position, tilemap, ref tileAnimationData));
}
return(false);
}
}
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tileMap, ref TileAnimationData tileAnimationData)
{
if (m_AnimatedSprites.Length > 0)
{
tileAnimationData.animatedSprites = m_AnimatedSprites;
tileAnimationData.animationSpeed = Random.Range(m_MinSpeed, m_MaxSpeed);
tileAnimationData.animationStartTime = m_AnimationStartTime;
return(true);
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
tileAnimationData.animatedSprites = Sprites;
tileAnimationData.animationSpeed = Speed;
tileAnimationData.animationStartTime = StartTime;
return(true);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
return(base.GetTileAnimationData(position, tilemap, ref tileAnimationData));
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData data)
{
if (sprites == null || sprites.Length == 0)
{
return(false);
}
data.animatedSprites = sprites;
data.animationSpeed = 1000f / duration;
data.animationStartTime = 0f;
return(true);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
if (CheckForBeingPrepared() == false)
{
return(false);
}
if (Patterns[CurrentIndex].Frames.Length == 1)
{
return(false);
}
else
{
tileAnimationData.animatedSprites = Patterns[CurrentIndex].Frames;
tileAnimationData.animationSpeed = UnityEngine.Random.Range(m_MinSpeed, m_MaxSpeed);
tileAnimationData.animationStartTime = m_AnimationStartTime;
return(true);
}
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
if (sprites == null)
{
return(false);
}
if (sprites.Length == 0)
{
return(false);
}
tileAnimationData.animatedSprites = sprites;
tileAnimationData.animationSpeed = fps;
tileAnimationData.animationStartTime = 0f;
return(true);
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
bool b;
if (dead)
{
b = destroyedTile.GetTileAnimationData(location, tilemap, ref tileAnimationData);
}
else
{
b = base.GetTileAnimationData(location, tilemap, ref tileAnimationData);
}
return(b);
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tileMap, ref TileAnimationData tileAnimationData)
{
tileAnimationData.animatedSprites = Tiles.Select(tile => tile.Sprite).ToArray();
tileAnimationData.animationSpeed = GetSpeed();
tileAnimationData.animationStartTime = GetStart();
return(true);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
if (!m_RuntimeTile)
{
Override();
}
return(m_RuntimeTile.GetTileAnimationData(position, tilemap, ref tileAnimationData));
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
if (m_AnimationSprites != null && m_AnimationSprites.Length > 1)
{
tileAnimationData.animatedSprites = m_AnimationSprites;
tileAnimationData.animationSpeed = 1.0f;
tileAnimationData.animationStartTime = 0;
return(true);
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int tilePosition, ITilemap iTilemap, ref TileAnimationData tileAnimationData)
{
Matrix4x4 matrixTransform = Matrix4x4.identity;
/*
* Se uma das Rules for um Tile com animação, é preciso definir o `tileAnimationData`
* com os dados da animação.
*
* Mas, antes é necessário verificar se o Rule é correspondido.
*/
foreach (Rule rule in rules)
{
if (rule.spriteOutputType == Rule.SpriteOutputType.Animation)
{
bool neighborsMatched = IsNeighborsMatched(rule, tilePosition, iTilemap, ref matrixTransform);
if (neighborsMatched)
{
// Replace Tile data.
tileAnimationData.animatedSprites = rule.tileSprites;
tileAnimationData.animationSpeed = rule.animationSpeed;
return(true);
}
}
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
var rule = DefaultRule;
if (OverrideTile)
{
var index = OverrideTile.GetRuleIndex(position, tilemap, this);
if (index >= 0 && index < Rules.Count)
{
rule = Rules[index];
}
}
if (rule.UseReference)
{
return(rule.Reference.GetTileAnimationData(position, tilemap, ref tileAnimationData));
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
foreach (TilingRule rule in m_TilingRules)
{
Matrix4x4 transform = Matrix4x4.identity;
if (RuleMatches(rule, position, tilemap, ref transform) && rule.m_Output == TilingRule.OutputSprite.Animation)
{
tileAnimationData.animatedSprites = rule.m_Sprites;
tileAnimationData.animationSpeed = rule.m_AnimationSpeed;
return(true);
}
}
return(false);
}
public override bool GetTileAnimationData(Vector3Int location, ITilemap tilemap, ref TileAnimationData tileAnimationData)
{
tileAnimationData.animatedSprites = animatedTiles;
tileAnimationData.animationSpeed = fps;
tileAnimationData.animationStartTime = 0f;
return(true);
}
