public void SetOccupied(Vector2Int position, CollisionLayer layer)
{
if (!_bounds.Contains(position))
{
return;
}
var tile = AddOrGetTile(position);
tile.OccupiedLayer |= (tile.CollisionLayerIncrement == CollisionLayer.None ? layer : tile.CollisionLayerIncrement);
}
private static int GetLowestLayerIndex(CollisionLayer layer)
{
var value = (int)layer;
for (var i = 0; i < LayerCount; i++)
{
if (((value >> i) & 1) != 0)
return i;
}
return 1;
}
public void SetOccupied(Vector2Int position, CollisionLayer layer)
{
if (_occupiedTiles.TryGetValue(position, out CollisionLayer occupied))
{
occupied |= layer;
}
else
{
_occupiedTiles[position] = layer;
}
}
private void TileEntered(Vector2Int position)
{
var tile = WorldManager.Instance.FindTile(position);
if (tile != null && tile.LayerChange != CollisionLayer.None)
{
MovementLayer = tile.LayerChange;
}
WorldManager.Instance.SetOccupied(position, MovementLayer);
WorldManager.Instance.AddInteraction(position, _interaction);
}
public virtual void WarpToPosition(Vector2Int position, Vector2 direction, CollisionLayer layer)
{
UnoccupyCurrentTiles();
transform.position = position + PositionOffset;
CurrentGridPosition = position;
PreviousGridPosition = CurrentGridPosition;
CollisionLayer = layer;
_willWarp = true;
OccupyCurrentTiles();
}
protected virtual void TileEntered(Vector2Int position)
{
if (CurrentZone != null)
{
var tile = CurrentZone.Tilemap.GetTile(position);
if (tile != null && tile.CollisionLayerIncrement != CollisionLayer.None)
{
CollisionLayer = tile.CollisionLayerIncrement;
}
}
}
protected virtual void UpdateSorting(CollisionLayer layer, bool usePosition)
{
var index = GetLowestLayerIndex(layer) + 1;
var sortingOrder = index * 100000;
if (usePosition)
{
sortingOrder += (int)(50000 - (transform.position.y * 100));
}
_renderer.sortingOrder = sortingOrder;
}
public void SetUnoccupied(Vector2Int position, CollisionLayer layer)
{
if (_occupiedTiles.TryGetValue(position, out CollisionLayer occupied))
{
var tile = FindTile(position);
occupied &= ~layer;
if (occupied == CollisionLayer.None)
{
_occupiedTiles.Remove(position);
}
}
}
private void removeCollLayerButton_Click(object sender, EventArgs e)
{
string filename = CollLayerListBox.SelectedItem as string;
if (CollLayerListBox.SelectedItem != null)
{
tileMap.colLayers.Remove(currentCollisionLayer);
collDict.Remove(filename);
CollLayerListBox.Items.Remove(CollLayerListBox.SelectedItem);
currentCollisionLayer = null;
}
}
public Weapon(Game1 game, IPositionable entity, float angle = 0.0f)
{
const float SECONDS_IN_MINUTE = 60f;
const float RATE_OF_FIRE = 200f;
_laserSpawnTime = TimeSpan.FromSeconds(SECONDS_IN_MINUTE / RATE_OF_FIRE);
_previousLaserSpawnTime = TimeSpan.Zero;
_game = game;
_entity = entity;
_state = State.Ready;
_itMustFire = false;
_weaponAngle = angle;
_collisionLayers = CollisionLayer.PowerUp | CollisionLayer.Enemy | CollisionLayer.Laser;
}
private int GetLowestLayerIndex(CollisionLayer layer)
{
var value = (int)layer;
for (var i = 0; i < CollisionLayerData.LayerCount; i++)
{
if (((value >> i) & 1) != 0)
{
return(i);
}
}
return(0);
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
List <string> tileNameList = new List <string>();
List <string> collNameList = new List <string>();
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
foreach (var tileName in layerDict)
{
tileNameList.Add(tileName.Key);
}
foreach (var colName in collDict)
{
collNameList.Add(colName.Key);
}
foreach (var layer in layerDict)
{
TileLayer tileLayer = layer.Value;
Dictionary <int, string> utilizedTextures = new Dictionary <int, string>();
foreach (string textureName in textureListBox.Items)
{
int index = tileLayer.isUsingTexture(textureDict[textureName]);
if (index != -1)
{
utilizedTextures.Add(index, textureName);
}
}
List <string> utilizedTextureList = new List <string>();
for (int i = 0; i < utilizedTextures.Count; i++)
{
utilizedTextureList.Add(utilizedTextures[i]);
}
tileMap.Save(saveFileDialog1.FileName, collNameList.ToArray(), tileNameList.ToArray());
tileLayer.Save(contentPathTextBox.Text + "\\Layers\\" + layer.Key, utilizedTextureList.ToArray());
}
foreach (var colLayer in collDict)
{
CollisionLayer collLayer = colLayer.Value;
collLayer.Save(contentPathTextBox.Text + "\\Layers\\" + colLayer.Key);
}
}
}
public void Add(ICollidable collidable)
{
CollisionLayer group = collidable.CollisionGroup;
lock (_collidableLists)
{
if (!_collidableLists.ContainsKey(group))
{
_collidableLists.Add(group, new List <ICollidable>());
}
_collidableLists[group].Add(collidable);
}
}
public MapData(
string mapName,
List <TilesetData> tilesets,
AnimatedTilesetData animatedSet,
List <MapLayerData> layers,
CollisionLayer collisionLayer,
AnimatedTileLayer animatedLayer)
{
MapName = mapName;
AnimatedTileset = animatedSet;
Tilesets = tilesets.ToArray();
Layers = layers.ToArray();
Collisions = collisionLayer;
AnimatedTiles = animatedLayer;
}
protected LayerMask LayerMaskForCollisionLayer(CollisionLayer layer, ISceneContext context)
{
switch (layer)
{
case CollisionLayer.Background: return(context.GetBackgroundLayer());
case CollisionLayer.StaticForeground: return(context.GetStaticForegroundLayer());
case CollisionLayer.DynamicForeground: return(context.GetDynamicForegroundLayer());
case CollisionLayer.Wall: return(LayerMask.NameToLayer("Wall"));
default: throw new System.ArgumentException("Unknown collision layer type");
}
}
/// <summary>
/// initializes with collison layer and creates a simple shadow.
/// </summary>
public override void Initialize()
{
base.Initialize();
colLayerMoveWorld =
RobotGameGame.CurrentGameLevel.CollisionLayerMoveWorld;
colLayerHitWorld =
RobotGameGame.CurrentGameLevel.CollisionLayerHitWorld;
colLayerFriendlyMech =
RobotGameGame.CurrentGameLevel.CollisionLayerFriendlyMech;
colLayerEnemyMech =
RobotGameGame.CurrentGameLevel.CollisionLayerEnemyMech;
colLayerAllMech =
RobotGameGame.CurrentGameLevel.CollisionLayerAllMech;
colLayerItems =
RobotGameGame.CurrentGameLevel.CollisionLayerItems;
colLayerVersusTeam = RobotGameGame.CurrentGameLevel.CollisionVersusTeam;
// creates a simple shadow.
GameResourceTexture2D resource =
FrameworkCore.ResourceManager.LoadTexture("Textures/shadow");
simpleShadow = new GameQuad(new Vector3(0.0f, 0.02f, 0.0f),
Vector3.Up, Vector3.Forward, 3.0f, 3.0f);
simpleShadow.Name = "simple shadow";
simpleShadow.Texture = resource.Texture2D;
simpleShadow.LightingEnabled = false;
simpleShadow.Alpha = 0.6f;
simpleShadow.AlphaBlendEnable = true;
simpleShadow.ReferenceAlpha = 0;
simpleShadow.DepthBufferEnable = true;
simpleShadow.DepthBufferWriteEnable = true;
simpleShadow.DepthBufferFunction = CompareFunction.Less;
simpleShadow.SourceBlend = Blend.SourceAlpha;
simpleShadow.DestinationBlend = Blend.InverseSourceAlpha;
simpleShadow.BlendFunction = BlendFunction.Add;
simpleShadow.AlphaFunction = CompareFunction.Greater;
simpleShadow.CullMode = CullMode.CullCounterClockwiseFace;
this.AddChild(simpleShadow);
}
/// <summary>
/// Construit une carte de jeu selon une liste de tilesets et une liste de couches de carte
/// </summary>
/// <param name="tilesets"></param>
/// <param name="mapLayers"></param>
public TileMap(List <Tileset> tilesets, List <MapLayer> mapLayers)
{
// Ajout des tilesets
this.tilesets = tilesets;
// Ajout des maplayers
this.MapLayers = mapLayers;
// Ajout de la collision
collisionLayer = new CollisionLayer(mapLayers[0].Height, mapLayers[0].Width);
bulletCollisionLayer = new CollisionLayer(mapLayers[0].Height, mapLayers[0].Width);
foreach (MapLayer maplayer in mapLayers)
{
ProcessColisionLayer(maplayer);
}
}
// Token: 0x0600001A RID: 26 RVA: 0x00003070 File Offset: 0x00001270
private Vector2 GetPlayerAimPointController(Vector2 aimBase, Vector2 aimDirection)
{
Func <SpeculativeRigidbody, bool> rigidbodyExcluder = (SpeculativeRigidbody otherRigidbody) => otherRigidbody.minorBreakable && !otherRigidbody.minorBreakable.stopsBullets;
Vector2 result = aimBase + aimDirection * 10f;
CollisionLayer layer = CollisionLayer.EnemyHitBox;
int rayMask = CollisionMask.LayerToMask(CollisionLayer.HighObstacle, CollisionLayer.BulletBlocker, layer, CollisionLayer.BulletBreakable);
RaycastResult raycastResult;
bool flag = PhysicsEngine.Instance.Raycast(aimBase, aimDirection, 50f, out raycastResult, true, true, rayMask, null, false, rigidbodyExcluder, null);
if (flag)
{
result = aimBase + aimDirection * raycastResult.Distance;
}
RaycastResult.Pool.Free(ref raycastResult);
return(result);
}
public void SetUnoccupied(Vector2Int position, CollisionLayer layer)
{
var tile = GetTile(position);
if (tile == null)
{
return;
}
tile.OccupiedLayer &= (tile.CollisionLayerIncrement == CollisionLayer.None ? ~layer : ~tile.CollisionLayerIncrement);
if (tile.IsEmpty())
{
_tiles.Remove(position);
}
}
private JobHandle BuildRadarLayer(FactionMember factionMember, out CollisionLayer layer, JobHandle inputDeps)
{
m_radars.SetSharedComponentFilter(factionMember);
int count = m_radars.CalculateEntityCount();
var bodies = new NativeArray <ColliderBody>(count, Allocator.TempJob);
var aabbs = new NativeArray <Aabb>(count, Allocator.TempJob);
var jh = Entities.WithAll <AiRadarTag>().WithSharedComponentFilter(factionMember).WithStoreEntityQueryInField(ref m_radars)
.ForEach((Entity e, int entityInQueryIndex, in AiShipRadar radar, in LocalToWorld ltw) =>
{
var transform = new RigidTransform(quaternion.LookRotationSafe(ltw.Forward, ltw.Up), ltw.Position);
var sphere = new SphereCollider(0f, radar.distance);
if (radar.cosFov < 0f)
{
//Todo: Create tighter bounds here too.
aabbs[entityInQueryIndex] = Physics.CalculateAabb(sphere, transform);
}
else
{
//Compute aabb of vertex and spherical cap points which are extreme points
float3 forward = math.forward(transform.rot);
bool3 positiveOnSphereCap = forward > radar.cosFov;
bool3 negativeOnSphereCap = -forward > radar.cosFov;
float3 min = math.select(0f, -radar.distance, negativeOnSphereCap);
float3 max = math.select(0f, radar.distance, positiveOnSphereCap);
Aabb aabb = new Aabb(min, max);
//Compute aabb of circle base
float4 cos = new float4(forward, radar.cosFov);
float4 sinSq = 1f - (cos * cos);
float4 sin = math.sqrt(sinSq);
float3 center = forward * radar.distance * radar.cosFov;
float radius = radar.distance * sin.w;
float3 extents = sin.xyz * radius;
min = center - extents;
max = center + extents;
aabb.min = math.min(aabb.min, min) + transform.pos;
aabb.max = math.max(aabb.max, max) + transform.pos;
aabbs[entityInQueryIndex] = aabb;
}
bodies[entityInQueryIndex] = new ColliderBody
{
collider = sphere,
entity = e,
transform = transform
};
}).ScheduleParallel(inputDeps);
public object Clone()
{
Map map = new Map();
map.AssetName = AssetName;
map.baseLayer = BaseLayer.Clone() as int[];
foreach (MapEntry <Chest> chestEntry in chestEntries)
{
MapEntry <Chest> mapEntry = new MapEntry <Chest>();
mapEntry.Content = chestEntry.Content.Clone() as Chest;
mapEntry.ContentName = chestEntry.ContentName;
mapEntry.Count = chestEntry.Count;
mapEntry.Direction = chestEntry.Direction;
mapEntry.MapPosition = chestEntry.MapPosition;
map.chestEntries.Add(mapEntry);
}
map.chestEntries.AddRange(ChestEntries);
map.collisionLayer = CollisionLayer.Clone() as int[];
map.combatMusicCueName = CombatMusicCueName;
map.combatTexture = CombatTexture;
map.combatTextureName = CombatTextureName;
map.fixedCombatEntries.AddRange(FixedCombatEntries);
map.fringeLayer = FringeLayer.Clone() as int[];
map.innEntries.AddRange(InnEntries);
map.mapDimensions = MapDimensions;
map.musicCueName = MusicCueName;
map.name = Name;
map.objectLayer = ObjectLayer.Clone() as int[];
map.playerNpcEntries.AddRange(PlayerNpcEntries);
map.portals.AddRange(Portals);
map.portalEntries.AddRange(PortalEntries);
map.questNpcEntries.AddRange(QuestNpcEntries);
map.randomCombat = new RandomCombat();
map.randomCombat.CombatProbability = RandomCombat.CombatProbability;
map.randomCombat.Entries.AddRange(RandomCombat.Entries);
map.randomCombat.FleeProbability = RandomCombat.FleeProbability;
map.randomCombat.MonsterCountRange = RandomCombat.MonsterCountRange;
map.spawnMapPosition = SpawnMapPosition;
map.storeEntries.AddRange(StoreEntries);
map.texture = Texture;
map.textureName = TextureName;
map.tileSize = TileSize;
map.tilesPerRow = tilesPerRow;
return(map);
}
private void LoadTiles(CollisionLayer colLayer)
{
globalX = colLayer.Width;
globalY = colLayer.Height;
tiles = new Tile[colLayer.Width, colLayer.Height];
for (int x = 0; x < colLayer.Width; ++x)
{
for (int y = 0; y < colLayer.Height; ++y)
{
tiles[x, y] = LoadTile(colLayer.GetCellIndex(x, y), x, y);
}
}
//if (exits.Count == 0)
// throw new NotSupportedException("A level must have an exit.");
}
/// <summary>
/// Construit une carte de jeu avec un tileset et une carte de jeu
/// </summary>
/// <param name="tileset"></param>
/// <param name="mapLayer"></param>
public TileMap(Tileset tileset, MapLayer mapLayer)
{
// Ajout du tileset
tilesets = new List <Tileset>();
tilesets.Add(tileset);
// Ajout des maplayers
MapLayers = new List <MapLayer>();
MapLayers.Add(mapLayer);
// Ajout de la collision
collisionLayer = new CollisionLayer(MapLayers[0].Height, MapLayers[0].Width);
bulletCollisionLayer = new CollisionLayer(MapLayers[0].Height, MapLayers[0].Width);
foreach (MapLayer maplayer in MapLayers)
{
ProcessColisionLayer(maplayer);
}
}
private bool GetCanMove(Vector2Int position, MovementDirection direction, CollisionLayer layer, out bool jump)
{
jump = false;
if (WorldManager.Instance.IsOccupied(position, layer))
{
return(false);
}
var tile = WorldManager.Instance.FindTile(position);
if (tile != null)
{
jump = tile.IsJumpable(direction);
return(!tile.HasCollision(layer) && !tile.IsEdge(direction) && !WorldManager.Instance.IsOccupied(tile.Position, tile.LayerChange));
}
return(true);
}
/// <summary>
/// drops weapon at specified position.
/// </summary>
/// <param name="position">new drop position</param>
/// <param name="parent">new scene node</param>
/// <param name="layer">new collision layer</param>
public void Drop(Vector3 position, NodeBase parent, CollisionLayer layer)
{
// Detached scene node from owner
AttachOwner(parent);
// Add a collision
if (layer != null)
{
layer.AddCollide(this.Collide);
}
DroppedModel.SetRootAxis(
Matrix.CreateRotationX(MathHelper.ToRadians(-90.0f)));
this.Position = position;
this.isDropped = true;
this.Enabled = true;
this.Visible = true;
}
/// <summary>
/// Initialize members.
/// </summary>
public void Initialize()
{
Clear();
// Add collision layers
collisionLayerMoveWorld =
FrameworkCore.CollisionContext.AddLayer("Collision MoveWorld");
// Add collision layers
collisionLayerHitWorld =
FrameworkCore.CollisionContext.AddLayer("Collision HitWorld");
// Add collision layers
collisionLayerAllMech =
FrameworkCore.CollisionContext.AddLayer("Collision AllMech");
// Add collision layers
collisionLayerItems =
FrameworkCore.CollisionContext.AddLayer("Collision Items");
if (Info.GamePlayType == GamePlayTypeId.Versus)
{
collisionVersusTeam = new CollisionLayer[2];
// Add two collision layers
for (int i = 0; i < 2; i++)
{
collisionVersusTeam[i] =
FrameworkCore.CollisionContext.AddLayer(
"Collision Versus Team");
}
}
else
{
// Add collision layers
collisionLayerFriendlyMech =
FrameworkCore.CollisionContext.AddLayer("Collision FriendlyMech");
// Add collision layers
collisionLayerEnemyMech =
FrameworkCore.CollisionContext.AddLayer("Collision EnemyMech");
}
}
private void AddCollLayerButton_Click(object sender, EventArgs e)
{
newCollisionLayerForm form2 = new newCollisionLayerForm();
form2.ShowDialog();
if (form2.OKColpressed)
{
CollisionLayer collisionLayer = new CollisionLayer(
int.Parse(form2.collWidth.Text),
int.Parse(form2.collHeight.Text));
collDict.Add(form2.collName.Text + ".collayer", collisionLayer);
tileMap.colLayers.Add(collisionLayer);
CollLayerListBox.Items.Add(form2.collName.Text + ".collayer");
AdjustScrollBars();
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
//use base.Content to load your game content here
//load map0 layers and backbuffer
base.Maps[0].CollisionLayer = CollisionLayer.FromFile("Content/Layers/Map1/collision.lyr");
base.Maps[0].TacticalLayer = TileLayer.FromFile(Content, "Content/Layers/Map1/tactical_map.lyr");
base.Maps[0].TacticalLayer.Alpha = 1.0f;
base.Maps[0].Layers.Add(TileLayer.FromFile(Content, "Content/Layers/Map1/map1.lyr"));
base.Maps[0].Layers[0].Alpha = 1f;
//player setup
AnimatedSprite pas = new AnimatedSprite(base.Content.Load <Texture2D>("sprites/ship"), null);
pas.AddAnimation(1, 64, 64, 0, 0, 1, "Idle");
pas.Animations["Idle"].UpdateType = UpdateType.Forward;
pas.CurrentAnimationName = "Idle";
PlayerObject player = new PlayerObject("Player", new Vector2(0, 0), pas, base.Content.Load <Texture2D>("particles/particle_base"));
player.CurrentMap = CurrentMap;
}
public CollisionSpawner(CollisionLayer periphery)
{
_secondsToMaximumValues = 300f;
_timeSinceStart = 0.0f;
_minimumTimeSinceLastBirdSpawn = 0.6f;
_maximumTimeSinceLastBirdSpawn = 3f;
_timeSinceLastBirdSpawn = 0.0f;
_minimumBirdSpeed = 150f;
_maximumBirdSpeed = 700f;
_isSpawning = false;
_layer = periphery;
TimeInbetweenBirdSpawns = 1.0f;
_timeSinceLastGroundUnitSpawn = 0.0f;
TimeInbetweenGroundUnitSpawns = 8f;
_timeSinceLastBatterySpawn = 0.0f;
_minimumTimeSinceLastBatterySpawn = 15f;
_maximumTimeSinceLastBatterySpawn = 45f;
TimeInbetweenBatterySpawns = 15f;
}
public void AddLaser(IMovement movement, CollisionLayer collision_layers)
{
Animation laserAnimation = new Animation();
// initlize the laser animation
laserAnimation.Initialize(laserTexture,
_player.Position,
46,
16,
1,
30,
Color.White,
1f,
true);
laserBeams.Add().Initialize(this, laserAnimation, movement, collision_layers);
var instance = laserSoundEffect.CreateInstance();
instance.Play();
}
