//Variables End___________________________________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
//Store a reference to these objects since we will need to reference
//them frequently.
myTransform = transform.parent;
cameraHeadTransform = myTransform.FindChild("CameraHead");
resourceScript = myTransform.GetComponent<PlayerResource>();
changeScript = myTransform.GetComponent<ChangeWeapon>();
//Attaching a LineRenderer component which will give a visual
//effect for the block eraser. Only the player will be able to see it.
lineRenderer = gameObject.AddComponent<LineRenderer>();
lineRenderer.material = new Material(Shader.Find("Particles/Additive"));
lineRenderer.SetColors(c1, c2);
lineRenderer.SetWidth(0.04f, 0.01f);
lineRenderer.SetVertexCount(2); //Start and end position.
}
else
{
enabled = false;
}
}
public override bool feedCitizens()
{
citizens.Sort(Citizen.wealthComparison);
List <Building> stores = this.findBuilding("store");
PlayerResource food = new PlayerResource("food");
foreach (Citizen c in citizens)
{
Debug.Log(c.firstName + " " + c.wealth + " " + c.timeAtCurrentJob);
foreach (Building b in stores)
{
Store s = (Store)b;
if (s.getResourceCount(food.resourceName) < 0)
{
break;
}
Debug.Log(s.getPrice());
if (c.wealth >= s.getPrice())
{
c.wealth -= s.getPrice();
c.recieveFood(Citizen.foodAmount);
s.recieveResources(food.resourceName, -1 * Citizen.foodAmount);
s.money += s.getPrice();
break;
}
break;
}
c.recieveFood(0);
}
foreach (PlayerResource resource in resources)
{
money += resource.harvestCost * resource.getDamount() * tax;
}
return(false);
}
public void LoadClicked()
{
var resourceIndex = resources.IndexOf(currentResource);
currentResource = resourceIndex + 1 < resources.Count ? resources[resourceIndex + 1] : resources[0];
UpdateMyLabel();
}
void Awake()
{
deathScreen = GameObject.Find("Death Screen");
resource = GetComponent <PlayerResource>();
stats = GetComponent <PlayerStats>();
combat = GetComponent <PlayerCombat>();
}
void Start()
{
//TODO: Get PlayerStats and calculate what the damage should be.
int damage = Random.Range(15, 21);
int range = 6;
int generateResourceOnHit = 8;
RaycastHit[] hits = Physics.RaycastAll(transform.position, transform.forward, range);
//TODO: Remove DrawRay - this is to show the range in the inspector during live gameplay.
Debug.DrawRay(transform.position, transform.forward * range, Color.red, 0.25f);
for (int i = 0; i < hits.Length; i++)
{
if (hits[i].collider.tag == "Enemy")
{
EnemyHealth enemyHealth = hits[i].collider.gameObject.GetComponent <EnemyHealth>();
enemyHealth.TakeDamage(damage);
GameObject player = GameObject.FindGameObjectWithTag("Player");
PlayerResource playerResource = player.GetComponent <PlayerResource>();
playerResource.GenerateResourceOnHitDealt(generateResourceOnHit);
}
}
Destroy(gameObject);
}
public override bool feedCitizens()
{
citizens.Sort(Citizen.educationComparison);
List <Building> stores = this.findBuilding("store");
PlayerResource food = new PlayerResource("food");
double foodSum = 0;
foreach (Building b in stores)
{
Store s = (Store)b;
foodSum += s.getResourceCount(food.resourceName);
s.giveResources(food.resourceName);
}
foreach (Citizen c in citizens)
{
if (foodSum >= Citizen.foodAmount)
{
c.recieveFood(Citizen.foodAmount);
foodSum -= Citizen.foodAmount;
}
else
{
c.recieveFood(0);
}
}
if (foodSum > 0)
{
return(true);
}
return(false);
}
public void AddResource(GameObject player)
{
Debug.Log("player " + player.GetComponent <MovementScript>().playerNum + " has recieved " + amount);
playerResource = player.GetComponent <PlayerResource>();
playerResource.resource += amount;
Analytics.CustomEvent("PlayerReceived Fuel", new Dictionary <string, object>
{
{ "Player Received Fuel", player.GetComponent <MovementScript>().publicUsername + " Received " + amount.ToString() + " fuel" },
{ "Timestamp: ", System.DateTime.Now.ToString() },
});
// Display hint box on players that receive fuel from the crate
if (player.GetPhotonView().isMine)
{
// GameObject.Find("HintBox").GetComponent<UIHintBox>().DisplayHint("FUEL RECEIVED!", "YOU COLLECTED " + amount.ToString() + " FUEL \nFROM THIS CRATE\nDEPOSIT OR COLLECT MORE!", 6.0f);
GameObject.FindGameObjectWithTag("UIHandler").GetComponent <UIFuelCollected>().DisplayFuelCollected(amount);
if (player.GetComponent <AudioSource>() != null)
{
player.GetComponent <AudioSource>().PlayOneShot(fuelPickupSound);
}
}
// Player stats
player.GetComponent <PlayerStatTracker>().timeSinceLastFuelCratePickup = 0.0f;
player.GetComponent <PlayerStatTracker>().overallCollectedFuel += amount;
player.GetComponent <PlayerStatTracker>().fuelCratesOpened += 1;
player.GetComponent <PlayerStatTracker>().fuelCratesOpenedBySize[requirement] += 1;
if (playerResource.resource > player.GetComponent <PlayerStatTracker>().maxFuelCarriedAtOnce)
{
player.GetComponent <PlayerStatTracker>().maxFuelCarriedAtOnce = playerResource.resource;
}
}
public void Gain(PlayerResourceType resourceType, int amount)
{
PlayerResource resource = config.Resources.Find(r => r.Type == resourceType);
resource.Gain(amount);
HUDManager.main.Refresh();
UIManager.main.ShowBillboardText(amount + "xp", Tools.GetPlayerPositionWithOffset(), resource.Icon, resource.Color);
}
public void addResource(PlayerResource playerResource, float addThis)
{
resourceBank[playerResource] += addThis;
if (playerResourceChanged != null)
{
playerResourceChanged(playerResource);
}
}
public double giveResources(string name)
{
PlayerResource pr = neededResources.Find(x => x.resourceName == name);
double amount = pr.getAmount();
pr.setResource(0);
return(amount);
}
// Start is called before the first frame update
void Awake()
{
player = GameObject.FindWithTag("Player");
resourceScript = player.GetComponent <PlayerResource>();
healthText.text = resourceScript.getHealth().ToString();
hungerText.text = resourceScript.getHunger().ToString();
thirstText.text = resourceScript.getThirst().ToString();
}
//Leveling Up function
private void LevelUp()
{
level++;
baseSTR += 2;
baseINT++;
//Typecasts to allow the class to access HP and Resource.
PlayerHealth health = GetComponent <PlayerHealth>();
PlayerResource rage = GetComponent <PlayerResource>();
//Checks divisibilty of 5 and adds Dex accordingly
if ((level % 5) == 0)
{
baseDEX += 3;
skillKnown++;
}
else
{
baseDEX++;
}
//Health scaling
if (level < 5)
{
health.maxHealth += 20;
}
else if (level > 4 && level < 10)
{
health.maxHealth += 40;
rage.maxResource = 25;
}
else if (level > 9 && level < 15)
{
health.maxHealth += 80;
rage.maxResource = 50;
}
else if (level > 14 && level < 20)
{
health.maxHealth += 160;
rage.maxResource = 75;
}
else if (level > 19 && level < 25)
{
health.maxHealth += 320;
rage.maxResource = 100;
}
if (level == 25)
{
health.maxHealth += 640;
rage.maxResource = 100;
}
health.curHealth = health.maxHealth;
rage.curResource = rage.maxResource;
}
public PlayerResource(PlayerResource _pr)
{
gold = _pr.gold;
mineralValues = new int[MineralData.NumberOfMineralType];
for (int i = 0; i < MineralData.NumberOfMineralType; i++)
{
mineralValues[i] = _pr.mineralValues[i];
}
}
void Awake()
{
resourceBar = GameObject.Find("Resource");
player = GameObject.FindGameObjectWithTag("Player");
playerResource = player.GetComponent <PlayerResource>();
resourceDisplayText = GameObject.Find("Resource Display Text");
resourceDisplay = resourceDisplayText.GetComponent <Text>();
}
protected static PlayerResource GeneratePlayerResource()
{
var id = Guid.NewGuid().ToString();
var resource = new PlayerResource {
Id = id
};
resource.Links.Add(new LinkResource("standby", $"/{Guid.NewGuid().ToString()}"));
return(resource);
}
void Awake()
{
spellSpawnPrefab = Resources.Load("Prefabs/Spell Spawn") as GameObject;
spellSpawn = Instantiate(spellSpawnPrefab, transform);
spellSpawnLocation = spellSpawn.transform;
player = GameObject.FindGameObjectWithTag("Player");
playerResource = player.GetComponent <PlayerResource>();
playerHealth = player.GetComponent <PlayerHealth>();
}
/// <summary>
///
/// Initialise the details about the players resources for a particular deck
///
/// </summary>
public void InitDeckResourceDetail(PlayerResource _playerResource)
{
playerResource = _playerResource;
//Set the generic properties of the details
resourceTitle.text = playerResource.ResourceType.ToString();
resourceIcon.sprite = GameManager.instance.iconManager.GetIcon(playerResource.ResourceType);
RefreshResourceProperties();
}
private void updateResourceReadout(PlayerResource playerResource)
{
if (playerResource == PlayerResource.money)
{
resourceReadoutsDict[playerResource].text = player.getResource(playerResource).ToString("C2");
}
else
{
resourceReadoutsDict[playerResource].text = EnumHelper.GetDescription(playerResource) + ": " + player.getResource(playerResource);
}
}
public void recieveResources(string name, double amount)
{
if (name == null)
{
return;
}
PlayerResource pr = neededResources.Find(x => x.resourceName == name);
//costDictionary.Add(pr, cost);
pr.gainResource(amount);
}
/// <summary>
///
/// Initialises the resource details wth the general functionality of the details
///
/// </summary>
public void InitResourceDetailUI(PlayerResource _playerResource, PlayerUIBar _playerBar)
{
playerResource = _playerResource;
playerBar = _playerBar;
resourceIcon.sprite = GameManager.instance.iconManager.GetIcon(playerResource.ResourceType);
resourceTitle.text = playerResource.ResourceType.ToString();
buttonGroup.interactable = false;
RefreshResourceDetailUI();
}
public void startTurn()
{
GDP = 0;
transport = 0;
foreach (Improvement n in nationalizedImprovements)
{
n.startTurn();
n.harvestResource();
string improvementName = n.resource.resourceName;
PlayerResource pr = findResource(improvementName);
pr.changeDamount(n.resource.getAmount());
}
foreach (PlayerResource resource in resources)
{
resource.setResource(resource.getAmount() + resource.getDamount());
//calculate GDP
GDP += resource.harvestCost * resource.getDamount();
if (resource.getAmount() > 1)
{
foreach (Store s in findBuilding("store"))
{
Debug.Log(resource.resourceName + " " + resource.getAmount());
s.recieveResources(resource.resourceName, resource.getAmount());
}
}
}
//calculate GDP
GDP = 0;
money = 0;
foreach (PlayerResource r in resources)
{
GDP += (r.getDamount() * r.harvestCost);
if (r.resourceName.Equals("transport"))
{
transport = r.getDamount() * transport_mod;
}
//Debug.Log("Transportation: " + transport);
r.setDResource(0);
r.setResource(0);
money = GDP * .08;
}
bool food = feedCitizens();
for (int i = 0; i < citizens.Count; i++)
{
citizens[i].startTurn(food);
}
cleanUpBodies();
Debug.Log(citizens.Count);
}
public StreamioAPI(string username, string password)
{
RestClient client = new RestClient(BaseUrl);
client.Authenticator = new HttpBasicAuthenticator(username, password);
Videos = new VideoResource(client);
Images = new ImageResource(client);
Playlists = new PlaylistResource(client);
Players = new PlayerResource(client);
Audios = new AudioResource(client);
EncodingProfiles = new EncodingProfileResource(client);
PublicUploads = new PublicUploadResource(client);
}
public int GetResourceCount(PlayerResource resourceType)
{
switch (resourceType)
{
case PlayerResource.OVERALL_BLOOD:
return(overallBlood);
case PlayerResource.SELECTED_BLOOD:
return(selectedBlood);
default:
throw new NotYetImplementedException("Resource type not implemented");
}
}
public static Producer searchProducersForUnsold(List <Producer> producers, PlayerResource resourceType)
{
producers.Sort(Producer.amountComparison);
foreach (Producer p in producers)
{
if (p.producedResource.Equals(resourceType))
{
if (p.producedResource.getAmount() > 0)
{
return(p);
}
}
}
return(null);
}
public ResetCause GetResetCause()
{
PlayerResource energy = config.Resources.Find(r => r.Type == PlayerResourceType.Energy);
PlayerResource health = config.Resources.Find(r => r.Type == PlayerResourceType.Health);
if (energy.Value <= 0)
{
return(ResetCause.EnergyLoss);
}
if (health.Value <= 0)
{
return(ResetCause.Death);
}
return(ResetCause.None);
}
public void SetPlayerPrimaryResource(PlayerResource primary)
{
if (primary.ToString().StartsWith("Secondary"))
{
throw new Exception("Recived secondary resource in SetPlayerPrimaryResource()");
}
if (primary == PlayerResource.None)
{
Player.PrimaryResourcePercentage = 0;
}
else
{
Player.PrimaryResourcePercentage = int.Parse(primary.ToString().Split('_')[1]);
}
}
public bool removeResource(PlayerResource playerResource, float removeThis)
{
if (resourceBank[playerResource] > removeThis)
{
resourceBank[playerResource] -= removeThis;
if (playerResourceChanged != null)
{
playerResourceChanged(playerResource);
}
return(true);
}
else
{
return(false);
}
}
public bool CreatePlayerResource(PlayerResource playerResource)
{
outpostwarsEntities entities = new outpostwarsEntities();
try
{
// Add tew New Player into the player Collection
entities.PlayerResources.Add(playerResource);
// Save changes
return(entities.SaveChanges() == 1);
}
catch (DbEntityValidationException ex)
{
LogCriticalError(ex);
}
return(false);
}
private void CreaterResourceBar(PlayerResource resource)
{
HUDResourceBar newBar = Prefabs.Instantiate <HUDResourceBar>();
if (resource.Type == PlayerResourceType.Energy)
{
newBar.Init(resource, energyBarContainer);
}
else if (resource.IsSkill)
{
newBar.Init(resource, xpBarContainer);
}
else
{
newBar.Init(resource, resourceBarContainer);
}
resourceBars.Add(newBar);
}
public async Task <IActionResult> PutAsync([FromBody] PlayerResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var player = mapper.Map <PlayerResource, Player>(resource);
var result = await playerService.UpdateAsync(player);
if (!result.IsSuccess)
{
return(BadRequest(result.Message));
}
var userResource = mapper.Map <Player, PlayerResource>(result.internalValue);
return(Ok(userResource));
}
// Use this for initialization
void Start()
{
resources = new List <PlayerResource>();
resources.Add(new PlayerResource()
{
ResourceId = 1,
Quantity = 0,
SystemName = "resource_1_rock_blah",
Name = "Rock"
});
resources.Add(new PlayerResource()
{
ResourceId = 2,
Quantity = 12,
SystemName = "resource_2_cheese",
Name = "Cheese"
});
currentResource = resources[0];
}
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
Transform triggerTransform = transform.FindChild("Trigger");
HDScript = triggerTransform.GetComponent<HealthAndDamage>();
energyScript = gameObject.GetComponent<PlayerEnergy>();
rescourceScript = gameObject.GetComponent<PlayerResource>();
healthStyle.normal.textColor = Color.red;
healthStyle.fontStyle = FontStyle.Bold;
energyStyle.normal.textColor = Color.cyan;
energyStyle.fontStyle = FontStyle.Bold;
rescourcesStyle.normal.textColor = Color.green;
rescourcesStyle.fontStyle = FontStyle.Bold;
}
else
{
enabled = false;
}
}
//Variables End___________________________________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
myTransform = transform;
//The ray is cast based on the direction the camera head is facing
//Remember the camera head tilts up and down because of the
//MouseLook script attached to it.
myCameraHeadTransform = myTransform.FindChild("CameraHead");
resourceScript = gameObject.GetComponent<PlayerResource>();
changeScript = myTransform.GetComponent<ChangeWeapon>();
}
else
{
enabled = false;
}
}
