//============= ClickedOnBuild() ===================//
public void ClickedOnBuild(BuildingAsset buildingAsset)
{
//--------------------- buildAsset, BuildObj ---------------------------//
currentBuildAsset = buildingAsset;
currentBuildObj = Object.Instantiate(buildingAsset.BuildingObj, Vector3.zero, Quaternion.identity, buildings);
//--------------------- Proto Material ---------------------------//
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Proto;
for (int i = 0; i < currentBuildObj.transform.childCount; i++)
{
currentBuildObj.transform.GetChild(i).GetComponent <Renderer>().material = currentBuildAsset.Mat_Proto;
}
//--------------------- Audio ---------------------------//
scrollAudio.scrollAudioSrc.clip = scrollAudio.ding_confirm;
scrollAudio.scrollAudioSrc.Play();
buildAudioSrc = currentBuildObj.AddComponent <AudioSource>();
buildAudioSrc.clip = scrollAudio.ding_selected;
buildAudioSrc.playOnAwake = false;
buildAudioSrc.Play();
//--------------------- BuildPhase ---------------------------//
buildPhase = BuildPhase.moving;
//--------------------- EnableDisableScroll ---------------------------//
EnableDisableScroll(false);
}
private void OnGUI()
{
GUILayout.Space(5);
currentBuildType = (BuildType)EditorGUILayout.EnumPopup("Build Type", currentBuildType);
currentBuildPhase = (BuildPhase)EditorGUILayout.EnumPopup("Build Phase", currentBuildPhase);
bundleVersion = EditorGUILayout.IntField("Bundle Version", bundleVersion);
//EditorGUILayout.BeginVertical();
if (GUILayout.Button("Reset Build Settings", GUILayout.ExpandHeight(true)))
{
settings.buildPhase = BuildPhase.Alpha.ToString();
settings.buildType = BuildType.Development.ToString();
settings.bundleVersion = 1;
settings.v1 = 1;
settings.v2 = 0;
settings.v3 = 0;
BuildPipeline.WriteBuildSettingToJson(settings);
ShowVersionSettings();
}
if (GUILayout.Button("Update Build Settings", GUILayout.ExpandHeight(true)))
{
settings.buildType = currentBuildType.ToString();
settings.buildPhase = currentBuildPhase.ToString();
settings.bundleVersion = bundleVersion;
BuildPipeline.WriteBuildSettingToJson(settings);
}
//EditorGUILayout.BeginVertical();
}
public static void ShowVersionSettings()
{
settings = JsonUtility.FromJson <BuildVersionSettings> (System.IO.File.ReadAllText(BuildPipeline.VERSION_SETTINGS_LOCATION));
currentBuildType = (BuildType)System.Enum.Parse(typeof(BuildType), settings.buildType);
currentBuildPhase = (BuildPhase)System.Enum.Parse(typeof(BuildPhase), settings.buildPhase);
bundleVersion = settings.bundleVersion;
HrtzzBuildVersionWindow window = GetWindow <HrtzzBuildVersionWindow> ("Version Settings");
window.minSize = window.maxSize = new Vector2(300, 140);
}
// Use this for initialization
void Awake()
{
Instance = this;
selectedTT = TowerType.Duplicator;
ChangeSelectedTowerType(selectedTT);
emptyGO = new GameObject();
buildTransform = emptyGO.transform;
isBuildPhase = false;
}
public static BuildMessageInfo GetPhaseMessageInfo(BuildMessage messages, BuildPhase phase)
{
if (messages == null)
{
return(null);
}
if (!messages.TryGetValue(phase, out BuildMessageInfo message))
{
messages[phase] = message = new BuildMessageInfo();
}
return(message);
}
void Start()
{
List <string> buildPhaseString = new List <string>(Enum.GetNames(typeof(BuildPhase)));
buildDropdown.AddOptions(buildPhaseString);
buildDropdown.onValueChanged.AddListener(delegate {
phase = (BuildPhase)buildDropdown.value;
});
List <string> touchPhaseString = new List <string>(Enum.GetNames(typeof(TouchPahaseConstr)));
touchPhaseDropdown.AddOptions(touchPhaseString);
touchPhaseDropdown.onValueChanged.AddListener(delegate {
touchPhase = (TouchPahaseConstr)touchPhaseDropdown.value;
});
if (Prototype.NetworkLobby.LobbyManager.s_Singleton != null)
{
Destroy(Prototype.NetworkLobby.LobbyManager.s_Singleton.gameObject);
}
if (GameObject.Find("DefBlank") != null)
{
GameObject.Find("DefBlank").SetActive(false);
}
gridBlocks = new GameObject[1, 1];
instance = this;
startPos = transform.position;
borderLine = GetComponent <LineRenderer>();
if (PlayerPrefs.GetString("EMAIL") != null)
{
emailEnterField.text = PlayerPrefs.GetString("EMAIL");
passwordEnerField.text = PlayerPrefs.GetString("PASSWORD");
}
if (UserDataPool.signUpUser != null)
{
user = UserDataPool.signUpUser;
user.localId = UserDataPool.resp.localId;
user.idToken = UserDataPool.resp.idToken;
closeSignMenu();
}
}
/// <summary>
/// report model load info
/// </summary>
/// <param name="hostService">host service</param>
/// <param name="files">models' LocalPathFromRoot</param>
/// <param name="phase">the buildphase that the model was loaded at</param>
public void ReportModelLoadInfo(HostService hostService, IEnumerable<string> files, BuildPhase? phase)
{
foreach (var f in files)
{
ReportModelLoadInfo(hostService, f, phase);
}
}
/// <summary>
/// report model load info
/// </summary>
/// <param name="hostService">host service</param>
/// <param name="file">the model's LocalPathFromRoot</param>
/// <param name="phase">the buildphase that the model was loaded at</param>
public void ReportModelLoadInfo(HostService hostService, string file, BuildPhase? phase)
{
Dictionary<string, BuildPhase?> mi = null;
string name = hostService.Processor.Name;
if (!_modelLoadInfo.TryGetValue(name, out mi))
{
_modelLoadInfo[name] = mi = new Dictionary<string, BuildPhase?>();
}
mi[file] = phase;
}
public ImmutableDictionary <string, FileIncrementalInfo> GetModelIncrementalInfo(HostService hostService, BuildPhase phase)
{
if (hostService == null)
{
throw new ArgumentNullException(nameof(hostService));
}
if (!hostService.ShouldTraceIncrementalInfo)
{
throw new InvalidOperationException($"HostService: {hostService.Processor.Name} doesn't record incremental info, cannot call the method to get model incremental info.");
}
var increInfo = (from pair in GetModelLoadInfo(hostService)
let incr = pair.Value == null ? true : false
select new FileIncrementalInfo
{
SourceFile = pair.Key,
IsIncremental = incr,
}).ToImmutableDictionary(f => f.SourceFile, f => f, FilePathComparer.OSPlatformSensitiveStringComparer);
return(increInfo);
}
private void ReloadUnloadedModelsPerCondition(IncrementalBuildContext incrementalContext, BuildPhase phase, Func<string, bool> condition)
{
if (!CanIncrementalBuild)
{
return;
}
var mi = incrementalContext.GetModelLoadInfo(this);
var toLoadList = (from f in mi.Keys
where condition(f)
select LoadIntermediateModel(incrementalContext, f) into m
where m != null
select m).ToList();
if (toLoadList.Count > 0)
{
Reload(Models.Concat(toLoadList));
incrementalContext.ReportModelLoadInfo(this, toLoadList.Select(t => t.FileAndType.File), phase);
}
}
void changeBuildMode(BuildPhase val)
{
phase = val;
}
public void BuildDone()
{
buildPhase = BuildPhase.Done;
gun.SetActive(true);
}
private void ReloadUnloadedModelsPerCondition(IncrementalBuildContext incrementalContext, BuildPhase phase, Func <string, bool> condition)
{
if (!CanIncrementalBuild)
{
return;
}
var mi = incrementalContext.GetModelLoadInfo(this);
var toLoadList = (from f in mi.Keys
where condition(f)
from m in LoadIntermediateModel(incrementalContext, f)
select m).ToList();
if (toLoadList.Count > 0)
{
Reload(Models.Concat(toLoadList));
incrementalContext.ReportModelLoadInfo(this, toLoadList.Select(t => t.FileAndType.File), phase);
}
}
//============= Update() ===========================//
private void Update()
{
if (buildPhase == BuildPhase.none)
{
if (Input.GetMouseButtonDown(0))
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, float.MaxValue, layerMaskSoldiers))
{
currentUnit = hit.collider.GetComponent <Unit>();
Object.Instantiate(unitControl.selectionCircle, currentUnit.transform.position, currentUnit.transform.rotation, currentUnit.transform);
currentUnit.Select();
}
else
{
audioGUI.audioSrc.clip = audioGUI.clip_nullClick; audioGUI.audioSrc.Play();
}
}
if (Input.GetMouseButtonDown(1) && currentUnit != null && currentUnit.currentState == Unit.UnitState.notAttacking)
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, float.MaxValue, layerMaskGroundAndSoldiers))
{
if (hit.collider.GetComponent <Unit>())
{
audioGUI.audioSrc.clip = audioGUI.clip_attackClick; audioGUI.audioSrc.Play();
currentUnit.AssignEnemy(hit.collider.GetComponent <Unit>());
}
else
{
currentUnit.AssignObjective(hit.point);
}
}
}
}
else
if (currentBuildObj != null)
{
if (Input.GetMouseButtonDown(1) && !overlap)
//------------------------- Finish placement ---------------------------------------------------------------------//
{
//Apply material
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
for (int i = 0; i < currentBuildObj.transform.childCount; i++)
{
currentBuildObj.transform.GetChild(i).GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
}
//Place final wall node
if (buildPhase == BuildPhase.walling)
{
Object.Instantiate(currentBuildAsset.BuildingObj, currentNode.position + (currentBuildObj.transform.position - currentNode.position) * 2, Quaternion.identity, buildings);
currentNode = null;
}
//reset currentBuildObj, currentBuildAsset, & buildphase
currentBuildObj = null;
currentBuildAsset = null;
buildPhase = BuildPhase.none;
//Audio
buildAudioSrc.clip = scrollAudio.ding_confirm;
buildAudioSrc.Play();
}
else
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 100.0f, layerMaskGround))
{
//Collision detection
Collider[] colliders = Physics.OverlapBox(hit.point, currentBuildObj.GetComponent <BoxCollider>().size / 2, currentBuildObj.transform.rotation, layerMaskNotGround, QueryTriggerInteraction.Collide);
if (colliders.Length > 1)
{
overlap = true;
}
else
{
overlap = false;
}
if (overlap)
{
currentBuildAsset.Mat_Proto.color = new Color(1, 0, 0, currentBuildAsset.Mat_Proto.color.a);
}
else
{
currentBuildAsset.Mat_Proto.color = new Color(1, 1, 1, currentBuildAsset.Mat_Proto.color.a);
}
//------------------------- Moving & rotating -----------------------------------------------------------//
if (buildPhase != BuildPhase.walling)
{
if (!Input.GetMouseButton(0)) //--------------- Moving -----------------------------------------//
{
currentBuildObj.transform.position = hit.point;
}
else
{
if (currentBuildAsset.wall.wallObj == null) //----------------- Rotating ------------------------//
{
currentBuildObj.transform.LookAt(hit.point);
}
else //----------------- Walling ------------------------//
{
buildPhase = BuildPhase.walling;
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
for (int i = 0; i < currentBuildObj.transform.childCount; i++)
{
currentBuildObj.transform.GetChild(i).GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
}
currentNode = currentBuildObj.transform;
currentBuildObj = Object.Instantiate(currentBuildAsset.wall.wallObj, buildings);
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Proto;
}
}
}
else //----------------- Walling ------------------------//
if (Vector3.Distance(hit.point, currentNode.position) > currentBuildAsset.wall.wallLength)
{
currentBuildObj.transform.position = currentNode.position + Vector3.Normalize(hit.point - currentNode.position) * (currentBuildAsset.wall.wallLength / 2);
currentBuildObj.transform.LookAt(hit.point);
currentBuildObj.transform.rotation = Quaternion.Euler(0, currentBuildObj.transform.eulerAngles.y - 90, 0);
if (Input.GetMouseButtonDown(0) && !overlap)
{
buildAudioSrc.clip = scrollAudio.ding_confirm;
buildAudioSrc.Play();
currentNode = Object.Instantiate(currentBuildAsset.BuildingObj, currentNode.position + Vector3.Normalize(hit.point - currentNode.position) * (currentBuildAsset.wall.wallLength), Quaternion.identity, buildings).transform;
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
for (int i = 0; i < currentBuildObj.transform.childCount; i++)
{
currentBuildObj.transform.GetChild(i).GetComponent <Renderer>().material = currentBuildAsset.Mat_Final;
}
//Instantiate new object
currentBuildObj = Object.Instantiate(currentBuildAsset.wall.wallObj, buildings);
currentBuildObj.transform.position = currentNode.position + Vector3.Normalize(hit.point - currentNode.position) * (currentBuildAsset.wall.wallLength / 2);
currentBuildObj.transform.LookAt(hit.point);
currentBuildObj.transform.rotation = Quaternion.Euler(0, currentBuildObj.transform.eulerAngles.y - 90, 0);
currentBuildObj.GetComponent <Renderer>().material = currentBuildAsset.Mat_Proto;
}
}
}
}
}
}
public void ReloadModelsPerIncrementalChanges(IncrementalBuildContext incrementalContext, IEnumerable <string> changes, BuildPhase loadedAt)
{
if (changes == null)
{
return;
}
ReloadUnloadedModelsPerCondition(
incrementalContext,
loadedAt,
f =>
{
var key = ((RelativePath)f).GetPathFromWorkingFolder().ToString();
return(changes.Contains(key));
});
}
public void ReloadUnloadedModels(IncrementalBuildContext incrementalContext, BuildPhase loadedAt)
{
var mi = incrementalContext.GetModelLoadInfo(this);
ReloadUnloadedModelsPerCondition(incrementalContext, loadedAt, f => mi[f] == null);
}
internal static void RelayBuildMessage(IncrementalBuildContext context, IEnumerable <HostService> hostServices, BuildPhase phase)
{
var falseSet = new HashSet <string>(from h in hostServices
where !h.CanIncrementalBuild
from f in h.Models
select f.OriginalFileAndType.File,
FilePathComparer.OSPlatformSensitiveStringComparer);
var fileSet = new HashSet <string>(from h in hostServices
where h.CanIncrementalBuild
from f in GetFilesToRelayMessages(context, h)
where !falseSet.Contains(f)
select f,
FilePathComparer.OSPlatformSensitiveStringComparer);
var lastBuildMessageInfo = GetPhaseMessageInfo(context.LastBuildVersionInfo?.BuildMessage, phase);
foreach (var file in fileSet)
{
lastBuildMessageInfo.Replay(file);
}
}
void Start()
{
enemyMngr = GameObject.Find("gameManager").GetComponent<EnemyManager>() as EnemyManager;
bulletHolder = GameObject.Find("bullets");
Transform gnT = gun.transform.FindChild("gunArt");
if(gnT!=null){
GameObject gn = gnT.gameObject;
gunAnimCtrl = gun.transform.FindChild("gunArt").GetComponent<Animator>();
}
animCtrl = transform.GetComponent<Animator>();
if(animCtrl!=null){
animCtrl.SetTrigger("build");
buildPhase = BuildPhase.Building;
gun.SetActive(false);
}
}
public void ReloadModelsPerIncrementalChanges(IncrementalBuildContext incrementalContext, IEnumerable<string> changes, BuildPhase loadedAt)
{
if (changes == null)
{
return;
}
ReloadUnloadedModelsPerCondition(
incrementalContext,
loadedAt,
f =>
{
var key = ((TypeForwardedToRelativePath)f).GetPathFromWorkingFolder().ToString();
return changes.Contains(key);
});
}
public void DeBuild()
{
buildPhase = BuildPhase.DeBuilding;
gun.SetActive(false);
animCtrl.SetTrigger("deBuild");
}
public void ReloadUnloadedModels(IncrementalBuildContext incrementalContext, BuildPhase loadedAt)
{
var mi = incrementalContext.GetModelLoadInfo(this);
ReloadUnloadedModelsPerCondition(incrementalContext, loadedAt, f => mi[f] == null);
}
