Assets/Scripts/Cloud.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Cloud : MonoBehaviour
+{
+
+    private void Start()
+    {
+        transform.localScale = new Vector3(Random.Range(2f, 5f), Random.Range(2f, 5f), 1);
+    }
+
+    void Update()
+    {
+        float x = transform.position.x;
+        transform.position = new Vector3(x-0.1f, transform.position.y, transform.position.z);
+        
+    }
+
+    private void OnBecameInvisible()
+    {
+        Destroy(gameObject);
+    }
+}

Assets/Scripts/Cloud.cs.meta

+fileFormatVersion: 2
+guid: fc89ba7face02fd46bb95930a9f0fb6e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/CloudSpawner.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CloudSpawner : MonoBehaviour
+{
+    [SerializeField]
+    private GameObject cloudPrefab = null;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        StartCoroutine("StartSpawning");   
+    }
+
+    private IEnumerator StartSpawning() {
+        while (true)
+        {
+            GameObject go = Instantiate<GameObject>(cloudPrefab);
+            Vector3 min = Camera.main.ScreenToWorldPoint(new Vector3(Camera.main.pixelWidth, 0, -10));
+            Vector3 max = Camera.main.ScreenToWorldPoint(new Vector3(Camera.main.pixelWidth, Camera.main.pixelHeight, -10));
+            go.transform.position = new Vector3(max.x+10, Random.Range(min.y,max.y),-5);
+            yield return new WaitForSeconds(Random.Range(2, 7));
+        }
+    }
+}

Assets/Scripts/CloudSpawner.cs.meta

+fileFormatVersion: 2
+guid: a991ff8c67bd56d448502bfbce3b0a4e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Collector.cs

