public TurretController(TurretModel model, Vector3 spawnPosition, Transform node)
{
_model = model;
_view = TurretFactory.InstantiateView(spawnPosition, node, _model.PrefabName, this);
_fireCountdown = 0f;
_aimType = new NearestPriority();
}
private void LoadAllTurretParams()
{
foreach (TurretParams defaultTurretParams in GlobalVariables.DefaultTurretsParams)
{
foreach (string turretName in defaultTurretParams.Upgrades)
{
if (GlobalVariables.AllTurretParams.ContainsKey(turretName))
{
return;
}
using (UnityWebRequest request = UnityWebRequest.Get("http://127.0.0.1:8000/turret-download?name=" + turretName))
{
request.SendWebRequest();
while (!request.isDone)
{
new WaitForSeconds(0.1f);
}
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
}
else
{
string responseBody = request.downloadHandler.text;
TurretModel model = JsonUtility.FromJson <TurretModel>(responseBody);
GlobalVariables.AllTurretParams.Add(model.name, model.ToTurretParams());
}
}
}
}
}
private void OnTurretClicked(TurretMessage m)
{
if (from == null)
{
from = m.TurretModel;
turretCursor.transform.position = from.Position;
turretCursor.SetType(TurretCursorType.Stop);
return;
}
turretCursor.SetType(TurretCursorType.SelectHover);
if (from == m.TurretModel)
{
m.TurretModel.TargetTurret.Model = null;
m.TurretModel.NotifyChange();
from = null;
return;
}
from.TargetTurret.Model = m.TurretModel;
from.NotifyChange();
from = null;
}
private void OnTurretMouseOut(TurretMessage m)
{
if (m.TurretModel == hovered)
{
hovered = null;
}
}
/**
* Une tourelle est fixée à une case
* */
private void BuildTurret()
{
TurretModel turretToBuild = BuildManager.GetInstance().GetTurretToBuild();
if (turret != null)
{
Debug.Log("Can't build there !");
return;
}
else if (GameController.Pay(turretToBuild.Price) != -1)
{
Vector3 spawnPosition = new Vector3(transform.position.x, 0.7f, transform.position.z);
Debug.Log("Turret to build : " + turretToBuild);
TurretController turretBuilt = new TurretController(turretToBuild, spawnPosition, this.transform);
turret = turretBuilt;
}
else
{
//Not enough money
Debug.Log("Not enough money");
rend.material.color = errorColor;
}
}
protected override void OnSetupState()
{
// Setup Player
TurretModel = new TurretModel(Game.TimekeeperModel);
// Setup Environment
WaveSystem = new WaveSystemModel(Game.GameCamera, Game.TimekeeperModel);
}
protected override void OnDisable()
{
base.OnDisable();
from = null;
Message.RemoveListener <TurretMessage>("click", OnTurretClicked);
Message.RemoveListener <TurretMessage>("mouse_over", OnTurretMouseOver);
Message.RemoveListener <TurretMessage>("mouse_exit", OnTurretMouseOut);
}
public TurretModel GetTurretToBuild()
{
TurretModel building = _turretToBuild;
_turretToBuild = null;
_isWaiting = false;
return(building);
}
protected override void OnViewDestroy()
{
base.OnViewDestroy();
if (_model != null)
{
_model.TargetSetEvent -= OnTargetSetEvent;
_model = null;
}
}
void Start()
{
self = GetComponent <TurretConfig>();
self.owner = transform.parent.parent.GetComponentInParent <PlayerConfig>();
model = self.model;
targeting = self.targeting;
view = self.view;
InvokeRepeating("UpdateTarget", self.updateRate, self.updateRate);
}
public void SellTurret()
{
PlayerStats.Money += turretModel.getSellCost();
GameObject sellEffect = Instantiate(buildManager.sellEffectParticle, getBuildPosition(), Quaternion.identity);
Destroy(sellEffect, 3f);
Destroy(turret);
turretModel = null;
}
private void OnTurretClicked(TurretMessage m)
{
if (deletedThisFrame)
{
return;
} // Prevent click-trough
m.TurretModel.Delete();
hovered = null;
turretCursor.SetType(TurretCursorType.Delete);
deletedThisFrame = true;
}
private void OnPlaceTurret(PlaceTurretMessage message)
{
TurretModel turretModel = new TurretModel();
turretModel.Color = TurretColors.GetRandom();
turretModel.Position = message.Position;
turretModel.TargetTurret = new ModelRef <TurretModel>(null);
Controller.Instantiate <TurretController>("Turret", turretModel, transform);
model.Turrets.Add(turretModel);
}
/// <summary>
/// Returns a name for an turret given its properties. Format will follow "XL ARG Combat Turret Mk2"
/// </summary>
/// <param name="turret">populated turret object used to derive the name</param>
/// <returns>readable name for the turret object</returns>
private string GenerateTurretName(TurretModel turret)
{
string turretName = $"{turret.Size.ToString().ToUpper()} {turret.Faction} Turret {CultureInfo.CurrentCulture.TextInfo.ToTitleCase(turret.Type.ToString())} {CultureInfo.CurrentCulture.TextInfo.ToTitleCase(turret.Grade.ToString())}";
if (turret.Version > 1)
{
turretName += $" {turret.Version.Value:00}";
}
return(turretName);
}
public void selectNode(Node node)
{
if (selectedNode == node)
{
DeselectNode();
return;
}
selectedNode = node;
turretToBuild = null;
nodeUI.setUITargetOnNode(node);
}
public void GenerateTurretName_WeaponHasVersion02()
{
TurretModel turret = new TurretModel {
Faction = FactionType.BUC, Grade = WeaponSystemGrade.mk1, Name = "Some Weapon Name", Size = WeaponSystemSize.s, Type = WeaponSystemType.laser, Class = WeaponSystemClass.turret, Version = 2
};
TurretGetter turretGetter = new TurretGetter();
MethodInfo methodInfo = typeof(TurretGetter).GetMethod("GenerateTurretName", BindingFlags.NonPublic | BindingFlags.Instance);
object[] parameters = { turret };
// Method under test
string turretName = (string)methodInfo.Invoke(turretGetter, parameters);
Assert.Equal("S BUC Turret Laser Mk1 02", turretName);
}
public TurretModel PopulateTurretModel(string turretFilePath, List <string> turretFileNameSubParts)
{
TurretModel turret = new TurretModel();
turretFileNameSubParts.ForEach(x => turret = ParseTurretSubstring(turret, x));
XmlDocument turretXml = new XmlDocument();
turretXml.Load(turretFilePath);
turret.Properties = ParseTurretPropertiesXml(turretXml);
turret.Faction ??= FactionType.GEN;
turret.Name = GenerateTurretName(turret).Trim();
return(turret);
}
private void OnTurretMouseOver(TurretMessage m)
{
hovered = m.TurretModel;
turretCursor.transform.position = hovered.Position;
if (m.TurretModel == from)
{
turretCursor.SetType(TurretCursorType.Stop);
}
else if (from == null)
{
turretCursor.SetType(TurretCursorType.SelectHover);
}
else
{
turretCursor.SetType(TurretCursorType.TargetHover);
}
}
public void ParseTurretSubstring_FactionFound()
{
const string weaponSubstring = "arg";
TurretModel turret = new TurretModel();
TurretGetter turretGetter = new TurretGetter();
MethodInfo methodInfo = typeof(TurretGetter).GetMethod("ParseTurretSubstring", BindingFlags.NonPublic | BindingFlags.Instance);
object[] parameters = { turret, weaponSubstring };
// Method under test
turret = (TurretModel)methodInfo.Invoke(turretGetter, parameters);
Assert.Equal(FactionType.ARG, turret.Faction);
Assert.Null(turret.Size);
Assert.Null(turret.Type);
Assert.Null(turret.Grade);
Assert.Null(turret.Version);
}
public void ParseTurretSubstring_VersionFound_AllOthersPreviouslyPopulated()
{
const string weaponSubstring = "01";
TurretGetter turretGetter = new TurretGetter();
TurretModel turret = new TurretModel {
Faction = FactionType.BUC, Grade = WeaponSystemGrade.mk3, Name = "Some Weapon Name", Size = WeaponSystemSize.xl, Type = WeaponSystemType.laser
};
MethodInfo methodInfo = typeof(TurretGetter).GetMethod("ParseTurretSubstring", BindingFlags.NonPublic | BindingFlags.Instance);
object[] parameters = { turret, weaponSubstring };
// Method under test
turret = (TurretModel)methodInfo.Invoke(turretGetter, parameters);
Assert.Equal(FactionType.BUC, turret.Faction);
Assert.Equal(WeaponSystemSize.xl, turret.Size);
Assert.Equal(WeaponSystemType.laser, turret.Type);
Assert.Equal(WeaponSystemGrade.mk3, turret.Grade);
Assert.Equal(1, turret.Version);
}
/// <summary>
/// Parses a substring from an turret file name, determines which property that substring represents, and assigns the corresponding enum
/// </summary>
/// <param name="turretObject">original turret object</param>
/// <param name="turretSubstring">substring taken from an turret's filename e.g. arg, xl, or mk2</param>
/// <returns>object with the new property added</returns>
private TurretModel ParseTurretSubstring(TurretModel turretObject, string turretSubstring)
{
if (turretObject.Version == null && int.TryParse(turretSubstring, out int turretVersion))
{
turretObject.Version = turretVersion;
return(turretObject);
}
if (turretObject.Faction == null && Enum.TryParse(turretSubstring, true, out FactionType turretFaction))
{
turretObject.Faction = turretFaction;
return(turretObject);
}
if (turretObject.Size == null && Enum.TryParse(turretSubstring, true, out WeaponSystemSize turretSize))
{
turretObject.Size = turretSize;
return(turretObject);
}
if (turretObject.Type == null && Enum.TryParse(turretSubstring, true, out WeaponSystemType turretType))
{
turretObject.Type = turretType;
return(turretObject);
}
if (turretObject.Grade == null && Enum.TryParse(turretSubstring, true, out WeaponSystemGrade turretGrade))
{
turretObject.Grade = turretGrade;
return(turretObject);
}
if (turretObject.Class == null && Enum.TryParse(turretSubstring, true, out WeaponSystemClass turretClass))
{
turretObject.Class = turretClass;
return(turretObject);
}
throw new Exception($"Failed to parse turret substring \"{turretSubstring}\"");
}
public void buildTurret(TurretModel turretModelToBuild)
{
if (PlayerStats.Money < turretModelToBuild.cost)
{
SSTools.ShowMessage("Not Enough Money to Buy", SSTools.Position.bottom, SSTools.Time.oneSecond);
return;
}
PlayerStats.Money -= turretModelToBuild.cost;
//get turretmodel prefab
GameObject _turretPrefab = Instantiate(turretModelToBuild.prefab, getBuildPosition(), Quaternion.identity);
turret = _turretPrefab;
this.turretModel = turretModelToBuild;
//build effect
GameObject buildEffect = Instantiate(buildManager.buildEffectParticle, getBuildPosition(), Quaternion.identity);
Destroy(buildEffect, 5f);
}
public void ParseTurretSubstring_AllParsingFails()
{
const string weaponSubstring = "invalid string to parse";
TurretModel turret = new TurretModel();
TurretGetter turretGetter = new TurretGetter();
MethodInfo methodInfo = typeof(TurretGetter).GetMethod("ParseTurretSubstring", BindingFlags.NonPublic | BindingFlags.Instance);
object[] parameters = { turret, weaponSubstring };
// Method under test
void Action() => turret = (TurretModel)methodInfo.Invoke(turretGetter, parameters);
Exception exception = Assert.Throws <TargetInvocationException>(Action);
Assert.Equal($"Failed to parse turret substring \"{weaponSubstring}\"", exception.InnerException.Message);
Assert.Null(turret.Faction);
Assert.Null(turret.Size);
Assert.Null(turret.Type);
Assert.Null(turret.Grade);
Assert.Null(turret.Version);
}
void Awake()
{
model = GetComponent <TurretModel>();
targeting = GetComponent <TurretTargeting>();
view = GetComponent <TurretView>();
}
public void selectTurretToBuild(TurretModel turret)
{
turretToBuild = turret;
DeselectNode();
}
protected override void OnViewReady()
{
base.OnViewReady();
_model = MVCUtil.GetModel <TurretModel>(this);
_model.TargetSetEvent += OnTargetSetEvent;
}
public void SetTurretToBuild(TurretModel model)
{
_turretToBuild = model;
_isWaiting = true;
}
private void OnTurretMouseOver(TurretMessage m)
{
hovered = m.TurretModel;
turretCursor.SetType(TurretCursorType.DeleteHover);
turretCursor.transform.position = m.TurretModel.Position;
}
public void Init()
{
gameObject = new GameObject();
gameObject.AddComponent <TurretModel>();
model = gameObject.GetComponent <TurretModel>();
}
private void OnTurretMouseOut(TurretMessage m)
{
hovered = null;
turretCursor.SetType(TurretCursorType.Delete);
}
