private void PredictAbilitiesHelper(MTile tile, MAbility ability, bool lWeapon, CWeapon parentWeapon, bool wpnAbility)
{
var target = tile.GetCurrentOccupant() as CChar;
var prediction = new AgentAbilityData();
prediction.Ability = ability;
prediction.LWeapon = lWeapon;
prediction.ParentWeapon = parentWeapon;
prediction.Target = target;
prediction.Weight = 0;
prediction.WpnAbiltiy = wpnAbility;
if (ability.Data.Hostile)
{
if (target.Proxy.LParty != this._agent.Proxy.LParty)
{
this.HandleAbility(prediction);
this._predictions.Add(prediction);
}
}
else
{
if (target.Proxy.LParty == this._agent.Proxy.LParty)
{
this.HandleAbility(prediction);
this._predictions.Add(prediction);
}
}
}
public VTile(MTile h)
{
this._center = h.Center;
this._col = h.GetCol();
this._height = h.GetHeight();
this._row = h.GetRow();
this._type = h.Type;
}
public CTile(MTile tile)
{
this._handle = new GameObject(SortingLayers.TILE);
this._handle.transform.position = tile.Center;
this._nonCurrent = new List <CChar>();
this._zones = new List <AZone>();
this.SetModel(tile);
}
private void HandleQuadrantHelper(MHit hit, CChar tgt, MTile tile)
{
if (tile.GetCurrentOccupant() != null)
{
if (tile.GetCurrentOccupant().GetType().Equals(typeof(CChar)))
{
this.HandleCharacterOccupant(tile);
}
else if (tile.GetCurrentOccupant().GetType().Equals(typeof(CDeco)))
{
this.HandleDecoOccupant(tile);
}
}
}
private void HandleRaycastHover(CTile t, MAbility active)
{
var sprite = MapBridge.Instance.GetTileHighlightSprite();
var source = CombatManager.Instance.GetCurrentlyActing().Tile;
MTile initTile = null;
if (source.Model.IsTileN(t.Model, active.Data.Range))
{
initTile = source.Model.GetN();
}
else if (source.Model.IsTileNE(t.Model, active.Data.Range))
{
initTile = source.Model.GetNE();
}
else if (source.Model.IsTileNE(t.Model, active.Data.Range))
{
initTile = source.Model.GetNE();
}
else if (source.Model.IsTileSE(t.Model, active.Data.Range))
{
initTile = source.Model.GetSE();
}
else if (source.Model.IsTileS(t.Model, active.Data.Range))
{
initTile = source.Model.GetS();
}
else if (source.Model.IsTileSW(t.Model, active.Data.Range))
{
initTile = source.Model.GetSW();
}
else if (source.Model.IsTileNW(t.Model, active.Data.Range))
{
initTile = source.Model.GetNW();
}
var tiles = source.Model.GetConvertedRaycastTiles(initTile, active.Data.Range);
foreach (var tile in tiles)
{
if (tile.Liquid)
{
this._aoeTiles.Add(this.DecorateTileHandle(tile.Controller.LiquidHandle, sprite));
}
this._aoeTiles.Add(this.DecorateTileHandle(tile.Controller.Handle, sprite));
}
}
private void HandleDecoOccupant(MTile tile)
{
var occupant = tile.GetCurrentOccupant() as CDeco;
var data = new StrayTargetData();
data.Chance = occupant.Model.GetBulletObstructionChance();
data.Tile = tile.Controller;
var pair = new Pair <double, double>(tile.GetCol(), tile.GetRow());
if (this._strayTargets.ContainsKey(pair))
{
this._strayTargets[pair].Chance += data.Chance;
}
else
{
this._strayTargets.Add(pair, data);
}
}
void CreateMap()
{
currentTile = TileCacher.Instance.Get(1);
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
GameObject obj = Object.Instantiate(prefabTile);
obj.SetActive(true);
obj.name = "Tile_" + (i + 1) + "_" + (j + 1);
obj.transform.SetParent(tilesLayer.transform);
obj.transform.localPosition = new Vector3(j * 0.64f + 0.32f, -i * 0.64f - 0.32f, 0f);
obj.transform.localScale = Vector3.one;
VTile vTile = obj.GetComponent <VTile>();
vTile.EditorSetData(currentTile);
}
}
}
private void ChangeCurrentTile()
{
MTile[] tiles = TileCacher.Instance.GetAll();
int i = 0;
int j = 0;
foreach (MTile tile in tiles)
{
if (GUI.Button(new Rect(50 + i * 110, 100 + j * 40, 100, 30), tile.name))
{
currentTile = tile;
}
j++;
if (j >= 15)
{
j = 0;
i++;
}
}
}
private double GetHeightScalar(MTile tile)
{
double scalar = 1;
foreach (var neighbor in tile.GetAdjacent())
{
int delta = neighbor.GetHeight() - tile.GetHeight();
switch (delta)
{
case (2): { scalar *= 0.8; } break;
case (1): { scalar *= 0.9; } break;
case (-1): { scalar *= 1.1; } break;
case (-2): { scalar *= 1.2; } break;
}
}
return(scalar);
}
private void HandleCharacterOccupant(MTile tile)
{
var data = new StrayTargetData();
data.Tile = tile.Controller;
var occupant = tile.GetCurrentOccupant() as CChar;
if (occupant.Proxy.Type == ECharType.Humanoid)
{
if (FActionStatus.HasFlag(occupant.Proxy.GetActionFlags().CurFlags, FActionStatus.Flags.ShieldWalling))
{
data.Chance = BASE_SHIELDWALL_OBSTRUCTION_CHANCE;
}
else if (occupant.Proxy.GetLWeapon() != null && occupant.Proxy.GetLWeapon().IsTypeOfShield())
{
data.Chance = BASE_SHIELD_OBSTRUCTION_CHANCE;
}
else if (occupant.Proxy.GetRWeapon() != null && occupant.Proxy.GetRWeapon().IsTypeOfShield())
{
data.Chance = BASE_SHIELD_OBSTRUCTION_CHANCE;
}
else
{
data.Chance = BASE_OBSTRUCTION_CHANCE;
}
}
else
{
data.Chance = BASE_OBSTRUCTION_CHANCE;
}
var pair = new Pair <double, double>(tile.GetCol(), tile.GetRow());
if (this._strayTargets.ContainsKey(pair))
{
this._strayTargets[pair].Chance += data.Chance;
}
else
{
this._strayTargets.Add(pair, data);
}
}
private double GetRangedVulnScalar(MTile tile)
{
double scalar = 1;
foreach (var neighbor in tile.GetAdjacent())
{
if (neighbor.GetCurrentOccupant() != null)
{
if (neighbor.GetCurrentOccupant().GetType().Equals(typeof(CChar)))
{
scalar *= this.TryScaleRangedVulnDueToChar(neighbor.GetCurrentOccupant() as CChar);
}
else if (neighbor.GetCurrentOccupant().GetType().Equals(typeof(CDeco)))
{
scalar *= this.TryScaleRangedVulnDueToDeco(neighbor.GetCurrentOccupant() as CDeco);
}
}
}
return(scalar);
}
private void GenerateThreatPoints(CChar agent, MTile tile, int dist, bool lTeam)
{
var builder = new ThreatPointBuilder();
double scalar = 1;
double degrade = AgentRoleDegradationTable.Instance.ThreatTable[agent.Proxy.GetAIRole()];
for (int i = 0; i < dist; i++)
{
scalar *= degrade;
}
scalar *= this.GetHeightScalar(tile);
var threats = builder.BuildThreats(agent);
var particles = tile.GetParticles();
var selfThreatMods = AgentRoleSelfModTable.Instance.ThreatTable[agent.Proxy.GetAIRole()];
foreach (var kvp in threats)
{
kvp.Value.ScaleValue(degrade);
kvp.Value.ScaleValue(selfThreatMods[kvp.Key]);
particles.AddThreatParticles(kvp.Key, kvp.Value, lTeam);
}
}
public HexMap GetMap(int rows, int cols, float e, Vector3 seed)
{
var tiles = new List <IHex>();
for (int i = 0; i < cols; i += 2)
{
for (int j = 1; j < rows; j++)
{
var xOffset = e * 0.75f;
var tile = new MTile();
tile.SetCol(i);
tile.SetRow(j);
tile.SetCenter(new Vector3((seed.x + (xOffset * i)), (seed.y - (e * j)), seed.z));
tiles.Add(tile);
}
}
var h = e * 0.50f;
var ySeed = new Vector3((seed.x + (e * 0.75f)), (seed.y - h), seed.z);
for (int i = 1; i < cols; i += 2)
{
for (int j = 1; j < rows; j++)
{
var xOffset = e * 0.75f;
var tile = new MTile();
tile.SetCol(i);
tile.SetRow(j);
tile.SetCenter(new Vector3((seed.x + (xOffset * i)), (ySeed.y - (e * j)), seed.z));
tiles.Add(tile);
}
}
var map = new HexMap(tiles, rows, cols);
this.PopulateAdjacentTiles(map);
return(map);
}
void OnGUI()
{
if (!loadComplete)
{
GUI.Label(new Rect(100, 50, 100, 30), "Loading");
return;
}
width = int.Parse(GUI.TextField(new Rect(50, 10, 50, 30), width.ToString()));
height = int.Parse(GUI.TextField(new Rect(110, 10, 50, 30), height.ToString()));
setId = GUI.TextField(new Rect(170, 10, 50, 30), setId);
if (GUI.Button(new Rect(250, 10, 90, 30), "createMap"))
{
CreateMap();
//createMapOk = true;
currentTile = TileCacher.Instance.Get(1);
}
if (GUI.Button(new Rect(350, 10, 90, 30), "saveMap"))
{
CreateScriptableObjectMasterMapRun();
}
ChangeCurrentTile();
}
private void GenerateParticlePoints(EAgentRole role, MTile tile, bool lTeam)
{
var particles = tile.GetParticles();
double particlePoints = 0;
var enemyVulns = this._vulns.EnemyVulnTable[role];
var enemyThreats = this._threats.EnemyThreatTable[role];
var friendlyVulns = this._vulns.FriendlyVulnTable[role];
var friendlyThreats = this._threats.FriendlyThreatTable[role];
foreach (var kvp in enemyThreats)
{
particlePoints -= (particles.GetThreatValue(kvp.Key, lTeam) * kvp.Value);
}
foreach (var kvp in enemyVulns)
{
double points = (particles.GetVulnValue(kvp.Key, lTeam) * kvp.Value);
points *= tile.GetVulnMod();
particlePoints += points;
}
foreach (var kvp in friendlyThreats)
{
double points = (particles.GetThreatValue(kvp.Key, lTeam) * kvp.Value);
points *= tile.GetThreatMod();
particlePoints += points;
}
foreach (var kvp in friendlyVulns)
{
particlePoints += (particles.GetVulnValue(kvp.Key, lTeam) * kvp.Value);
}
var tileAndWeight = new AgentMoveTileAndWeight();
tileAndWeight.Tile = tile;
tileAndWeight.Weight = particlePoints;
this._tiles.Add(tileAndWeight);
}
public void SetCurrentHex(IHex hex)
{
this._tile = hex as MTile;
}
public MapTileInspector()
{
InitializeComponent();
Tile = new MTile();
}
public void EditorSetData(MTile mTile)
{
terrainReview.gameObject.SetActive(true);
terrainReview.sprite = MTile.GetIcon(mTile.id);
SetData(mTile);
}
public void SetData(MTile mTile)
{
_mTile = mTile;
}
public void SetModel(MTile t)
{
this._model = t;
this.Model.SetController(this);
this.SetView(new VTile(this._model));
}
public int GetTileTraversalStaminaCost(MTile tile)
{
return(tile.GetCost());
}