@@ -4,12 +4,6 @@ using UnityEngine;
 
 public class Collector : MonoBehaviour
 {
-    // Start is called before the first frame update
-    void Start()
-    {
-
-    }
-
     [SerializeField]
     private GameObject target;
 
@@ -19,17 +13,48 @@ public class Collector : MonoBehaviour
     [SerializeField]
     private int max_amount = 10;
 
+    [SerializeField]
+    private int Requested_amount;
+
+    [SerializeField]
+    private Resource Requested_resource;
+
+    [SerializeField]
+    private bool OnkoVapaa;
+
     [SerializeField]
     private int amount;
 
     [SerializeField]
     private GameObject home;
-
+    
     [SerializeField]
     private Resource resource;
     public float speed = 1;
 
+    [SerializeField]
+    private GameObject target_flag;
+
+    [SerializeField]
+    private bool send_to_resource;
+    public GameObject flag;
+    // Start is called before the first frame update
+    void Start()
+    {
+        home = GameObject.FindGameObjectWithTag("Home");
+    }
 
+    public GameObject GetMoveToTarget() {
+        return move_to;
+    }
+    public void SetOnkoVapaa(bool vapaa)
+    {
+        this.OnkoVapaa = vapaa;
+    }
+    public bool tarkistaVapaus()
+    {
+        return this.OnkoVapaa;
+    }
     public void SetTarget(GameObject target)
     {
         this.target = target;
@@ -38,49 +63,125 @@ public class Collector : MonoBehaviour
     {
         this.move_to = target;
     }
-    GameObject lastClicked;
-    Ray ray;
-    RaycastHit rayHit;
+    public Resource getResource()
+    {
+        return this.resource;
+    }
+    public void SetSend_to_resource(bool r)
+    {
+        this.send_to_resource = r;
+    }
     // Update is called once per frame
     void Update()
     {
+        
         if (Input.GetMouseButtonDown(0))
         {
             Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
             Vector2 mousePos2D = new Vector2(mousePos.x, mousePos.y);
 
             RaycastHit2D hit = Physics2D.Raycast(mousePos2D, Vector2.zero);
-            if (hit.collider != null)
+            if (hit.collider != null && hit.collider.gameObject != null)
             {
+
+                this.Requested_resource = null;
+                this.Requested_amount = 0;
+                if (hit.collider.gameObject.GetComponent<Outcrop>() != null && hit.collider.gameObject.tag == "Buildable")
+                {
+                    this.send_to_resource = true;
+                }
+                else
+                {
+                    this.send_to_resource = false;
+                }
+                DestroyImmediate(target_flag);
+                target_flag = Instantiate(flag, hit.point, Quaternion.identity);
+                target_flag.GetComponent<Flag>().SetWorker(this.gameObject);
                 SetTarget(hit.collider.gameObject);
-                MoveTo(hit.collider.gameObject);
+                if(resource == null || hit.collider.gameObject.tag == "Home")
+                    MoveTo(hit.collider.gameObject);
             }
         }
-        if (target != null)
-            transform.position = Vector2.MoveTowards(new Vector2(transform.position.x, transform.position.y), move_to.transform.position, speed * Time.deltaTime);
+        if (move_to != null)
+            transform.position = Vector3.MoveTowards(new Vector3(transform.position.x, transform.position.y, -1f), move_to.transform.position, speed * Time.deltaTime);
     }
     private void OnTriggerEnter2D(Collider2D collision)
     {
 
-        if (collision.gameObject.tag == "Resource")
+        if (target_flag != null)
         {
-            //Amount of resources worker is carrying right now
-            this.amount = collision.gameObject.GetComponent<Resource>().extractResource(this.max_amount);
-            //Gives target resource to resource variable
-            this.resource = this.target.GetComponent<Resource>();
-            StartCoroutine("goHome");
-        }
-        else if (collision.gameObject.name == "City")
-        {
-            //resets amount and resource variables
-            this.amount = 0;
-            this.resource = null;
-            MoveTo(this.target);
+            if(collision.gameObject.transform.position == target_flag.transform.position)
+            {
+
+                if (resource == null)
+                {
+                    if (home.GetComponent<BoxCollider2D>().bounds.Contains(new Vector3(target_flag.transform.position.x, target_flag.transform.position.y,home.transform.position.z)))
+                    {
+                        Destroy(target_flag);
+                        this.resource = null;
+                        this.amount = 0;
+                    }
+                    else if (send_to_resource && target.GetComponent<Outcrop>() && target.tag == "Buildable")
+                    {
+                        if(this.amount > 0) { }
+                            target.GetComponent<Outcrop>().addResource(this.amount);
+                        Requested_resource = target.GetComponent<Outcrop>().getNeededResource();
+                        Requested_amount = target.GetComponent<Outcrop>().stillNeeded();
+                        if (this.Requested_amount == 0)
+                        {
+                            this.Requested_resource = null;
+                            this.target = null;
+                        }
+                        StartCoroutine("goHome");
+                    }
+                    else
+                    {
+                        if(target != null)
+                        {
+                            //Amount of resources worker is carrying right now
+                            this.amount = target.GetComponent<Resource>().extractResource(this.max_amount);
+                            //Gives target resource to resource variable
+                            this.resource = this.target.GetComponent<Resource>();
+                        }
+                        StartCoroutine("goHome");
+                    }
+
+                    
+                }
+                else
+                {
+                    StartCoroutine("goHome");
+                }               
+            }
+            else
+            {
+                if (collision.gameObject.GetComponent<BoxCollider2D>().bounds.Contains(new Vector3(home.transform.position.x, home.transform.position.y, collision.gameObject.transform.position.z)))
+                {
+                    if (target.GetComponent<Outcrop>() && this.Requested_resource != null)
+                    {
+                        if(this.Requested_amount < this.max_amount)
+                            this.amount = home.GetComponent<City>().UseResource(this.Requested_resource, this.Requested_amount);
+                        else
+                            this.amount = home.GetComponent<City>().UseResource(this.Requested_resource, this.max_amount);
+                    }
+                    else
+                    {
+                        //resets amount and resource variables
+                        collision.gameObject.GetComponent<City>().AddResource(this.resource, this.amount);
+                        this.amount = 0;
+                    }
+
+                    this.resource = null;
+                    MoveTo(this.target);
+                }
+            }
         }
     }
     IEnumerator goHome()
     {
         yield return new WaitForSeconds(4);
+        if(target == null)
+            DestroyImmediate(target_flag);
         MoveTo(home);
     }
 

Assets/Scripts/CollectorMover.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CollectorMover : MonoBehaviour
+{ 
+    [SerializeField]
+    Sprite[] sprites = null;
+    Collector col;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        col = gameObject.GetComponent<Collector>();
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (col.GetMoveToTarget() == null) return;
+        //Vector3 target = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+        Vector3 target = col.GetMoveToTarget().transform.position;
+        Vector3 dir = target - transform.position;
+        GameObject go = new GameObject();
+        go.transform.position = target;
+        dir = go.transform.InverseTransformDirection(dir);
+        float angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
+        angle += 22.5f;
+            
+        Destroy(go);
+        SpriteRenderer rd = gameObject.GetComponent<SpriteRenderer>();
+        if(angle > -180 && angle < -135f)
+        {
+            rd.sprite = sprites[3];
+        }
+        else if (angle > -135f && angle < -90f)
+        {
+            rd.sprite = sprites[1];
+        }
+        else if (angle > -90f && angle < -45f)
+        {
+            rd.sprite = sprites[0];
+        }
+        else if (angle > -45f && angle < 0f)
+        {
+            rd.sprite = sprites[2];
+        }
+        else if (angle > 0f && angle < 45f)
+        {
+            rd.sprite = sprites[4];
+        }
+        else if (angle > 45f && angle < 90f)
+        {
+            rd.sprite = sprites[6];
+        }
+        else if (angle > 90f && angle < 135f) {
+            rd.sprite = sprites[7];
+        }
+        else if (angle > 135f && angle < 180f)
+        {
+            rd.sprite = sprites[5];
+        }
+        else 
+        {
+            rd.sprite = sprites[3];
+        }
+    }
+    
+}

Assets/Scripts/CollectorMover.cs.meta

+fileFormatVersion: 2
+guid: 266b3ace213eb154d80f94023b63eabb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/EventSystem.meta

+fileFormatVersion: 2
+guid: 9116c188ab2d3f747a13fc0390e5f874
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/EventSystem.cs → Assets/Scripts/EventSystem/EventSystem.cs

@@ -17,7 +17,7 @@ public static class EventSystem
     {
         if (events.ContainsKey(name))
         {
-            foreach (IAction e in events.Values){
+            foreach (IAction e in events[name]){
                 e.React(name);
             }
         }

Assets/Scripts/EventType.cs → Assets/Scripts/EventSystem/EventType.cs

@@ -4,14 +4,20 @@ using UnityEngine;
 
 public enum EventType
 {
-    GameStarts, //music
-    TimePeriodChanged, // music
-    CitySmall, //music
-    CityBig, //music
-    WoodChopped, //effect
-    StoneCut, //effect
-    HuntingSmall, //music
-    HuntingBig, //music
-    UpgradeBuilt //effect
+    //music
+    GameStarts, 
+    TimePeriodChanged, 
+    CitySmall, 
+    CityBig, 
+    HuntingSmall,
+    HuntingBig,
+    WinMusic,
+    MenuMusic,
+    Ultimate,
+    //effects
+    WoodChopped, 
+    StoneCut, 
+    Berrypicked,
+    UpgradeBuilt
 
 }

Assets/Scripts/Flag.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Flag : MonoBehaviour
+{
+    [SerializeField]
+    private GameObject Worker;
+
+    private void Start()
+    {
+        StartCoroutine("resize");
+    }
+    public void SetWorker(GameObject w)
+    {
+        this.Worker = w;
+    }
+    public GameObject GetWorker()
+    {
+        return this.Worker;
+    }
+
+    private IEnumerator resize() {
+        int multiplier = 1;
+        while (true) {
+            for (int i = 0; i < 100; i++) {
+                yield return new WaitForSeconds(0.01f);
+                transform.localScale = transform.localScale + new Vector3(0.01f,0.01f,0)*multiplier;
+            }
+            multiplier *= -1;
+        }
+    }
+}

Assets/Scripts/Flag.cs.meta

+fileFormatVersion: 2
+guid: 1c028ba564ee8304e9c41111c8912ebe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GameEnd.meta

+fileFormatVersion: 2
+guid: cf62eacc43e8a40469118b61f12a5364
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GameEnd/MoveRandomly.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class MoveRandomly : MonoBehaviour
+{
+    // Start is called before the first frame update
+    void Start()
+    {
+        StartCoroutine("moveAround");
+    }
+
+    private IEnumerator moveAround() {
+        while (true)
+        {
+            float moveTime = Random.value * 2;
+            float timeSpent = 0;
+            Vector3 direction = new Vector3(Random.value*2-1,Random.value*2-1, 0);
+
+            while (timeSpent < moveTime)
+            {
+                transform.position = transform.position + direction*0.01f;
+                yield return null;
+                timeSpent += Time.deltaTime;
+
+            }
+        }
+    }
+}

Assets/Scripts/GameEnd/MoveRandomly.cs.meta

+fileFormatVersion: 2
+guid: d3063605b31636c4e9998676be17db5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GameEnd/WinGame.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class WinGame : MonoBehaviour
+{
+    [SerializeField]
+    private GameObject housePrefab = null;
+    [SerializeField]
+    private GameObject workerPrefab = null;
+
+    private List<GameObject> houses = new List<GameObject>();
+
+    void Start()
+    {
+        StartCoroutine("MoveCamera");
+        StartCoroutine("EndGame");
+    }
+    private IEnumerator MoveCamera()
+    {
+        while (Camera.main.orthographicSize < 9f) {
+            Camera.main.orthographicSize += 0.01f;
+            yield return null;
+        }
+    }
+
+    private IEnumerator EndGame()
+    {
+        EventSystem.EventHappened(EventType.TimePeriodChanged);
+        float spawnRate = 5f;
+        int count = 0;
+        while (count < 9)
+        {
+            GameObject go = Instantiate<GameObject>(housePrefab);
+            Destroy(go.GetComponent<BoxCollider2D>());
+            houses.Add(go);
+            go.transform.position = new Vector3(Random.Range(1f, 14f), Random.Range(1f, 14f),-5);
+            spawnRate -= 0.5f;
+            yield return new WaitForSeconds(spawnRate);
+            count++;
+        }
+        for (int i = 0; i < 10; i++) {
+            GameObject go = Instantiate<GameObject>(housePrefab);
+            Destroy(go.GetComponent<BoxCollider2D>());
+            houses.Add(go);
+            go.transform.position = new Vector3(Random.Range(1f, 14f), Random.Range(1f, 14f), -5);
+            yield return new WaitForSeconds(spawnRate);
+        }
+        count = 0;
+        EventSystem.EventHappened(EventType.WinMusic);
+        while (count < 150)
+        {
+            GameObject go = Instantiate<GameObject>(workerPrefab);
+            int index = Random.Range(0, houses.Count);
+            go.transform.position = houses[index].transform.position;
+            go.AddComponent<MoveRandomly>();
+            Destroy(go.GetComponent<Collector>());
+            Destroy(go.GetComponent<Rigidbody2D>());
+            yield return new WaitForSeconds(0.1f);
+            count++;
+        }
+    }
+    
+}