public Vector2 GetPositionRelativeToAncestor(FContainer ancestor)
{
FNode target = this;
Vector2 position = new Vector2(0, 0);
FContainer container;
while (true)
{
position += target.GetPosition();
container = target.container;
if (container == null)
{
break;
}
if (container == ancestor)
{
break;
}
target = container;
}
return(position);
}
public void addPlayer(Player p)
{
p.addToMiniMap(miniMap);
if (p.isControlled)
{
p.SetPosition(playerSpawn.GetPosition());
}
else
{
p.SetPosition(spawnPoints[RXRandom.Int(spawnPoints.Count)].GetPosition());
}
float scaleChance = RXRandom.Float();
if (scaleChance < .15f)
{
p.setScale(3.0f);
}
else if (scaleChance < .4f)
{
p.setScale(2.0f);
}
playerLayer.AddChild(p);
playerList.Add(p);
p.setWorld(this);
}
public FNodeFollower(FNode follower,FNode following)
{
_follower=follower;
_following=following;
Vector2 globalPos=_following.LocalToGlobal(Vector2.zero);
Vector2 localPos=_follower.container.GlobalToLocal(globalPos);
_offset=_follower.GetPosition()-localPos;
((IFNodeWatcher)this).Watch(_following);
}
public void go(FNode node_, float duration_, float amplitude_)
{
Cancel(node_);
oPosition = node_.GetPosition();
curDuration = duration = duration_;
curAmplitude = amplitude = amplitude_;
_pendings.Add(node_, this);
if (node == null)
{
Futile.instance.SignalUpdate += HandleUpdate;
}
node = node_;
}
public void go(FNode node_, float duration_, float amplitude_)
{
oPosition = node_.GetPosition();
curDuration = duration = duration_;
curAmplitude = amplitude = amplitude_;
if (_pendings.ContainsKey(node_))
{
_pendings.Remove(node_);
}
_pendings.Add(node_, this);
if (node == null)
{
Futile.instance.SignalUpdate += HandleUpdate;
}
node = node_;
}
virtual public void Update()
{
if (_clipNode != null && !_skipZero)
{
// get position of _clipNode relative to this
Vector2 relPos = StageToLocal(_clipNode.GetPosition());
float xMin = relPos.x - _clipWidth / 2 - _tileWidth * 0.75f;
float yMin = relPos.y - _clipHeight / 2 - _tileHeight * 0.75f;
// check if the _clipNode has moved enough to check tile positions
if (Mathf.Round(xMin / _tileWidth) == _clipPos.x && Mathf.Round(yMin / _tileHeight) == _clipPos.y)
{
return;
}
_clipPos = new Vector2(Mathf.Round(xMin / _tileWidth), Mathf.Round(yMin / _tileHeight));
float tileOffsetX = (Mathf.Floor(_clipWidth / _tileWidth) + 2) * _tileWidth;
float tileOffsetY = (Mathf.Floor(_clipHeight / _tileHeight) + 2) * _tileHeight;
float xMax = xMin + tileOffsetX;
float yMax = yMin + tileOffsetY;
foreach (FSprite tile in _tiles)
{
bool tileChangedX = false;
bool tileChangedY = false;
while (tile.x < xMin)
{
tile.x += tileOffsetX;
tileChangedX = true;
}
if (!tileChangedX)
{
while (tile.x > xMax)
{
tile.x -= tileOffsetX;
tileChangedX = true;
}
}
while (tile.y < yMin)
{
tile.y += tileOffsetY;
tileChangedY = true;
}
if (!tileChangedY)
{
while (tile.y > yMax)
{
tile.y -= tileOffsetY;
tileChangedY = true;
}
}
if (tileChangedX || tileChangedY)
{
int tileX = Mathf.FloorToInt((tile.x - _tileWidth / 2) / _tileWidth);
int tileY = Mathf.FloorToInt((-tile.y - _tileHeight / 2) / _tileHeight);
if (repeatX)
{
while (tileX < 0)
{
tileX += _tilesWide;
}
while (tileX >= _tilesWide)
{
tileX -= _tilesWide;
}
}
else if (tileX < 0 || tileX >= _tilesWide)
{ // display empty tile, outside of known data
tileX = -1;
tileY = -1;
}
if (repeatY)
{
while (tileY < 0)
{
tileY += _tilesHigh;
}
while (tileY >= _tilesHigh)
{
tileY -= _tilesHigh;
}
}
else if (tileY < 0 || tileY >= _tilesHigh)
{ // display empty tile, outside of known data
tileX = -1;
tileY = -1;
}
int frame = tileX + tileY * _tilesWide;
if (frame >= 0 && frame < _tileArray.GetLength(0))
{
uint frameNum = _tileArray[frame];
bool flipped_horizontally = FTmxMap.FlippedHorizontally(frameNum);
bool flipped_vertically = FTmxMap.FlippedVertically(frameNum);
bool flipped_diagonally = FTmxMap.FlippedDiagonally(frameNum);
tile.element = Futile.atlasManager.GetElementWithName(_baseName + "_" + FTmxMap.RemoveFrameFlags(frameNum));
tile.rotation = flipped_diagonally ? -90 : 0;
if (flipped_diagonally)
{
tile.scaleY = flipped_vertically ? 1 : -1;
tile.scaleX = flipped_horizontally ? -1 : 1;
if (!(flipped_horizontally || flipped_vertically))
{
tile.scaleX = -1;
tile.scaleY = 1;
tile.rotation = -90;
}
else if (flipped_vertically && flipped_horizontally)
{
tile.scaleX = 1;
tile.scaleY = -1;
}
}
else
{
tile.scaleY = flipped_vertically ? -1 : 1;
tile.scaleX = flipped_horizontally ? -1 : 1;
}
tile.isVisible = true;
}
else
{
tile.isVisible = false;
}
}
}
}
}
internal void loadMap(string mapName)
{
this.clearMap();
this.LoadTMX("Maps/" + mapName);
tilemap = (FTilemap)(getLayerNamed("Tilemap"));
for (int x = 0; x < 3; x++)
{
otherTilemaps[x] = new FTilemap(tilemap.BaseElementName + "_" + (x + 1), 1);
otherTilemaps[x].LoadText(tilemap.dataString, false);
}
tilemapCollision = (FTilemap)(getLayerNamed("Meta"));
objectGroup = (FContainer)(getLayerNamed("Objects"));
foreach (XMLNode xml in this.objects)
{
switch (xml.attributes["type"])
{
case "Spawn":
FNode spawnPoint = new FNode();
spawnPoint.SetPosition(int.Parse(xml.attributes["x"]) + 8, -int.Parse(xml.attributes["y"]) + 8);
spawnPoints.Add(spawnPoint);
player.SetPosition(spawnPoint.GetPosition());
break;
case "Warp":
int warpX = 0;
int warpY = 0;
XMLNode propertiesNode = (XMLNode)xml.children[0];
foreach (XMLNode property in propertiesNode.children)
{
switch (property.attributes["name"])
{
case "warpTileX":
warpX = int.Parse(property.attributes["value"]);
break;
case "warpTileY":
warpY = int.Parse(property.attributes["value"]);
break;
}
}
WarpPoint warpPoint = new WarpPoint(warpX, warpY, xml.attributes["name"], int.Parse(xml.attributes["x"]) + 8, -int.Parse(xml.attributes["y"]) + 8);
warpPoints.Add(warpPoint);
break;
}
}
for (int x = 0; x < 100; x++)
{
Scientist s = new Scientist(tilemap.width * RXRandom.Float(), -tilemap.height * RXRandom.Float());
while (BaseGameObject.isWalkable(tilemap, s.x, s.y))
{
s.SetPosition(tilemap.width * RXRandom.Float(), -tilemap.height * RXRandom.Float());
}
addEnemy(s);
}
backgroundLayer.AddChild(tilemap);
foreach (FTilemap f in otherTilemaps)
{
backgroundLayer.AddChild(f);
}
backgroundLayer.AddChild(tilemapCollision);
backgroundLayer.AddChild(objectGroup);
player.setMap(this);
playerLayer.AddChild(player);
}
public void go(FNode node_,float duration_,float amplitudeX_,float periodX_,float amplitudeY_,float periodY_,float delay_)
{
Cancel(node_);
oPosition=node_.GetPosition();
//Debug.Log("oPosition="+oPosition);
curDuration=duration=duration_;
curAmplitudeX=amplitudeX=amplitudeX_;
curAmplitudeY=amplitudeY=amplitudeY_;
periodX=periodX_;
periodY=periodY_;
curDelay=delay_;
pendings.Add(node_,this);
if (node==null) {
Futile.instance.SignalUpdate+=HandleUpdate;
}
node=node_;
}
