//protected override Vector2f DefaultViewSize
//{
// set
// {
// if (value != this.DefaultViewSize)
// {
// base.DefaultViewSize = value;
// IntRect endTurnButtonCanvevas = this.endTurnButton.Canevas;
// this.endTurnButton.Position = new Vector2f(-endTurnButtonCanvevas.Width / 2, this.DefaultViewSize.Y / 2 - endTurnButtonCanvevas.Height);
// IntRect effectBehaviorLabelCanvevas = this.effectBehaviorLabel2D.Canevas;
// this.effectBehaviorLabel2D.StartingPosition = new Vector2f(-this.DefaultViewSize.X / 2 - effectBehaviorLabelCanvevas.Width, 0);
// }
// }
//}
public BoardNotifLayer2D(World2D world2D, IObject2DFactory factory, BoardNotifLayer layer) :
base(world2D, factory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.hittableEntities2D = new List <AEntity2D>();
this.awakenedBannerLabel2D = new AwakenedBannerLabel2D(this);
this.effectBanner2D = new EffectBanner2D(this);
this.effectLabel2D = new EffectLabel2D(this);
this.endTurnButton = new EndTurnButton2D(this);
this.effectBehaviorLabel2D = new EffectBehaviorLabel2D(this);
this.pendingRemovingCardEntities = new List <CardEntity2D>();
this.cardsHand = new List <CardEntity2D>();
layer.CardCreated += OnCardCreated;
layer.CardRemoved += OnCardRemoved;
layer.CardPicked += OnCardPicked;
layer.CardUnpicked += OnCardUnpicked;
layer.CardFocused += OnCardFocused;
layer.CardAwakened += OnCardAwakened;
layer.NotifBehaviorStarted += OnNotifBehaviorStarted;
layer.NotifBehaviorPhaseChanged += OnNotifBehaviorPhaseChanged;
layer.NotifBehaviorUseChanged += OnNotifBehaviorUseChanged;
layer.NotifBehaviorEnded += OnNotifBehaviorEnded;
}
private void InternalEmit(int idx, EmitParams emitParams)
{
Particle p = particles[idx];
World2D world = GetWorld2d();
Physics2DDirectSpaceState spaceState = world.DirectSpaceState;
foreach (ParticleSystem2DModule module in modules)
{
if (!module.enabled)
{
continue;
}
IParticleInitializable IInit = module as IParticleInitializable;
if (IInit == null)
{
continue;
}
module.world = world;
module.spaceState = spaceState;
IInit.InitParticle(ref p, emitParams);
}
p.alive = true;
particles[idx] = p;
}
void Start()
{
world = GetComponent <World2D>();
generator = new RoomGenerator();
generator.GetGridSystem.SetGridSize(new IntVector2(50, 50));
generator.GenerateRooms(world);
world.worldMap = LinqConvert(generator.GetGridSystem.GetGrid);
GameObject[] o = GameObject.FindGameObjectsWithTag("Player");
loader = new GameLoader(windows);
List <FPSPlayer> players = new List <FPSPlayer>();
for (int i = 0; i < o.Length; i++)
{
players.Add(o[i].GetComponent <FPSPlayer>());
}
for (int i = 0; i < generator.SpawnPointList.Count; i++)
{
players[i % players.Count].SpawnPos.Add(generator.SpawnPointList[i]);
players[i % players.Count].GetComponent <FPSPlayer>().SetPosition(generator.SpawnPointList[i]);
}
//get the target and objective entities
//targetEntity = generator
}
public BoardPlayerLayer2D(World2D world2D, IObject2DFactory factory, BoardPlayerLayer layer) :
base(world2D, factory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.hittableEntities2D = new List <AEntity2D>();
layer.CardDrawn += OnCardDrawn;
layer.NbCardsToDrawChanged += OnNbCardToDrawsChanged;
layer.CardFocused += OnCardFocused;
layer.CardPicked += OnCardPicked;
layer.CardUnpicked += OnCardUnpicked;
layer.PileFocusedChanged += OnPileFocusedChanged;
layer.CardDestroyed += OnCardDestroyed;
// layer.CardResurrected += OnCardResurrected;
layer.SourceCardEntitiesSet += OnSourceCardEntitiesSet;
//this.cardToolTip = new CardToolTip(this);
//this.endTurnButton = new EndTurnButton2D(this);
this.scoreLabel = new ScoreLabel2D(this);
this.cardsDeck = new List <CardEntity2D>();
this.cardsCemetery = new List <CardEntity2D>();
this.cardsHand = new List <CardEntity2D>();
this.pileFocused = BoardPlayerLayer.PileFocused.NONE;
layer.BoardToLayerPositionConverter = this;
}
public BoardBannerLayer2D(World2D world2D, IObject2DFactory factory, BoardBannerLayer layer) :
base(world2D, factory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
layer.PlayerScoreUpdated += OnPlayerScoreUpdated;
layer.TurnCountChanged += OnTurnCountChanged;
this.bannerEntity2D = new BannerEntity2D(this);
this.endLevelBanner2D = new EndLevelBanner2D(this);
this.returnMenuButton2D = new ReturnMenuButton2D(this);
this.returnMenuButton2D.Position = new Vector2f(-200, this.endLevelBanner2D.Canevas.Height / 2 - this.returnMenuButton2D.Canevas.Height / 2 - 20);
this.replayMenuButton2D = new ReplayMenuButton2D(this);
this.replayMenuButton2D.Position = new Vector2f(200, this.endLevelBanner2D.Canevas.Height / 2 - this.returnMenuButton2D.Canevas.Height / 2 - 20);
this.hittableEntities2D = new List <AEntity2D>();
this.turnBanner2D = new TurnBanner2D(this);
this.cardsToPlaceBanner2D = new CardsToPlaceBanner2D(this);
this.domainToolTip = new DomainToolTip2D(this);
this.cardFocusedLayers = new HashSet <ICardFocusedLayer>();
this.domainsLayers = new HashSet <IDomainsLayer>();
this.scoreLayers = new Dictionary <string, IScoreLayer>();
}
public BackgroundLayer2D(World2D world2D, IObject2DFactory factory, BackgroundLayer layer) :
base(world2D, factory, layer)
{
this.Area = (factory as BackgroundLayer2DFactory).Area;
this.nameToTiles = new Dictionary <string, TileBackgoundObject2D>();
}
public ImageBackgroundLayer2D(World2D world2D, IObject2DFactory layerFactory, ALayer layer)
: base(world2D, layerFactory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.imageBackground2D = new ImageBackgroundObject2D(this);
(layer as ImageBackgroundLayer).CurrentImageIdChanged += this.OnCurrentImageIdChanged;
}
private void UpdateSystem(float delta)
{
try
{
if (timeScale < 0f)
{
timeScale = 0f;
}
delta *= timeScale;
Vector2 deltaPos = GlobalPosition - prevPos;
currentVelocity = deltaPos / delta;
World2D world = GetWorld2d();
Physics2DDirectSpaceState spaceState = world.DirectSpaceState;
foreach (ParticleSystem2DModule module in modules)
{
if (!module.enabled)
{
continue;
}
module.particleSystem = this;
module.world = world;
module.spaceState = spaceState;
module.UpdateModule(delta);
for (int i = 0; i < maxParticles; i++)
{
IParticleUpdateable IUpdate = module as IParticleUpdateable;
if (particles[i].alive)
{
if (IUpdate != null)
{
IUpdate.UpdateParticle(ref particles[i], delta);
}
if (particles[i].currentLife <= 0f)
{
particles[i].currentLife = 0f;
DestroyParticle(i);
particles[i].alive = false;
}
}
}
}
prevPos = GlobalPosition;
}
catch (Exception e)
{
if (Engine.EditorHint)
{
emitting = false;
}
var st = new System.Diagnostics.StackTrace(e, true);
GD.PrintErr(st);
}
}
private void SetActionForButton(Button button, Vector3 newCameraLocation, TabletPosition tabPos, int id)
{
button.onClick.AddListener(() => {
targetLocation = newCameraLocation;
UIManager.singleton.setPosition(tabPos);
if (tabPos == TabletPosition.Bot || tabPos == TabletPosition.Top)
{
NetworkEconomySystem.setCurrentTower(World2D.getTowerFromID(id));
}
});
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is MenuTextLayer)
{
MenuTextLayer menuTextLayer = obj as MenuTextLayer;
return(new MenuTextLayer2D(world2D, this, menuTextLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
{
if (obj is CardEntityAwakenedDecorator)
{
CardEntityAwakenedDecorator entity = obj as CardEntityAwakenedDecorator;
return(new CardEntityAwakenedDecorator2D(this, layer2D, entity));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
{
if (obj is StarLinkEntity)
{
StarLinkEntity entity = obj as StarLinkEntity;
return(new StarLinkEntity2D(layer2D, this, entity));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is CJMenuLayer)
{
CJMenuLayer backgroundLayer = obj as CJMenuLayer;
return(new CJMenuLayer2D(world2D, this, backgroundLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is OppBoardPlayerLayer)
{
OppBoardPlayerLayer oppBoardPlayerLayer = obj as OppBoardPlayerLayer;
return(new OppBoardPlayerLayer2D(world2D, this, oppBoardPlayerLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is BoardGameLayer)
{
BoardGameLayer boardGameLayer = obj as BoardGameLayer;
return(new BoardGameLayer2D(world2D, this, boardGameLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is BoardBannerLayer)
{
BoardBannerLayer backgroundLayer = obj as BoardBannerLayer;
return(new BoardBannerLayer2D(world2D, this, backgroundLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
{
if (obj is CardEntity)
{
CardEntity entity = obj as CardEntity;
return(new CardEntity2D(this, layer2D, entity));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
{
if (obj is CJStarDomain)
{
CJStarDomain entity = obj as CJStarDomain;
return(new CJStarDomain2D(layer2D, this, entity));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
{
if (obj is ToolTipEntity)
{
ToolTipEntity entity = obj as ToolTipEntity;
return(new CardToolTip2D(layer2D));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is ImageBackgroundLayer)
{
ImageBackgroundLayer imageBackgroundLayer = obj as ImageBackgroundLayer;
return(new ImageBackgroundLayer2D(world2D, this, imageBackgroundLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is MenuBoardPlayerLayer)
{
MenuBoardPlayerLayer boardPlayerLayer = obj as MenuBoardPlayerLayer;
return(new MenuBoardPlayerLayer2D(world2D, this, boardPlayerLayer));
}
return(null);
}
public override IObject2D CreateObject2D(World2D world2D, IObject obj)
{
if (obj is EntityLayer)
{
EntityLayer entityLayer2D = obj as EntityLayer;
return(new EntityLayer2D(world2D, this, entityLayer2D));
}
return(null);
}
public MenuTextLayer2D(World2D world2D, IObject2DFactory layerFactory, ALayer layer) : base(world2D, layerFactory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.LevelTurnPhase = TurnPhase.VOID;
this.titleText2D = new TextCanevas2D(this);
this.titleText2D.Position = new Vector2f(-5000, -800);
this.titleText2D.Canevas = new IntRect(0, 0, 10000, 1000);
this.titleText2D.CreateTextParagraph2D(new Vector2f(0, 0), new Vector2f(0, 0), TextParagraph2D.Alignment.CENTER, 1000);
this.titleText2D.UpdateTextOfParagraph(0, "menu_title");
}
public CJMenuLayer2D(World2D world2D, IObject2DFactory factory, CJMenuLayer layer) :
base(world2D, factory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.startButton = new CJStartButton2D(this);
this.player1DeckBuildingButton = new CJDeckBuildingButton2D(this, "start_deck_building1");
this.player2DeckBuildingButton = new CJDeckBuildingButton2D(this, "start_deck_building2");
this.focusableEntities = new List <AEntity2D>()
{
this.startButton,
this.player1DeckBuildingButton,
this.player2DeckBuildingButton
};
}
public override void LoadContent(ContentManager content)
{
//Level / World
var level = content.Load(levelReference);
world = level.Create(new Range <float>(0, 1), chunkSize);
collidables.AddSource(world);
(camera as PlayerCamera)?.SetBoundaries(new Rectangle(0, 0, GameScale.FromTile(level.LevelSize.X).Pixels, GameScale.FromTile(level.LevelSize.Y).Pixels));
//Player
//Temp Texture.
Point playerSize = new Point(64, 64);
var playerTexture = CreateSingleColorTexture(Color.BurlyWood, playerSize.X, playerSize.Y);
player = new Player("Player", new Sprite(playerTexture, null, new Vector2(playerSize.X / 2, playerSize.Y)), new Transform2D(level.PlayerSpawnLocation.X, level.PlayerSpawnLocation.Y), collidables);
(camera as PlayerCamera)?.SetTargetPlayer(player);
collidables.AddSingle(player);
}
public override void _EnterTree()
{
World2D world = GetWorld2d();
Physics2DDirectSpaceState spaceState = world.DirectSpaceState;
if (modulesData.Count == 0)
{
modules.Clear();
maxParticles = 256;
seed = new Random().Next();
emitting = true;
emitOnStart = true;
AddModule <ParticleSystem2DEmitOptionsModule>(false);
AddModule <ParticleSystem2DEmitRateModule>(false);
AddModule <ParticleSystem2DUpdateModule>(false);
AddModule <ParticleSystem2DDrawBatchModule>(false);
WriteModulesData();
}
else
{
if (modules.Count != modulesData.Count)
{
ReadModulesData();
}
}
if (!Engine.EditorHint)
{
emitting |= emitOnStart;
}
foreach (ParticleSystem2DModule module in modules)
{
module.particleSystem = this;
module.InitModule();
}
prevPos = GlobalPosition;
}
public BoardGameLayer2D(World2D world2D, IObject2DFactory factory, BoardGameLayer layer) :
base(world2D, factory, layer)
{
this.Area = new Vector2i(int.MaxValue, int.MaxValue);
this.cardsOnBoard = new List <CardEntity2D>();
this.domainsOwnedByPlayers = new List <CJStarDomain2D>();
this.linksFocused = new List <StarLinkEntity2D>();
layer.CardPicked += this.OnCardPicked;
//layer.CardUnpicked += this.OnCardUnPicked;
layer.CardFocused += this.OnCardFocused;
layer.DomainFocused += this.OnDomainFocused;
layer.SourceStarEntitiesSet += OnSourceStarEntitiesSet;
layer.TargetStarEntitiesSet += OnTargetStarEntitiesSet;
layer.NbCardsToPlaceChanged += OnNbCardsToPlaceChanged;
}
public void GenerateRooms(World2D world)
{
m_generating = true;
while (m_generating)
{
int roomSize = GetRoomSize();
// update the current transform to the new room's center after placing it
m_transform = SetTiles(m_transform, roomSize);
}
// generate walls
new WallGenerator(m_gridSystem);
new DoorGenerator(m_gridSystem);
new SectionGenerator(m_gridSystem, TileType.s01Wall, TileType.s02Wall, TileType.s03Wall, TileType.s04Wall);
SpawnPointGenerator s = new SpawnPointGenerator(m_gridSystem, world);
world.spawnpointGenerator = s;
world.gridSystem = m_gridSystem;
m_playerList = s.SpawnPointList;
}
public World2D Create(Range <float> depthRange, int chunkSize)
{
byte layerCount = (byte)colorMaps.Count;
var world = new World2D(GameScale.TileSize, layerCount, depthRange, chunkSize, (int)Math.Ceiling(LevelSize.X / (float)chunkSize), (int)Math.Ceiling(LevelSize.Y / (float)chunkSize));
for (var layer = 0; layer < layerCount; layer++)
{
for (var y = 0; y < LevelSize.Y; y++)
{
for (var x = 0; x < LevelSize.Y; x++)
{
var tile = GetTileForColor(colorMaps[layer][x + y * LevelSize.X]);
if (tile != null)
{
world.PlaceTile(x, y, layer, tile);
}
}
}
}
return(world);
}
public SpawnPointGenerator(GridSystem gSystem, World2D world)
{
m_randomSpawnPoints = GetEmptyTiles(gSystem);
Vector2 pos = GetWithoutOccupyRange(gSystem);
GameObject o = new GameObject();
o.AddComponent <RaycastEntity>();
RaycastEntity entity = o.GetComponent <RaycastEntity>();
entity.Position = pos;
entity.TextureId = 18;
entity.tag = "Pickup";
world.Entities.Add(entity);
GameObject o2 = new GameObject();
o2.AddComponent <RaycastEntity>();
Vector2 pos2 = GetAndOccupyPosRange(gSystem);
RaycastEntity endPoint = o2.GetComponent <RaycastEntity>();
endPoint.Position = pos2;
endPoint.TextureId = 17;
endPoint.tag = "EndPoint";
world.Entities.Add(endPoint);
//gSystem.SetOccupied((int)pos.x, (int)pos.y, TileType.item);
for (int i = 0; i < 8; i++)
{
if (!SpawnPlayer(gSystem))
{
return;
}
}
}
