protected override bool DoResourceCalculations (ResourceTileSelection selection)
{
bool success = base.DoResourceCalculations (selection);
if (success) {
GameManager.economyController.IncreasePendingBalance(Player.CharacterClass.Conservationist, cost*selection.Count());
}
return success;
}
public void OnSelectionChanged(ResourceTileSelection selection)
{
List<int> ids = new List<int>(selection.resource_tile_ids);
if (tileIds.Count == ids.Count) {
return;
}
if (ids.Count <= 0) {
FloodFill();
} else {
if (tileIds.Count < ids.Count) {
tileIds = ids;
}
TerrainManager.Status status;
ResourceTileLite[] tiles = TerrainManager.GetResourceTileCacheGroup(out status,tileIds.ToArray());
if (status == TerrainManager.Status.Succeeded) {
Region region = new Region(tiles);
region.ToTerrainRegion(out region);
PaintRegion(region);
}
}
tileIds = ids;
}
/// <summary>
/// Forces a put of resource tile modifications using god mode.
/// </summary>
/// <remarks>
/// This is a temporary solution for implementing actions with no server API point, and can eventually be removed.
/// </remarks>
/// <param name='selection'>
/// The selection.
/// </param>
protected override IEnumerator Put(ResourceTileSelection selection)
{
m_actionProgress = 0f;
string url;
List<ResourceTile> tiles = new List<ResourceTile>();
float div = 1f/selection.Count();
for (int i=0; i<selection.Count(); ++i) {
int id = selection[i];
// get url for current tile
url = WebRequests.GetURLToResourceTile(id);
// get current tile to determine supported saplings
WWW www = WWWX.Get(url, WebRequests.authenticatedGodModeParameters);
while (!www.isDone) {
m_actionProgress = (i+www.progress*0.3f)*div; // about 30% done
yield return 0;
}
ResourceTile tile = JSONDecoder.Decode<IndividualResourceTile>(www.text).resource_tile;
m_tileModifications.resource_tile = new ModifiedFields(tile.supportedSaplings);
// add new trees
www = WWWX.Put(url, GetActionJson(), WebRequests.authenticatedGodModeParameters);
while (!www.isDone) {
m_actionProgress = (i+0.3f+www.progress*0.7f)*div; // about 70% done
yield return 0;
}
// get the results back and append to array
www = WWWX.Get(url, WebRequests.authenticatedGodModeParameters);
while (!www.isDone) {
m_actionProgress = (i+0.7f+www.progress+0.3f)*div; // all the way done
yield return 0;
}
try {
tiles.Add(JSONDecoder.Decode<IndividualResourceTile>(www.text).resource_tile);
}
catch (JsonException) {
Debug.LogError(www.text);
}
}
// ConcludeActionOnResourceTiles(tiles.ToArray());
}
/// <summary>
/// Gets the do it WWW object.
/// </summary>
/// <returns>
/// The do it WWW object.
/// </returns>
/// <param name='selection'>
/// Selection.
/// </param>
override protected WWW GetDoItWWW(ResourceTileSelection selection)
{
string url = string.Format("{0}/worlds/{1}/resource_tiles/bulldoze.json", WebRequests.urlServer, UserData.worldNumber);
return WWWX.Post(url, selection.ToJson(), WebRequests.authenticatedParameters);
}
protected override bool DoResourceCalculations (ResourceTileSelection selection)
{
bool success = base.DoResourceCalculations (selection);
if (success) {
//Calculate Tree usage
if (GameManager.worldData.timber_count >= selection.Count() * 15) {
GameManager.economyController.UseTimber(selection.Count()*15);
GameManager.economyController.IncreasePendingBalance(Player.CharacterClass.TimberCompany,
selection.Count() * EconomyController.timberRate * 15);
} else {
GameGUIManager.use.SetErrorMessage("There is not enough timber available to build.");
GameGUIManager.use.PlayInvalidActionSound();
return false;
}
}
return success;
}
/// <summary>
/// Submits the resource tile selection to server API.
/// </summary>
/// <remarks>
/// This differs from the base implementation because the API returns timber values, not modified resource tiles
/// </remarks>
/// <returns>
/// The resource tile selection to server API.
/// </returns>
/// <param name='selection'>
/// The resource tile selection.
/// </param>
protected override IEnumerator SubmitResourceTileSelectionToServerAPI(ResourceTileSelection selection)
{
//HACK -- HACK -- HACK -- HACK
/*selection = FilterSelection(selection);
if (selection.Count() <= 0) {
Debug.LogError("No tiles in the selection can have an action performed on them.");
yield break;
}*/
//END HACK
// initialize a clearcut
Harvest harvest = new Harvest(selection.ToArray(), 1);
// configure harvest to perform
if (m_cutType == CutType.DiameterLimitCut) {
harvest = new Harvest(
selection.ToArray(), 1,
m_diameterLimit, m_diameterLimitDirection
);
} else if (m_cutType == CutType.QRatioCut) {
harvest = new Harvest(
selection.ToArray(), 1,
m_qRatio, m_basalArea
);
}
// perform harvest (50% of action progress)
StartCoroutine(harvest.DoIt());
while (harvest.progress < 1f) {
m_actionProgress = 0.5f*harvest.progress;
if (!string.IsNullOrEmpty(harvest.doItError)) {
Debug.LogError(harvest.doItError);
StartCoroutine(RefreshAfterActionFailed(harvest.doItError));
yield break;
}
yield return 0;
}
// get updated tiles (100% of action progress)
/*List<ResourceTile> tiles = new List<ResourceTile>();
float div = 1f/selection.Count();
HTTP.Request request;
for (int i=0; i<selection.Count(); ++i) {
int id = selection[i];
request = new HTTP.Request( "Get", WebRequests.GetURLToResourceTile(id) );
request.AddParameters( WebRequests.authenticatedParameters );
request.Send();
while (!request.isDone) {
//m_actionProgress = 0.5f*(1f+(i+www.progress)*div);
yield return 0;
}
if( request.ProducedError ) {
m_actionProgress = 1f;
yield break;
}
try {
tiles.Add(JSONDecoder.Decode<IndividualResourceTile>(request.response.Text).resource_tile);
}
catch (JsonException) {
//Debug.LogError(www.text);
}
}*/
// conclude the action
ConcludeActionOnResourceTiles(selection);
GameManager.use.worldDataIsValid = false;
TerrainManager.use.RefreshFromIds(selection.resource_tile_ids.ToArray());
IEnumerator e = WebRequests.DownloadPlayerData(Player.current);
while (e.MoveNext()) {
yield return 0;
}
}
/// <summary>
/// HACK
/// </summary>
/// <returns>
/// The selection.
/// </returns>
/// <param name='selection'>
/// Selection.
/// </param>
protected ResourceTileSelection FilterSelection(ResourceTileSelection selection) {
//Filter out tiles we cannot use
TerrainManager.Status status = TerrainManager.Status.Succeeded;
ResourceTileLite[] tiles = TerrainManager.GetResourceTileCacheGroup(out status,selection.resource_tile_ids.ToArray());
ResourceTileSelection newSelection = new ResourceTileSelection(new List<int>());
foreach(ResourceTileLite tile in tiles) {
if(tile.IsActionPermitted(this)) {
newSelection.Add(tile.id);
}
}
return newSelection;
}
/// <summary>
/// Refreshs the data for selection.
/// </summary>
/// <param name='selection'>
/// The selection.
/// </param>
private IEnumerator RefreshDataForSelection(ResourceTileSelection selection)
{
// TODO: this is temporary. it should actually get back survey data.
isDirty = false; // set this now so multiple downloads dont happen
WWW www;
int[] frequencyDistribution = new int[ResourceTile.treeSizeClassCount];
int[] knownFreqDistribution = new int[ResourceTile.treeSizeClassCount];
m_refreshDownloadProgress = 0f;
float div = 1f/selection.Count();
for (int i=0; i<selection.Count(); ++i) {
int id = selection[i];
www = WWWX.Get(WebRequests.GetURLToResourceTile(id), WebRequests.authenticatedGodModeParameters);
while (!www.isDone) {
m_refreshDownloadProgress = (i+www.progress)*div;
yield return 0;
}
if (!string.IsNullOrEmpty(www.error)) {
Debug.LogError(www.error);
continue;
}
ResourceTile tile;
try {
tile = JSONDecoder.Decode<IndividualResourceTile>(www.text).resource_tile;
}
catch (JsonException e) {
Debug.LogError(e);
continue;
}
for (int j=0; j<ResourceTile.treeSizeClassCount; ++j) {
if (tile.bought_by_timber_company) {
knownFreqDistribution[j] += tile.treeDistribution[j];
}
frequencyDistribution[j] += tile.treeDistribution[j];
}
}
m_knownFrequencyDistributionOfSelectedTiles = knownFreqDistribution;
m_actualFrequencyDistributionOfSelectedTiles = frequencyDistribution;
m_refreshDownloadProgress = 1f;
}
protected override WWW GetDoItWWW (ResourceTileSelection selection)
{
string url = string.Format("{0}build_outpost.json",WebRequests.GetResourceTileURL(selection[selection.Count()-1]));
Debug.Log(url);
return WWWX.Post(url,WebRequests.authenticatedParameters);
}
/// <summary>
/// Submits the resource tile selection.
/// </summary>
/// <remarks>
/// NOTE: This may need a more sophisticated implementation if e.g., player action changes before server responds.
/// </remarks>
/// <param name='selection'>
/// The resource tile selection.
/// </param>
protected void SubmitResourceTileSelection(ResourceTileSelection selection)
{
if (selection.Count() == 0) {
GameGUIManager.use.SetErrorMessage("No tiles selected.");
return;
}
if (isActionInProgress) {
GameGUIManager.use.PlayInvalidActionSound();
return;
}
//Check Resources
/*
if (!DoResourceCalculations(selection)) {
return;
}*/
// if there is no API point, use the god mode implementation
if (!hasServerAPIPoint) {
StartCoroutine(Put(selection));
}
// otherwise use the api point on the server
else {
StartCoroutine(SubmitResourceTileSelectionToServerAPI(selection));
}
}
/// <summary>
/// Gets the effect spawn locations from resource tiles.
/// </summary>
/// <returns>
/// The effect spawn locations from resource tiles.
/// </returns>
/// <param name='selection'>
/// Tiles.
/// </param>
protected Vector3[] GetEffectSpawnLocationsFromResourceTiles(ResourceTileSelection selection)
{
System.Collections.Generic.List<Vector3> spawnLocations = new System.Collections.Generic.List<Vector3>();
TerrainManager.Status status = TerrainManager.Status.Failed;
foreach (ResourceTileLite tile in TerrainManager.GetResourceTileCacheGroup(out status, selection.resource_tile_ids.ToArray())) {
spawnLocations.Add(tile.GetCenterPoint());
}
return spawnLocations.ToArray();
}
/// <summary>
/// Concludes the action on resource tiles.
/// </summary>
/// <param name='selection'>
/// Tiles.
/// </param>
protected void ConcludeActionOnResourceTiles(ResourceTileSelection selection)
{
// set the action progress to complete
m_actionProgress = 1f;
// get the effect spawn locations
Vector3[] spawnLocations = GetEffectSpawnLocationsFromResourceTiles(selection);
// refresh the tiles using the new data
//TerrainManager.use.SetTerrainFromResourceTiles(tiles, SetTerrainMode.Flush);
// filter the current selection
//InputManager.use.FilterSelection(); // TODO: this may need to be more sophisticated
InputManager.use.ClearResourceTileSelection();
// Spawn effects
SpawnEffectsAtLocations(spawnLocations);
//Send the Action done message
// SendActionMessage(selection);
}
protected virtual bool DoResourceCalculations(ResourceTileSelection selection)
{
//Make sure we have enough money to perform the action
TerrainManager.Status status = TerrainManager.Status.Failed;
ResourceTileLite[] tiles = TerrainManager.GetResourceTileCacheGroup(out status, selection.resource_tile_ids.ToArray());
if (status == TerrainManager.Status.Failed) {
Debug.LogError("Invalid tiles were part of the selection! o_o");
return false;
}
int cost = CalculateCost(tiles);
if (GameManager.economyController.IsBalanceAvailable(cost)) {
//Spend the money
GameManager.economyController.SpendMoney(cost);
} else {
GameGUIManager.use.SetErrorMessage("You do not have enough money to perform this action.");
GameGUIManager.use.PlayInvalidActionSound();
return false;
}
return true;
}
/// <summary>
/// Forces a put of resource tile modifications using god mode.
/// </summary>
/// <remarks>
/// This is a temporary solution for implementing actions with no server API point, and can eventually be removed.
/// </remarks>
/// <param name='selection'>
/// The selection.
/// </param>
protected virtual IEnumerator Put(ResourceTileSelection selection)
{
HTTP.Request request;
m_actionProgress = 0f;
string json = GetActionJson();
Debug.Log(json);
List<ResourceTile> tiles = new List<ResourceTile>();
float div = 1f/selection.Count();
for (int i=0; i<selection.Count(); ++i) {
int id = selection[i];
request = new HTTP.Request( "Put", WebRequests.GetURLToResourceTile(id) );
request.SetText( json );
request.AddParameters( WebRequests.authenticatedGodModeParameters );
request.Send();
while (!request.isDone) {
//m_actionProgress = (i+www.uploadProgress)*div;
yield return 0;
}
if( request.ProducedError ) {
m_actionProgress = 1f;
yield break;
}
try {
tiles.Add(JSONDecoder.Decode<IndividualResourceTile>(request.response.Text).resource_tile);
}
catch (JsonException) {
Debug.LogError(request.response.Text);
}
}
// ConcludeActionOnResourceTiles(tiles.ToArray());
//Update the world
IEnumerator e = WebRequests.RefreshWorldData(new WebCoroutine());
yield return e.Current;
while(e.MoveNext()) yield return e.Current;
}
/// <summary>
/// Submits the resource tile selection to server API.
/// </summary>
/// <returns>
/// The resource tile selection to server API.
/// </returns>
/// <param name='selection'>
/// The resource tile selection.
/// </param>
protected virtual IEnumerator SubmitResourceTileSelectionToServerAPI(ResourceTileSelection selection)
{
WWW www = GetDoItWWW((ResourceTileSelection)selection);
while (!www.isDone) {
m_actionProgress = 0.5f*(www.uploadProgress+www.progress);
yield return 0;
}
// see if there was an error
if (!string.IsNullOrEmpty(www.error)) {
Debug.LogError(www.error);
yield return StartCoroutine(RefreshAfterActionFailed(www.error));
m_actionProgress = 1f;
yield break;
}
// deserialize the retrieved resource tile list
ResourceTiles tiles;
try {
tiles = JSONDecoder.Decode<ResourceTiles>(www.text);
}
catch (JsonException) {
Debug.LogError(www.text);
StartCoroutine(RefreshAfterActionFailed("Error parsing server response."));
m_actionProgress = 1f;
yield break;
}
// conclude the action
//ConcludeActionOnResourceTiles(tiles.ToArray());
// refresh other data as needed
yield return StartCoroutine(Refresh());
//Update the world
IEnumerator e = WebRequests.RefreshWorldData(new WebCoroutine());
yield return e.Current;
while(e.MoveNext()) yield return e.Current;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceTileSelection.Enumerator"/> class.
/// </summary>
/// <param name='selection'>
/// Selection.
/// </param>
public Enumerator(ResourceTileSelection selection) {
resourceTileSelection = selection;
i = -1;
}
/// <summary>
/// Gets the do it WWW.
/// </summary>
/// <returns>
/// The do it WWW.
/// </returns>
/// <param name='selection'>
/// The selection.
/// </param>
virtual protected WWW GetDoItWWW(ResourceTileSelection selection)
{
return null;
}
