GameObject ResourceSet(BuildKind buildKind)
{
if (buildKind == BuildKind.집)
{
Debug.Log("집은 자원생성이 아닙니다.");
return(null);
}
GameObject obj = null;
switch (buildKind)
{
case BuildKind.우물:
obj = Instantiate(waterObj, Vector3.zero, Quaternion.identity, grid);
break;
case BuildKind.농장:
obj = Instantiate(foodObj, Vector3.zero, Quaternion.identity, grid);
break;
case BuildKind.발전소:
obj = Instantiate(energyObj, Vector3.zero, Quaternion.identity, grid);
break;
}
return(obj);
}
public void OnClickBuild()
{
int needGold = GoldParser.instance.GetNeedGold(count);
int myGold = InGame.instance.GetResource(BuildKind.집);
if (myGold < needGold)
{
Debug.Log("돈이 부족합니다.");
Debug.Log("필요골드 : " + needGold + " 소지 골드 : " + myGold);
return;
}
else
{
InGame.instance.SetResource(BuildKind.집, myGold - needGold);
}
int energyApearTime = ConfigParser.instance.config.EnergyAppearTime_Sec;
int maxRandomBuildKind = 3;
if (energyApearTime < Time.instance.GetTime())
{
maxRandomBuildKind = 4;
}
int randomBuildKind = Random.Range(0, maxRandomBuildKind);
BuildKind buildKind = (BuildKind)System.Enum.ToObject(typeof(BuildKind), randomBuildKind);
map.CreateBuild(buildKind, 1);
MyGold.instance.TextSet();
}
public int GetBuidResouceIncrease(BuildKind buildKind, int level)
{
for (int i = 0; i < buildList.Length; i++)
{
if (buildList[i].buildKind == buildKind && buildList[i].level == level)
{
return(buildList[i].Increase);
}
}
return(0);
}
public void SetResource(BuildKind buildKind, int resource)
{
switch (buildKind)
{
case BuildKind.집:
gold = resource;
MyGold.instance.TextSet();
break;
case BuildKind.우물:
if (resource < 0)
{
GameOver();
return;
}
if (resource > maxWater)
{
resource = maxWater;
}
water = resource;
break;
case BuildKind.농장:
if (resource < 0)
{
GameOver();
return;
}
if (resource > maxFood)
{
resource = maxFood;
}
food = resource;
break;
case BuildKind.발전소:
if (resource < 0)
{
GameOver();
return;
}
if (resource > maxEnergy)
{
resource = maxEnergy;
}
energy = resource;
break;
default:
break;
}
}
void CreateResource(BuildKind buildKind)
{
if (build.Contains(buildKind))
{
return;
}
else
{
build.Add(buildKind);
resourceCoroutine.Add(ResourceCoroutine(buildKind));
StartCoroutine(resourceCoroutine[resourceCoroutine.Count - 1]);
}
}
IEnumerator ResourceCoroutine(BuildKind buildKind, int level)
{
int time = (int)Time.instance.GetTime();
WaitForSeconds wait = new WaitForSeconds(0.02f);
while (true)
{
if ((int)Time.instance.GetTime() > time)
{
time++;
InGame.instance.SetResource(buildKind, InGame.instance.GetResource(buildKind) + BuildParser.instance.GetBuidResouceIncrease(buildKind, level));
}
yield return(wait);
}
}
public void MergeBuild(int index01, int index02)
{
// 건물과 레벨이 같다면 합병
if (buildKinds[index01].buildKind == buildKinds[index02].buildKind &&
buildKinds[index01].level == buildKinds[index02].level)
{
BuildKind tempBuildKind = buildKinds[index01].buildKind;
int tempLevel = buildKinds[index01].level + 1;
DeleteBuild(index01);
DeleteBuild(index02);
CreateBuild(tempBuildKind, tempLevel);
}
SetBuild();
}
IEnumerator ResourceCoroutine(BuildKind buildKind)
{
GameObject obj = ResourceSet(buildKind);
if (obj == null)
{
yield break;
}
int time = (int)Time.instance.GetTime();
WaitForSeconds wait = new WaitForSeconds(0.02f);
while (true)
{
if ((int)Time.instance.GetTime() > time)
{
time++;
int cost = CostParser.instance.GetCost(time, buildKind);
InGame.instance.SetResource(buildKind, InGame.instance.GetResource(buildKind) - cost);
int current = InGame.instance.GetResource(buildKind);
int max = InGame.instance.GetMaxResource(buildKind);
float fillAmount = current / (float)max;
obj.transform.Find("img").GetChild(0).GetComponent <Image>().DOFillAmount(fillAmount, 0.2f);
for (int i = 0; i < grid.childCount; i++)
{
bool isIncrease = IsUpResource(grid.GetChild(i).GetComponent <ResourcePrepab>().buildKind);
switch (isIncrease)
{
case true:
grid.GetChild(i).GetComponent <ResourcePrepab>().SetIncrease();
break;
case false:
grid.GetChild(i).GetComponent <ResourcePrepab>().SetDecrease();
break;
}
}
}
yield return(wait);
}
}
/// <summary>
/// Called when a build has started
/// </summary>
/// <param name="kind"></param>
/// <returns></returns>
public static bool StartBuild(BuildKind kind)
{
if (!BuildStatus.currentBuild.HasValue)
{
lock(BuildStatus.Mutex)
{
BuildStatus.currentBuild = kind;
}
return true;
}
BuildKind currentBuildKind = BuildStatus.currentBuild.Value;
switch (currentBuildKind)
{
case BuildKind.Sync:
// Attempt to start a build during sync build indicate reentrancy
Debug.Fail("Message pumping during sync build");
return false;
case BuildKind.Async:
if (kind == BuildKind.Sync)
{
// if we need to do a sync build during async build, there is not much we can do:
// - the async build is user-invoked build
// - during that build UI thread is by design not blocked and messages are being pumped
// - therefore it is legitimate for other code to call Project System APIs and query for stuff
// In that case we just fail gracefully
return false;
}
else
{
// Somebody attempted to start a build while build is in progress, perhaps and Addin via
// the API. Inform them of an error in their ways.
throw new InvalidOperationException("Build is already in progress");
}
default:
Debug.Fail("Unreachable");
return false;
}
}
/// <summary>
/// Called when a build has started
/// </summary>
/// <param name="kind"></param>
/// <returns></returns>
public static bool StartBuild(BuildKind kind)
{
if (!BuildStatus.currentBuild.HasValue)
{
lock (BuildStatus.Mutex)
{
BuildStatus.currentBuild = kind;
}
return(true);
}
BuildKind currentBuildKind = BuildStatus.currentBuild.Value;
switch (currentBuildKind)
{
case BuildKind.Sync:
// Attempt to start a build during sync build indicate reentrancy
Debug.Fail("Message pumping during sync build");
return(false);
case BuildKind.Async:
if (kind == BuildKind.Sync)
{
// if we need to do a sync build during async build, there is not much we can do:
// - the async build is user-invoked build
// - during that build UI thread is by design not blocked and messages are being pumped
// - therefore it is legitimate for other code to call Project System APIs and query for stuff
// In that case we just fail gracefully
return(false);
}
else
{
// Somebody attempted to start a build while build is in progress, perhaps and Addin via
// the API. Inform them of an error in their ways.
throw new InvalidOperationException("Build is already in progress");
}
default:
Debug.Fail("Unreachable");
return(false);
}
}
public int GetMaxResource(BuildKind buildKind)
{
switch (buildKind)
{
case BuildKind.집:
return(1000000);
case BuildKind.우물:
return(maxWater);
case BuildKind.농장:
return(maxFood);
case BuildKind.발전소:
return(maxEnergy);
default:
return(1000000);
}
}
public int GetResource(BuildKind buildKind)
{
switch (buildKind)
{
case BuildKind.집:
return(gold);
case BuildKind.우물:
return(water);
case BuildKind.농장:
return(food);
case BuildKind.발전소:
return(energy);
default:
return(0);
}
}
public int GetCost(int currentTime, BuildKind buildKind)
{
for (int i = 0; i < costList.Length; i++)
{
if (costList[i].Time_Sec >= currentTime)
{
switch (buildKind)
{
case BuildKind.우물:
return(costList[i].WaterCost);
case BuildKind.농장:
return(costList[i].FoodCost);
case BuildKind.발전소:
return(costList[i].EnergyCost);
}
}
}
return(0);
}
public void CreateBuild(BuildKind buildKind, int level)
{
if (!IsSuccesBuild())
{
return;
}
int random = Random.Range(0, row * row);
while (buildKinds[random].level != 0)
{
random = Random.Range(0, row * row);
}
buildKinds[random].buildKind = buildKind;
buildKinds[random].level = level;
SetBuild();
resourceCoroutine[random] = ResourceCoroutine(buildKind, level);
StartCoroutine(resourceCoroutine[random]);
}
bool IsUpResource(BuildKind buildKind)
{
int increaseResource = 0;
int decreaseResource = 0;
for (int i = 0; i < map.buildKinds.Length; i++)
{
if (map.buildKinds[i] != null && map.buildKinds[i].buildKind == buildKind)
{
increaseResource += BuildParser.instance.GetBuidResouceIncrease(buildKind, map.buildKinds[i].level);
}
}
decreaseResource = CostParser.instance.GetCost((int)Time.instance.GetTime(), buildKind);
if (increaseResource < decreaseResource)
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// Start MSBuild build submission
/// </summary>
/// If buildKind is ASYNC, this method starts the submission ane returns. uiThreadCallback will be called on UI thread once submissions completes.
/// if buildKind is SYNC, this method executes the submission and runs uiThreadCallback
/// <param name="buildKind">Is it a SYNC or ASYNC build</param>
/// <param name="target">target to build</param>
/// <param name="projectInstance">project instance to build; if null, this.BuildProject.CreateProjectInstance() is used to populate</param>
/// <param name="uiThreadCallback">callback to be run UI thread </param>
/// <returns></returns>
internal virtual BuildSubmission DoMSBuildSubmission(BuildKind buildKind, string target, ref ProjectInstance projectInstance, MSBuildCoda uiThreadCallback)
{
UIThread.MustBeCalledFromUIThread();
bool designTime = BuildKind.SYNC == buildKind;
//projectInstance = null;
var accessor = (IVsBuildManagerAccessor)this.Site.GetService(typeof(SVsBuildManagerAccessor));
if (!TryBeginBuild(designTime))
{
if (null != uiThreadCallback)
{
uiThreadCallback(MSBuildResult.Failed, projectInstance);
}
return null;
}
string[] targetsToBuild = new string[target != null ? 1 : 0];
if (target != null)
{
targetsToBuild[0] = target;
}
if (null == projectInstance)
{
projectInstance = BuildProject.CreateProjectInstance();
}
projectInstance.SetProperty(GlobalProperty.VisualStudioStyleErrors.ToString(), "true");
projectInstance.SetProperty("UTFOutput", "true");
projectInstance.SetProperty(GlobalProperty.BuildingInsideVisualStudio.ToString(), "true");
this.BuildProject.ProjectCollection.HostServices.SetNodeAffinity(projectInstance.FullPath, NodeAffinity.InProc);
BuildRequestData requestData = new BuildRequestData(projectInstance, targetsToBuild, this.BuildProject.ProjectCollection.HostServices, BuildRequestDataFlags.ReplaceExistingProjectInstance);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(requestData);
try
{
if (useProvidedLogger && buildLogger != null)
{
ErrorHandler.ThrowOnFailure(accessor.RegisterLogger(submission.SubmissionId, buildLogger));
}
if (buildKind == BuildKind.ASYNC)
{
ProjectInstance projectInstanceCopy = projectInstance;
submission.ExecuteAsync(sub =>
{
UIThread.Run(() =>
{
this.FlushBuildLoggerContent();
EndBuild(sub, designTime);
uiThreadCallback((sub.BuildResult.OverallResult == BuildResultCode.Success) ? MSBuildResult.Successful : MSBuildResult.Failed, projectInstanceCopy);
});
}, null);
}
else
{
submission.Execute();
EndBuild(submission, designTime);
MSBuildResult msbuildResult = (submission.BuildResult.OverallResult == BuildResultCode.Success) ? MSBuildResult.Successful : MSBuildResult.Failed;
if (uiThreadCallback != null)
{
uiThreadCallback(msbuildResult, projectInstance);
}
}
}
catch (Exception e)
{
Debug.Fail(e.ToString());
EndBuild(submission, designTime);
if (uiThreadCallback != null)
{
uiThreadCallback(MSBuildResult.Failed, projectInstance);
}
throw;
}
return submission;
}
/// <summary>
/// Start MSBuild build submission
/// </summary>
/// If buildKind is ASync, this method starts the submission and returns. uiThreadCallback will be called on UI thread once submissions completes.
/// if buildKind is Sync, this method executes the submission and runs uiThreadCallback
/// <param name="buildKind">Is it a Sync or ASync build</param>
/// <param name="target">target to build</param>
/// <param name="projectInstance">project instance to build; if null, this.BuildProject.CreateProjectInstance() is used to populate</param>
/// <param name="uiThreadCallback">callback to be run UI thread </param>
/// <returns>A Build submission instance.</returns>
protected virtual BuildSubmission DoMSBuildSubmission(BuildKind buildKind, string target, Action<MSBuildResult, string> uiThreadCallback)
{
const bool designTime = false;
bool requiresUIThread = buildKind == BuildKind.Sync && UIThread.Instance.IsUIThread; // we don't run tasks that require calling the STA thread, so unless we're ON it, we don't need it.
IVsBuildManagerAccessor accessor = (IVsBuildManagerAccessor)this.Site.GetService(typeof(SVsBuildManagerAccessor));
if (accessor == null)
{
throw new InvalidOperationException();
}
if (!TryBeginBuild(designTime, requiresUIThread))
{
if (uiThreadCallback != null)
{
uiThreadCallback(MSBuildResult.Failed, target);
}
return null;
}
string[] targetsToBuild = new string[target != null ? 1 : 0];
if (target != null)
{
targetsToBuild[0] = target;
}
MSBuildExecution.ProjectInstance projectInstance = BuildProject.CreateProjectInstance();
projectInstance.SetProperty(GlobalProperty.VisualStudioStyleErrors.ToString(), "true");
projectInstance.SetProperty("UTFOutput", "true");
projectInstance.SetProperty(GlobalProperty.BuildingInsideVisualStudio.ToString(), "true");
this.BuildProject.ProjectCollection.HostServices.SetNodeAffinity(projectInstance.FullPath, NodeAffinity.InProc);
BuildRequestData requestData = new BuildRequestData(projectInstance, targetsToBuild, this.BuildProject.ProjectCollection.HostServices, BuildRequestDataFlags.ReplaceExistingProjectInstance);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(requestData);
try
{
if (useProvidedLogger && buildLogger != null)
{
ErrorHandler.ThrowOnFailure(accessor.RegisterLogger(submission.SubmissionId, buildLogger));
}
if (buildKind == BuildKind.Async)
{
submission.ExecuteAsync(sub =>
{
UIThread.Instance.Run(() =>
{
this.FlushBuildLoggerContent();
EndBuild(sub, designTime, requiresUIThread);
uiThreadCallback((sub.BuildResult.OverallResult == BuildResultCode.Success) ? MSBuildResult.Successful : MSBuildResult.Failed, target);
});
}, null);
}
else
{
submission.Execute();
EndBuild(submission, designTime, requiresUIThread);
MSBuildResult msbuildResult = (submission.BuildResult.OverallResult == BuildResultCode.Success) ? MSBuildResult.Successful : MSBuildResult.Failed;
if (uiThreadCallback != null)
{
uiThreadCallback(msbuildResult, target);
}
}
}
catch (Exception e)
{
Debug.Fail(e.ToString());
EndBuild(submission, designTime, requiresUIThread);
if (uiThreadCallback != null)
{
uiThreadCallback(MSBuildResult.Failed, target);
}
throw;
}
return submission;
}
public Build()
{
buildKind = BuildKind.농장;
level = 0;
}
