public async Task <Response> AddItemAsync(BuildingLocation item)
{
Response result = new Response();
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("Id", item.Id);
parameters.Add("Name", item.Name);
parameters.Add("Description", item.Description);
parameters.Add("BuildingId", item.BuildingId);
parameters.Add("UserID", App.LogUser.Id.ToString());
parameters.Add("ImageName", item.ImageName);
parameters.Add("ImageUrl", item.ImageUrl);
parameters.Add("ImageDescription", item.ImageDescription);
//Regex UrlMatch = new Regex(@"(?i)(http(s)?:\/\/)?(\w{2,25}\.)+\w{3}([a-z0-9\-?=$-_.+!*()]+)(?i)", RegexOptions.Singleline);
//if (item.ImageUrl == "blank.png" || UrlMatch.IsMatch(item.ImageUrl))
//{
// item.ImageUrl = null;
//}
string ImageUrl = HttpUtil.GetImageUrl(item.ImageUrl).Result;
result = await HttpUtil.UploadSingleImage(item.Name, ImageUrl, "api/BuildingLocation/AddEdit", parameters);
return(await Task.FromResult(result));
}
public async Task <Response> DeleteItemAsync(BuildingLocation item)
{
item.IsDelete = true;
item.UserId = App.LogUser.Id.ToString();
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(App.AzureBackendUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
using (HttpResponseMessage response = await client.PostAsJsonAsync($"api/BuildingLocation/DeleteBuildingLocation", item))
{
var responseBody = await response.Content.ReadAsStringAsync();
Response result = JsonConvert.DeserializeObject <Response>(responseBody);
response.EnsureSuccessStatusCode();
//if (response.IsSuccessStatusCode == false)
//{
// throw new ApiException
// {
// StatusCode = (int)response.StatusCode,
// Content = result.Message
// };
//}
return(await Task.FromResult(result));
}
}
}
//-------------------------------------------------------------------------------------------------
//nuskaito pastatų pozicijų duomenis
public static BuildingLocation[] ReadBuildingLocations(string dataFile, int countOfBuildings)
{
string dataPath = Application.persistentDataPath;
string FilePath = Path.Combine(dataPath, dataFile + ".txt");
BuildingLocation[] locations = new BuildingLocation[countOfBuildings];
if (File.Exists(FilePath))
{
StreamReader reader = new StreamReader(new FileStream(FilePath, FileMode.Open));
int i = 0;
string line = reader.ReadLine();
while (line != null)
{
string[] values = line.Split(' ');
float x = float.Parse(values[0]);
float y = float.Parse(values[1]);
float z = float.Parse(values[2]);
locations[i] = new BuildingLocation(x, y, z);
line = reader.ReadLine();
i++;
}
reader.Close();
}
return(locations);
}
public void ConstructorShallSetType()
{
var type = typeof(SingleTileBuilding);
var buildingLocation = new BuildingLocation(type, new Tile(), Angle.Zero);
Assert.AreEqual(type, buildingLocation.Type);
}
private Vector2[,] FindBuildingSquares(int biuldingIndex, BuildingLocation buildingLocation)
{
Vector2[,] squares = new Vector2[buildingsDimensions[biuldingIndex].xLength, buildingsDimensions[biuldingIndex].zWidth];
double startX = 0;
double startZ = 0;
if (buildingLocation.x > 0)
{
startX = (double)buildingLocation.x - ((double)buildingsDimensions[biuldingIndex].xLength / 2);
}
else
{
startX = (double)buildingLocation.x - ((double)buildingsDimensions[biuldingIndex].xLength / 2);
}
if (buildingLocation.z > 0)
{
startZ = (double)buildingLocation.z - ((double)buildingsDimensions[biuldingIndex].zWidth / 2);
}
else
{
startZ = (double)buildingLocation.z - ((double)buildingsDimensions[biuldingIndex].zWidth / 2);
}
for (int i = 0; i < buildingsDimensions[biuldingIndex].zWidth; i++)
{
for (int j = 0; j < buildingsDimensions[biuldingIndex].xLength; j++)
{
squares[i, j].x = baseGridDimensionX_n + (float)startX + j;
squares[i, j].y = baseGridDimensionZ_n + (float)startZ + i;
}
}
return(squares);
}
// Kvieciamas tik tada kai paspaudziama ant movables layer neturincio pastato
public void DeselectBuildings()
{
if (selectedBuildingIndex != -1)
{
if (EmptySpot(selectedBuildingIndex))
{
ClearSquares(selectedBuildingIndex, buildingsLocations[selectedBuildingIndex]);
buildingsLocations[selectedBuildingIndex] = new BuildingLocation(buildings[selectedBuildingIndex].transform.position.x, buildings[selectedBuildingIndex].transform.position.y, buildings[selectedBuildingIndex].transform.position.z);
FillSquares(selectedBuildingIndex, buildingsLocations[selectedBuildingIndex]);
}
else
{
buildings[selectedBuildingIndex].transform.position = new Vector3(buildingsLocations[selectedBuildingIndex].x, buildingsLocations[selectedBuildingIndex].y, buildingsLocations[selectedBuildingIndex].z);
buildingBasisMeshRenderers[selectedBuildingIndex].material = green;
}
if (buildings[selectedBuildingIndex].transform.position == new Vector3(0, -100, 0))
{
CanonManager canonManager = buildings[selectedBuildingIndex].GetComponent(typeof(CanonManager)) as CanonManager;
CrossbowManager crossbowManager = buildings[selectedBuildingIndex].GetComponent(typeof(CrossbowManager)) as CrossbowManager;
if (canonManager != null)
{
AddAndRemove.instance.SellCanon();
}
else if (crossbowManager != null)
{
AddAndRemove.instance.SellCrossbowTower();
}
}
PutBuildingBack(selectedBuildingIndex);
selectedBuildingIndex = -1;
selectedBuildingArrows.transform.position = new Vector3(0, -100, 0);
}
removeBuildingButton.gameObject.SetActive(false);
}
public void ConstructorShallSetTile()
{
var tile = new Tile();
var buildingLocation = new BuildingLocation(typeof(SingleTileBuilding), tile, Angle.Zero);
Assert.AreEqual(tile, buildingLocation.Tile);
}
private static void Spawn(BuildingLocation _location)
{
switch (_location.m_buildingType)
{
case BuildingType.BARRACKS_KNIGHT:
for (int i = 0; i < 4; ++i)
{
m_unitList.Add(new Unit((int)_location.m_position.x, (int)_location.m_position.y, _location.m_allianceType, UnitType.KNIGHT));
}
break;
case BuildingType.BARRACKS_ARCHER:
for (int i = 0; i < 2; ++i)
{
m_unitList.Add(new Unit((int)_location.m_position.x, (int)_location.m_position.y, _location.m_allianceType, UnitType.ARCHER));
}
break;
case BuildingType.BARRACKS_GIANT:
for (int i = 0; i < 1; ++i)
{
m_unitList.Add(new Unit((int)_location.m_position.x, (int)_location.m_position.y, _location.m_allianceType, UnitType.GIANT));
}
break;
default:
break;
}
}
public void Instantiate_ShallCreateBuilding()
{
var buildingLocation = new BuildingLocation(typeof(SingleTileBuilding), new Tile(), Angle.Zero);
var result = buildingLocation.Instantiate();
Assert.True(result is SingleTileBuilding);
Assert.AreEqual(Angle.Zero, result.Angle);
}
public static void RecordTurretDamage(Turret __instance, BuildingLocation bLoc, float totalDamage)
{
if (bLoc == BuildingLocation.None || bLoc == BuildingLocation.Invalid)
{
return;
}
RecordUnitDamage(bLoc.ToString(), totalDamage, __instance.GetCurrentArmor(bLoc), __instance.GetCurrentStructure(bLoc));
}
public async Task <bool> UpdateItemAsync(BuildingLocation item)
{
var oldItem = items.Where((BuildingLocation arg) => arg.Id == item.Id).FirstOrDefault();
items.Remove(oldItem);
items.Add(item);
return(await Task.FromResult(true));
}
public static void LogTurretDamage(Turret __instance, BuildingLocation bLoc)
{
try {
if (bLoc == BuildingLocation.None || bLoc == BuildingLocation.Invalid)
{
return;
}
LogActorDamage(__instance.GetCurrentArmor(bLoc), __instance.GetCurrentStructure(bLoc));
} catch (Exception ex) { Error(ex); }
}
public static void FixZombieTurret(Turret __instance, ref float totalDamage, BuildingLocation bLoc)
{
try {
if (bLoc == BuildingLocation.None || bLoc == BuildingLocation.Invalid)
{
return;
}
KillZombie("turret", __instance.DisplayName, __instance.GetCurrentArmor(bLoc) + __instance.GetCurrentStructure(bLoc), ref totalDamage);
} catch (Exception ex) { Error(ex); }
}
//langeliai uzpildomi pastato indeksu
public void FillSquares(int buildingIndex, BuildingLocation location)
{
Vector2[,] buildingSquares = FindBuildingSquares(buildingIndex, location);
for (int i = 0; i < buildingsDimensions[buildingIndex].zWidth; i++)
{
for (int j = 0; j < buildingsDimensions[buildingIndex].xLength; j++)
{
base_squares[(int)buildingSquares[i, j].y, (int)buildingSquares[i, j].x] = buildingIndex;
}
}
}
public void RemoveBuilding()
{
buildings[selectedBuildingIndex].transform.position = new Vector3(0, -100, 0);
BuildingLocation location = buildingsLocations[selectedBuildingIndex];
ClearSquares(selectedBuildingIndex, location);
buildingsLocations[selectedBuildingIndex] = new BuildingLocation(buildings[selectedBuildingIndex].transform.position.x, buildings[selectedBuildingIndex].transform.position.y, buildings[selectedBuildingIndex].transform.position.z);
selectedBuildingIndex = -1;
selectedBuildingArrows.transform.position = new Vector3(0, -100, 0);
removeBuildingButton.gameObject.SetActive(false);
}
//-----------------------------------------------------------------------------------------------------
//Kvieciamas kai paspaudziama ant movables layer turincio pastato
public void SelectBuilding(int index)
{
if (index != selectedBuildingIndex)
{
if (selectedBuildingIndex != -1)
{
if (EmptySpot(selectedBuildingIndex))
{
ClearSquares(selectedBuildingIndex, buildingsLocations[selectedBuildingIndex]);
buildingsLocations[selectedBuildingIndex] = new BuildingLocation(buildings[selectedBuildingIndex].transform.position.x, buildings[selectedBuildingIndex].transform.position.y, buildings[selectedBuildingIndex].transform.position.z);
FillSquares(selectedBuildingIndex, buildingsLocations[selectedBuildingIndex]);
}
else
{
buildings[selectedBuildingIndex].transform.position = new Vector3(buildingsLocations[selectedBuildingIndex].x, buildingsLocations[selectedBuildingIndex].y, buildingsLocations[selectedBuildingIndex].z);
buildingBasisMeshRenderers[selectedBuildingIndex].material = green;
}
if (selectedBuildingIndex != index)
{
PutBuildingBack(selectedBuildingIndex);
BringBuildingNearer(index);
}
}
else
{
BringBuildingNearer(index);
}
if (selectedBuildingIndex != -1 && buildings[selectedBuildingIndex].transform.position == new Vector3(0, -100, 0))
{
CanonManager canonManager = buildings[selectedBuildingIndex].GetComponent(typeof(CanonManager)) as CanonManager;
CrossbowManager crossbowManager = buildings[selectedBuildingIndex].GetComponent(typeof(CrossbowManager)) as CrossbowManager;
if (canonManager != null)
{
AddAndRemove.instance.SellCanon();
}
else if (crossbowManager != null)
{
AddAndRemove.instance.SellCrossbowTower();
}
}
BuildingPlacement.instance.SetItem(buildings[index], buildingsDimensions[index]);
SetArrowsLocalPosition(index);
selectedBuildingArrows.transform.position = new Vector3(buildings[index].transform.position.x, 0, buildings[index].transform.position.z);
BringArrowsNearer();
selectedBuildingIndex = index;
}
removeBuildingButton.gameObject.SetActive(true);
}
void Start()
{
BountError = BountyError.NoError;
bountySize = GameObject.Find("BountySpotlight");
heroSpawn = GameObject.Find("HeroController").GetComponent <HeroSpawner>();
mymainmoney = GameObject.Find("GUIIncometab").GetComponent <MainMoney> ();
spawnPointpos = gameObject.transform.position;
spawnPointRot = gameObject.transform.rotation;
buildingloc = GameObject.Find("BuildingManager").GetComponent <BuildingLocation> ();
maxxz = heroSpawn.HowFarCanIGo(1);
MaxX = maxxz [0];
MaxZ = maxxz [1];
}
public void ClearSquares(int buildingIndex, BuildingLocation location)
{
Vector2[,] squaresToClear = FindBuildingSquares(buildingIndex, location);
for (int i = 0; i < buildingsDimensions[buildingIndex].zWidth; i++)
{
for (int j = 0; j < buildingsDimensions[buildingIndex].xLength; j++)
{
if (base_squares[(int)squaresToClear[i, j].y, (int)squaresToClear[i, j].x] == buildingIndex)
{
base_squares[(int)squaresToClear[i, j].y, (int)squaresToClear[i, j].x] = -1;
}
}
}
}
private static void TryToTrainCreepsFromBuilding(PlayerData _player, int id)
{
BuildingLocation location = m_locationList[id];
if (location.m_remainingBuildTime > 0)
{
return;
}
int price = GetPriceFromBuildingType(location.m_buildingType);
if (_player.m_gold >= price)
{
location.m_remainingBuildTime = GetBuildTimeFromType(location);
_player.m_gold -= price;
}
}
async Task ExecuteLocationDetailCommand(BuildingLocation parm)
{
if (parm != null)
{
// await Shell.Current.Navigation.PushAsync(new BuildingLo() { BindingContext = new ProjectDetailViewModel() { Project = Project } });
if (Shell.Current.Navigation.NavigationStack[Shell.Current.Navigation.NavigationStack.Count - 1].GetType() != typeof(BuildingLocationDetail))
{
await Shell.Current.Navigation.PushAsync(new BuildingLocationDetail()
{
BindingContext = new BuildingLocationDetailViewModel()
{
BuildingLocation = parm
}
});
}
}
}
static private void SpawnTwinLocationsWithOffset(int _x, int _y)
{
Random random = RefereeData.m_random;
_x = random.Next(_x - 10, _x + 10);
_y = random.Next(_y - 10, _y + 10);
Vector2 centerOfMap = new Vector2(RefereeData.m_fieldWidth / 2, RefereeData.m_fieldHeight / 2);
float distanceToCenter = Vector2.GetDistance(centerOfMap, new Vector2(_x, _y)).GetLength();
int distanceBonus = 0;
if (distanceToCenter <= 500 * 500)
{
++distanceBonus;
}
if (distanceToCenter <= 200 * 200)
{
++distanceBonus;
}
int randomRadius = random.Next(m_locationMinRadius, m_locationMaxRadius);
int randomGoldValue = random.Next(200, 250) + (50 * distanceBonus);
int maximumMiningRate = random.Next(1, 3) + distanceBonus;
BuildingLocation newBuildingLocation = new BuildingLocation(m_siteIdCount, _x, _y, randomRadius);
newBuildingLocation.m_buildingType = BuildingType.NONE;
newBuildingLocation.m_allianceType = AllianceType.NEUTRAL;
newBuildingLocation.m_goldRemaining = randomGoldValue;
newBuildingLocation.m_maxYield = maximumMiningRate;
m_locationList.Add(newBuildingLocation);
++m_siteIdCount;
BuildingLocation twinBuildingLocation = new BuildingLocation(m_finalLocationCount - m_siteIdCount,
RefereeData.m_fieldWidth - _x, RefereeData.m_fieldHeight - _y, randomRadius);
twinBuildingLocation.m_buildingType = BuildingType.NONE;
twinBuildingLocation.m_allianceType = AllianceType.NEUTRAL;
twinBuildingLocation.m_goldRemaining = randomGoldValue;
twinBuildingLocation.m_maxYield = maximumMiningRate;
m_locationList.Add(twinBuildingLocation);
}
private static int GetBuildTimeFromType(BuildingLocation location)
{
switch (location.m_buildingType)
{
case BuildingType.BARRACKS_KNIGHT:
return(5);
case BuildingType.BARRACKS_ARCHER:
return(8);
case BuildingType.BARRACKS_GIANT:
return(10);
default:
return(0);
}
}
static private void CreateQueens()
{
BuildingLocation queenSpawnLocation = m_locationList[0];
Vector2 firstQueenPos = queenSpawnLocation.m_position;
firstQueenPos.y = queenSpawnLocation.m_position.y + (queenSpawnLocation.m_radius);
m_player1Queen = new Unit((int)firstQueenPos.x, (int)firstQueenPos.y, AllianceType.FRIENDLY, UnitType.QUEEN);
m_player1Queen.m_radius = 30;
m_unitList.Add(m_player1Queen);
BuildingLocation enemySpawnLocation = m_locationList.Last();
Vector2 secondQueenPos = enemySpawnLocation.m_position;
secondQueenPos.y = enemySpawnLocation.m_position.y - (enemySpawnLocation.m_radius);
m_player2Queen = new Unit((int)secondQueenPos.x, (int)secondQueenPos.y, AllianceType.HOSTILE, UnitType.QUEEN);
m_player2Queen.m_radius = 30;
m_unitList.Add(m_player2Queen);
}
public bool EmptySpot(int buildingIndex)
{
BuildingLocation location = new BuildingLocation(buildings[buildingIndex].transform.position.x, buildings[buildingIndex].transform.position.y, buildings[buildingIndex].transform.position.z);
Vector2[,] buildingSquares = FindBuildingSquares(buildingIndex, location);
for (int i = 0; i < buildingsDimensions[buildingIndex].zWidth; i++)
{
for (int j = 0; j < buildingsDimensions[buildingIndex].xLength; j++)
{
if (base_squares[(int)buildingSquares[i, j].y, (int)buildingSquares[i, j].x] != -1 &&
base_squares[(int)buildingSquares[i, j].y, (int)buildingSquares[i, j].x] != buildingIndex)
{
buildingBasisMeshRenderers[buildingIndex].material = red;
return(false);
}
}
}
buildingBasisMeshRenderers[buildingIndex].material = green;
return(true);
}
internal static void Build(AllianceType _allianceType, int siteId, BuildingType _type)
{
BuildingLocation location = m_locationList[siteId];
if (_allianceType != location.m_allianceType && location.m_buildingType == BuildingType.TOWER)
{
return;
}
if (_allianceType == location.m_allianceType && _type == location.m_buildingType)
{
if (location.m_buildingType == BuildingType.MINE)
{
++location.m_level;
if (location.m_level > location.m_maxYield)
{
location.m_level = location.m_maxYield;
}
}
else if (location.m_buildingType == BuildingType.TOWER)
{
location.m_level += 100;
if (location.m_level > 800)
{
location.m_level = 800;
}
}
}
else
{
location.Reset();
location.m_allianceType = _allianceType;
location.m_buildingType = _type;
if (location.m_buildingType == BuildingType.TOWER)
{
location.m_level = 100;
}
}
}
public async Task <BuildingLocation> GetItemAsync(string id)
{
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(App.AzureBackendUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
using (HttpResponseMessage response = await client.GetAsync($"api/BuildingLocation/GetBuildingLocationByID?Id=" + id))
{
var responseBody = await response.Content.ReadAsStringAsync();
Response result = JsonConvert.DeserializeObject <Response>(responseBody);
BuildingLocation location = JsonConvert.DeserializeObject <BuildingLocation>(result.Data.ToString());
response.EnsureSuccessStatusCode();
return(await Task.FromResult(location));
}
}
}
//-----------------------------------------------------------------------------------------
//private void Renew()
//{
// buildingsLocations[0] = new BuildingLocation(10.5f, 0, 10.5f);
// buildingsLocations[1] = new BuildingLocation(-10.5f, 0, 10.5f);
// buildingsLocations[2] = new BuildingLocation(-10.5f, 0, -10.5f);
// buildingsLocations[3] = new BuildingLocation(10.5f, 0, -10.5f);
// for (int i = 0; i < baseGridDimensionZ_p + baseGridDimensionZ_n; i++)
// {
// for (int j = 0; j < baseGridDimensionX_p + baseGridDimensionX_n; j++)
// {
// if (i >= 14 && i <= 25)
// {
// base_squares[i, j] = -2; // kelias ir sienos
// }
// else
// {
// base_squares[i, j] = -1;
// }
// }
// }
// FillSquares(0, buildingsLocations[0]);
// FillSquares(1, buildingsLocations[1]);
// FillSquares(2, buildingsLocations[2]);
// FillSquares(3, buildingsLocations[3]);
//}
private void Renew()
{
for (int i = 0; i < numberOfBuildings; i++)
{
buildingsLocations[i] = new BuildingLocation(0, -100, 0);
}
for (int i = 0; i < baseGridDimensionZ_p + baseGridDimensionZ_n; i++)
{
for (int j = 0; j < baseGridDimensionX_p + baseGridDimensionX_n; j++)
{
if (i >= 14 && i <= 25)
{
base_squares[i, j] = -2; // kelias ir sienos
}
else
{
base_squares[i, j] = -1;
}
}
}
AddAndRemove.instance.ChangeMoneyValue(100000);
}
public static void Postfix(Turret __instance, BuildingLocation location, float damage, WeaponHitInfo hitInfo)
{
Mod.Log.Trace("T:ASSD - entered.");
if (ModState.BreachCheck == 0f)
{
return;
} // nothing to do
if (hitInfo.attackSequenceId != ModState.BreachAttackId)
{
Mod.Log.Error("INCOHERENT ATTACK SEQUENCE- SKIPPING!");
return;
}
Mod.Log.Debug($" --- Location: {location} needs breach check.");
if (ModState.BreachHitsTurret.ContainsKey(location))
{
ModState.BreachHitsTurret[location]++;
}
else
{
ModState.BreachHitsTurret.Add(location, 1);
}
}
public static void Postfix(Turret __instance, BuildingLocation location, float damage, WeaponHitInfo hitInfo)
{
Mod.Log.Trace?.Write("T:ASSD - entered.");
if (ModState.BreachCheck == 0f || ModState.BreachAttackId == ModState.NO_ATTACK_SEQUENCE_ID)
{
return;
} // nothing to do
if (hitInfo.attackSequenceId != ModState.BreachAttackId)
{
Mod.Log.Warn?.Write($"AttackSequenceId: {hitInfo.attackSequenceId} does not match hull breach attack sequence id: {ModState.BreachAttackId}... wasn't expecting this, skipping!");
return;
}
Mod.Log.Debug?.Write($" --- Location: {location} needs breach check.");
if (ModState.BreachHitsTurret.ContainsKey(location))
{
ModState.BreachHitsTurret[location]++;
}
else
{
ModState.BreachHitsTurret.Add(location, 1);
}
}
internal static bool DamageLocation(this Turret turret, WeaponHitInfo hitInfo, BuildingLocation bLoc, Weapon weapon, float totalDamage)
{
return(Traverse.Create(turret).Method(nameof(DamageLocation), hitInfo, bLoc, weapon, totalDamage).GetValue <bool>());
}
