public BuildingPromptItem(int townID, int hexaID, BuildingKind kind, String title, String description, SourceAll source, bool isSourceCost, Texture2D icon)
: base(title, description, source, isSourceCost, false, icon)
{
this.townID = townID;
this.hexaID = hexaID;
this.kind = kind;
}
public bool BuildBuildingInTown(int townID, int hexaID, BuildingKind kind)
{
GameMaster gm = GameMaster.Inst();
TownModel town = map.GetTownByID(townID);
if (town == null)
return false;
int buildingPos = town.FindBuildingByHexaID(hexaID);
if (buildingPos == -1)
return false;
BuildingBuildError error = CanBuildBuildingInTown(townID, hexaID, kind);
if (error == BuildingBuildError.OK)
{
ItemQueue item = new BuildingItemQueue(mapView, townID, buildingPos);
mapView.AddToViewQueue(item, gm.GetState() == EGameState.BeforeGame);
if (gm.GetState() != EGameState.BeforeGame)
{
gm.GetActivePlayer().PayForSomething(town.GetBuildingCost(buildingPos, kind));
}
town.BuildBuilding(buildingPos, kind);
TriggerManager.Inst().TurnTrigger(TriggerType.BuildingBuild, (int) kind);
return true;
}
return false;
}
public ISpecialBuildingGet BuildBuilding(int pos, BuildingKind kind)
{
buildingKind[pos] = kind;
switch (kind)
{
case BuildingKind.SourceBuilding :
building[pos] = new SourceBuildingModel(playerOwner, townID, hexaNeighbour[pos].GetID());
switch (hexaNeighbour[pos].GetKind())
{
case HexaKind.Cornfield: playerOwner.AddBuilding(Building.Mill); break;
case HexaKind.Pasture: playerOwner.AddBuilding(Building.Stepherd); break;
case HexaKind.Stone: playerOwner.AddBuilding(Building.Quarry); break;
case HexaKind.Forest: playerOwner.AddBuilding(Building.Saw); break;
case HexaKind.Mountains: playerOwner.AddBuilding(Building.Mine); break;
}
break;
case BuildingKind.MarketBuilding :
MarketModel marketModel = new MarketModel(playerOwner, townID, hexaNeighbour[pos].GetID());
building[pos] = marketModel;
playerOwner.AddBuilding(Building.Market);
playerOwner.AddPoints(PlayerPoints.Market);
playerOwner.AddMarket(marketModel);
break;
case BuildingKind.MonasteryBuilding :
MonasteryModel monasteryModel = new MonasteryModel(playerOwner, townID, hexaNeighbour[pos].GetID());
building[pos] = monasteryModel;
playerOwner.AddBuilding(Building.Monastery);
playerOwner.AddPoints(PlayerPoints.Monastery);
playerOwner.AddMonastery(monasteryModel);
break;
case BuildingKind.FortBuilding :
FortModel fortModel = new FortModel(playerOwner, townID, hexaNeighbour[pos].GetID());
building[pos] = fortModel;
playerOwner.AddBuilding(Building.Fort);
playerOwner.AddPoints(PlayerPoints.Fort);
playerOwner.AddFort(fortModel);
break;
}
return building[pos];
}
public SourceAll GetBuildingCost(int pos, BuildingKind kind)
{
SourceAll cost = new SourceAll(0);
switch (kind)
{
case BuildingKind.SourceBuilding:
cost = (SourceAll) hexaNeighbour[pos].GetSourceBuildingCost();
break;
case BuildingKind.FortBuilding:
cost = Settings.costFort;
break;
case BuildingKind.MarketBuilding:
cost = Settings.costMarket;
break;
case BuildingKind.MonasteryBuilding:
cost = Settings.costMonastery;
break;
}
return cost;
}
public BuildingBuildError CanActivePlayerBuildBuildingInTown(int pos, BuildingKind kind)
{
GameMaster gm = GameMaster.Inst();
SourceAll cost = GetBuildingCost(pos, kind);
if (gm.GetState() == EGameState.StateGame)
{
if (buildingKind[pos] != BuildingKind.NoBuilding)
{
GameState.map.GetMapController().SetLastError(Strings.ERROR_ALREADY_BUILD);
return BuildingBuildError.AlreadyBuild;
}
if (gm.GetActivePlayer() != playerOwner)
{
GameState.map.GetMapController().SetLastError(Strings.ERROR_NO_OWNER);
return BuildingBuildError.NotOwner;
}
if (!cost.HasPlayerSources(gm.GetActivePlayer()))
{
GameState.map.GetMapController().SetLastError(Strings.ERROR_NO_SOURCES);
return BuildingBuildError.NoSources;
}
if (cost == new SourceAll(0))
{
// WHAT?
}
return BuildingBuildError.OK;
}
return BuildingBuildError.NoSources;
}
public BuildingBuildError CanBuildBuildingInTown(int townID, int hexaID, BuildingKind kind)
{
GameMaster gm = GameMaster.Inst();
if (gm.GetState() == EGameState.BeforeGame)
return BuildingBuildError.OK;
if (kind == BuildingKind.FortBuilding && Settings.banFort)
{
SetLastError(Strings.ERROR_BAN_FORT);
return BuildingBuildError.Ban;
}
if (kind == BuildingKind.MarketBuilding && Settings.banMarket)
{
SetLastError(Strings.ERROR_BAN_MARKET);
return BuildingBuildError.Ban;
}
if (kind == BuildingKind.MonasteryBuilding && Settings.banMonastery)
{
SetLastError(Strings.ERROR_BAN_MONASTERY);
return BuildingBuildError.Ban;
}
TownModel town = map.GetTownByID(townID);
if (town == null)
{
SetLastError(Strings.ERROR_INVALID_TOWN_ID);
return BuildingBuildError.InvalidTownID;
}
int buildingPos = town.FindBuildingByHexaID(hexaID);
if (buildingPos == -1)
{
SetLastError(Strings.ERROR_INVALID_HEXA_ID);
return BuildingBuildError.TownHasNoHexaWithThatHexaID;
}
HexaModel hexa = town.GetHexa(buildingPos);
if (hexa.GetKind() == HexaKind.Desert && kind == BuildingKind.SourceBuilding)
{
SetLastError(Strings.ERROR_NO_SOURCE_BUILDING_FOR_DESERT);
return BuildingBuildError.NoSourceBuildingForDesert;
}
if (hexa.GetKind() == HexaKind.Water)
{
SetLastError(Strings.ERROR_NO_BUILDING_FOR_WATER);
return BuildingBuildError.NoBuildingForWater;
}
if (hexa.GetKind() == HexaKind.Mountains && kind != BuildingKind.SourceBuilding)
{
SetLastError(Strings.ERROR_NO_SPECIAL_BUIDLING_FOR_MOUNTAINS);
return BuildingBuildError.NoSpecialBuildingForMountains;
}
return town.CanActivePlayerBuildBuildingInTown(buildingPos, kind);
}
