private float checkBuildingsAround(BuildingClass classToCheck)
{
RaycastHit[] hits;
Vector3 p1 = transform.position;
float weight = 0;
/*throw out a sphere, and compare the hits building class to the class given as part of the check call
* Calculate a weight (that maybe should be a float?) and return it to the caller. Those weights will be
* used to fudge the random number in the direction of the building that should be spawned*/
if ((hits = Physics.SphereCastAll(p1, transform.localScale.y * 3, transform.forward)) != null)
{
foreach (RaycastHit h in hits)
{
if (h.collider.gameObject.GetComponent <BuildingNode>() != null &&
h.collider.gameObject.GetComponent <BuildingNode>().getConstructed() &&
h.collider.gameObject.GetComponent <BuildingNode>().GetType().Equals(classToCheck))
{
weight += (1.0f / hits.Length) * weight_fudge;
}
}
}
return(weight);
}
// Use this for initialization
void Start()
{
switch (building)
{
case Builiding.Money:
building_class = new MoneyBuilding();
break;
case Builiding.AutoGun:
building_class = new AutoGunBuilding();
break;
case Builiding.SlantingShot:
building_class = new SlantingShotBuilding();
break;
case Builiding.Stop:
building_class = new StopBuilding();
break;
case Builiding.SlantingBomb:
building_class = new SlantingBombBuilding();
break;
case Builiding.ResponceShot:
building_class = new ResponceShotBuilding();
break;
}
building_class.Init(gameObject);
}
public BuildingRequestment(Planets.Planet owner, string name, BuildingClass buildingClass, int index)
{
this.owner = owner;
this.name = name;
this.buildingClass = buildingClass;
this.index = index;
}
public void AddBuildingToDb()
{
newBuilding = new BuildingClass();
newBuilding.BuildingLongName = textBox1.Text;
newBuilding.BuildingShortName = textBox2.Text;
DataConnectionClass.buildingConn.WriteBuilding(newBuilding);
DataConnectionClass.AuditLogConnClass.AddRecordToAudit("added new building " + newBuilding.BuildingLongName);
this.DialogResult = DialogResult.OK;
this.Close();
}
// Update is called once per frame
void Update()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit = new RaycastHit();
if (Physics.Raycast(ray, out hit))
{
GameObject obj = hit.collider.gameObject;
if (Input.GetMouseButtonDown(0))
{
if (hit.collider.tag != "Building")
{
return;
}
PlayerBehaviour.root.GetComponent <ThirdPersonCameraController>().mouseSensitivity = 0;
building_class = null;
GameObject have_compornent_obj = null;
while (building_class == null)
{
have_compornent_obj = (have_compornent_obj == null)?hit.collider.gameObject:have_compornent_obj.transform.parent.gameObject;
if (have_compornent_obj.GetComponent <BuildingBehaviour>() != null)
{
building_class = have_compornent_obj.GetComponent <BuildingBehaviour>().building_class;
break;
}
}
//building_class = (hit.collider.gameObject.GetComponent<BuildingBehaviour>() == null)?
// hit.collider.gameObject.transform.parent.gameObject.GetComponent<BuildingBehaviour>().building_class:
// hit.collider.gameObject.GetComponent<BuildingBehaviour>().building_class;
building_class.upgrade();
upgrade_window.SetActive(true);
upgrade_window.transform.FindChild("Title").gameObject.GetComponent <Text>().text = building_class.m_name;
upgrade_window.transform.FindChild("Cost").gameObject.GetComponent <Text>().text = "費用:" + building_class.m_upgrade_cost + "円";
for (int i = 0; i < building_class.m_upgrade_text.Count; i++)
{
text_all.Add(Instantiate(text_src, Vector3.zero, Quaternion.identity) as GameObject);
text_all[i].transform.parent = upgrade_window.transform;
text_all[i].transform.localPosition = new Vector3(20, 180 - 40 * i, 0);
text_all[i].GetComponent <Text>().text = building_class.m_upgrade_text[i];
}
}
}
}
public override bool build()
{
/*TODO
* scan the area around the node for other buildings,
* and weight the random number based on their type.
* The more buildings of one type around a new node,
* the more likely it is to instantiate as that type
*/
if (concreteImplementation == null)
{
System.Random rnd = new System.Random();
SortedDictionary <BuildingClass, float> building_weights = buildingWeights();
BuildingClass most_frequent = BuildingClass.Residential;
float weighting_factor = 0.0f;
float temp_output = 0.0f;
foreach (BuildingClass b in building_weights.Keys)
{
building_weights.TryGetValue(b, out temp_output);
if (temp_output > weighting_factor)
{
weighting_factor = temp_output;
most_frequent = b;
}
}
switch ((rnd.NextDouble() <= weighting_factor ? (int)most_frequent : rnd.Next(buildingClasses.Length)))
{
case (int)BuildingClass.Residential:
concreteImplementation = new ResidentialBuildingNode(this.GetComponent <Transform>().position);
break;
case (int)BuildingClass.Commercial:
concreteImplementation = new CommercialBuildingNode(this.GetComponent <Transform>().position);
break;
default:
print("No corosponding building type");
return(false);
}
this.setConstructed(true);
this.GetComponent <BoxCollider>().enabled = false;
concreteImplementation.build();
concreteImplementation.setConstructed(true);
}
return(true);
}
public GameObject instantiate(BuildingClass buildingType, GameObject Owner, Vector3 position, bool activated)
{
GameObject instance = (GameObject)PhotonNetwork.Instantiate("Prefabs/Buildings/" + buildingType.GO.name, position, Quaternion.identity, 0);
BuildingConfiguration config = instance.AddComponent <BuildingConfiguration>();
instance.AddComponent <Owner>();
instance.GetComponent <Owner>().owner = Owner;
config.metalCost = buildingType.metalCost;
config.metalProd = buildingType.metalProd;
config.energy = buildingType.energy;
config.buildTime = buildingType.buildTime;
config.health = buildingType.health;
config.name = buildingType.name;
config.GO = instance;
config.isActivated = activated;
return((GameObject)instance);
}
// Instantiate a new building
public static void createBuilding(BuildingClass type_of_building)
{
int[] building_data = BuildingsHelper.pickBuilding(type_of_building);
// Residential
if (type_of_building == BuildingClass.Residential)
{
prefab = Resources.Load(BuildingUtils.getResidentialPath(building_data[1])) as GameObject;
building_obj = GameObject.Instantiate(prefab) as GameObject;
new_building = Residential.CreateComponent(building_obj,
(ResidentialType)building_data[0],
(ResidentialSize)building_data[1],
(ResidentialVariation)building_data[2]);
}
// Commercial
else if (type_of_building == BuildingClass.Commercial)
{
prefab = Resources.Load(BuildingUtils.getCommercialPath(building_data[1])) as GameObject;
building_obj = GameObject.Instantiate(prefab) as GameObject;
new_building = Commercial.CreateComponent(building_obj,
(CommercialType)building_data[0],
(CommercialSize)building_data[1],
(CommercialVariation)building_data[2]);
}
// Industrial
else if (type_of_building == BuildingClass.Industrial)
{
prefab = Resources.Load(BuildingUtils.getIndustrialPath(building_data[1])) as GameObject;
building_obj = GameObject.Instantiate(prefab) as GameObject;
new_building = Industrial.CreateComponent(building_obj,
(IndustrialType)building_data[0],
(IndustrialSize)building_data[1],
(IndustrialVariation)building_data[2]);
}
else
{
throw new NoSuchTypeException("Building Type not found");
}
}
// Randomize building type
public static int[] pickBuilding(BuildingClass building_class)
{
int[] result = new int[3]; // 1st index = class, 2nd = type 3rd = variation
System.Random rand = new System.Random();
int building_size = 1;
int building_variation = 1;
// Check what type of building we want
if (building_class == BuildingClass.Residential)
{
building_size = (int)ResidentialSize.Shack;
building_variation = rand.Next(0, residential_variations) + 1;
Debug.Log(building_class + " " + (ResidentialSize)building_size + " " +
(ResidentialVariation)building_variation);
}
else if (building_class == BuildingClass.Commercial)
{
building_size = (int)CommercialSize.Small;
building_variation = rand.Next(0, commercial_variations) + 1;
Debug.Log(building_class + " " + (IndustrialSize)building_size + " " +
(IndustrialVariation)building_variation);
}
else if (building_class == BuildingClass.Industrial)
{
building_size = (int)IndustrialSize.Small;
building_variation = rand.Next(0, industrial_variations) + 1;
}
result[0] = (int)building_class;
result[1] = building_size;
result[2] = building_variation;
Debug.Log(result[0] + " " + result[1] + " " + result[2]);
//Debug.Log((tt)building_type);
//return (ResidentialType)house_type;
return(result);
}
public void UpdateBuilding(BuildingClass building)
{
Update(building);
}
public void RemoveBuilding(BuildingClass building)
{
Delete(building);
}
public void WriteBuilding(BuildingClass building)
{
Write(building);
}
private void cmboRecipiant_SelectionChangeCommitted(object sender, EventArgs e)
{
if (message != "EDIT")
{
cmboRecipiant.Text = cmboRecipiant.SelectedItem.ToString();
if (!String.IsNullOrWhiteSpace(txtPO.Text))
{
if (txtPO.Text.Length < 4)
{
WorkingPID = txtPO.Text.ToLower().Substring(0, txtPO.Text.Length);
}
else
{
WorkingPID = txtPO.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboCarrier.Text))
{
if (!String.IsNullOrWhiteSpace(txtPO.Text))
{
if (cmboCarrier.Text.Length < 4)
{
WorkingPID += cmboCarrier.Text.ToLower().Substring(0, cmboCarrier.Text.Length);
}
else
{
WorkingPID += cmboCarrier.Text.ToLower().Substring(0, 4);
}
}
else
{
if (cmboCarrier.Text.Length < 4)
{
WorkingPID = cmboCarrier.Text.ToLower().Substring(0, cmboCarrier.Text.Length);
}
else
{
WorkingPID = cmboCarrier.Text.ToLower().Substring(0, 4);
}
}
}
if (!String.IsNullOrWhiteSpace(cmboVendor.Text))
{
if (cmboVendor.Text.Length < 4)
{
WorkingPID += cmboVendor.Text.ToLower().Substring(0, cmboVendor.Text.Length);
}
else
{
WorkingPID += cmboVendor.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboRecipiant.Text))
{
if (cmboRecipiant.Text.Length < 4)
{
WorkingPID += cmboRecipiant.Text.ToLower().Substring(0, cmboRecipiant.Text.Length);
}
else
{
WorkingPID += cmboRecipiant.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboBuilding.Text))
{
if (cmboBuilding.Text.Length < 4)
{
WorkingPID += cmboBuilding.Text.ToLower().Substring(0, cmboBuilding.Text.Length);
}
else
{
WorkingPID += cmboBuilding.Text.ToLower().Substring(0, 4);
}
}
DataConnectionClass.CreatePersonId(WorkingPID);
txtRoleId.Text = DataConnectionClass.PersonIdGenerated;
fac = DataConnectionClass.DataLists.FacultyList.FirstOrDefault(i => i.ToString() == cmboRecipiant.Text);
BuildingClass b = DataConnectionClass.DataLists.BuildingNames.FirstOrDefault(i => i.BuildingId == fac.Building_Id);
cmboBuilding.SelectedItem = b.BuildingShortName;
cmboBuilding_SelectionChangeCommitted(this, e);
lblroom.Text = fac.RoomNumber;
newPackage.DelivBuildingShortName = cmboBuilding.Text + " " + fac.RoomNumber;
}
else
{
fac = DataConnectionClass.DataLists.FacultyList.FirstOrDefault(i => i.ToString() == cmboRecipiant.Text);
BuildingClass b = DataConnectionClass.DataLists.BuildingNames.FirstOrDefault(i => i.BuildingId == fac.Building_Id);
cmboBuilding.SelectedItem = b.BuildingShortName;
cmboBuilding_SelectionChangeCommitted(this, e);
lblroom.Text = fac.RoomNumber;
newPackage.DelivBuildingShortName = cmboBuilding.Text + " " + fac.RoomNumber;
}
}
private void cmboRecipiant_SelectionChangeCommitted(object sender, EventArgs e)
{
if (message != "EDIT" || (message == "ADD" && newPackage.Notes.Count == 0))
{
cmboRecipiant.Text = cmboRecipiant.SelectedItem.ToString();
if (!String.IsNullOrWhiteSpace(txtPO.Text))
{
if (txtPO.Text.Length < 4)
{
WorkingPID = txtPO.Text.ToLower().Substring(0, txtPO.Text.Length);
}
else
{
WorkingPID = txtPO.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboCarrier.Text))
{
if (!String.IsNullOrWhiteSpace(txtPO.Text))
{
if (cmboCarrier.Text.Length < 4)
{
WorkingPID += cmboCarrier.Text.ToLower().Substring(0, cmboCarrier.Text.Length);
}
else
{
WorkingPID += cmboCarrier.Text.ToLower().Substring(0, 4);
}
}
else
{
if (cmboCarrier.Text.Length < 4)
{
WorkingPID = cmboCarrier.Text.ToLower().Substring(0, cmboCarrier.Text.Length);
}
else
{
WorkingPID = cmboCarrier.Text.ToLower().Substring(0, 4);
}
}
}
if (!String.IsNullOrWhiteSpace(cmboVendor.Text))
{
if (cmboVendor.Text.Length < 4)
{
WorkingPID += cmboVendor.Text.ToLower().Substring(0, cmboVendor.Text.Length);
}
else
{
WorkingPID += cmboVendor.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboRecipiant.Text))
{
if (cmboRecipiant.Text.Length < 4)
{
WorkingPID += cmboRecipiant.Text.ToLower().Substring(0, cmboRecipiant.Text.Length);
}
else
{
WorkingPID += cmboRecipiant.Text.ToLower().Substring(0, 4);
}
}
if (!String.IsNullOrWhiteSpace(cmboBuilding.Text))
{
if (cmboBuilding.Text.Length < 4)
{
WorkingPID += cmboBuilding.Text.ToLower().Substring(0, cmboBuilding.Text.Length);
}
else
{
WorkingPID += cmboBuilding.Text.ToLower().Substring(0, 4);
}
}
DataConnectionClass.CreatePersonId(WorkingPID);
txtRoleId.Text = DataConnectionClass.PersonIdGenerated;
fac = DataConnectionClass.DataLists.FacultyList.FirstOrDefault(i => i.ToString() == cmboRecipiant.Text);
BuildingClass b = DataConnectionClass.DataLists.BuildingNames.FirstOrDefault(i => i.BuildingId == fac.Building_Id);
cmboBuilding.SelectedItem = b.BuildingShortName;
cmboBuilding_SelectionChangeCommitted(this, e);
lblroom.Text = fac.RoomNumber;
newPackage.DelivBuildingShortName = cmboBuilding.Text + " " + fac.RoomNumber;
}
else
{
string compairer = cmboRecipiant.Text;
foreach (Faculty f in DataConnectionClass.DataLists.FacultyList)
{
string fname = f.ToString();
if (fname == compairer)
{
fac = f;
break;
}
}
if (fac == null)
{
MessageBox.Show("Null Faculty object. Aborting.", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//break point
BuildingClass b = new BuildingClass();
foreach (BuildingClass build in DataConnectionClass.DataLists.BuildingNames)
{
if (build.BuildingId == fac.Building_Id)
{
b = build;
break;
}
}
cmboBuilding.SelectedItem = b.BuildingShortName;
cmboBuilding_SelectionChangeCommitted(this, e);
lblroom.Text = fac.RoomNumber;
newPackage.DelivBuildingShortName = cmboBuilding.Text + " " + fac.RoomNumber;
}
isSlectedItem[1] = true;
selecteditem = cmboRecipiant.SelectedItem;
btnReceive.Enabled = IsRequiredItemsSelected();
}
public AddBuilding(string message, Object buildingToBeEdited)
{
InitializeComponent();
this.message = message;
newBuilding = (BuildingClass)buildingToBeEdited;
}
