The module assignment involves a portfolio of work to be individually completed.

INSTRUCTIONS TO CANDIDATES

ANSWER ALL QUESTIONS

Introduction and Assignment Overview

 

Complexity science is the scientific study of complex systems. These are systems with many parts that interact to produce global behaviour. These systems cannot easily be explained in terms of interactions between the individual elements. Complex systems are dynamic, unpredictable and have many elements. They exhibit emergent behaviour (rather than prescriptive behaviour) that is not easy to predict.

 

Complex systems can be found almost everywhere, examples include:

• Ecosystems,

• Cities and Businesses,

• Crowd Simulation,

• Our Brains.

• The Internet (not individual computer system).

 

In this module, you will explore and model complex systems. You will learn how to simulate (e.g. program) complex systems and research the topic in terms of artificial intelligence and emerging autonomous technologies.

 

The module assignment involves a portfolio of work to be individually completed. The portfolio comprises of two tasks and provides overall evidence of your development in the area of complex systems. The portfolio should include an application and a research report. Please see the assignment specification below for more details. The purpose of the assignment is to allow students to explore automated agents, software simulation of complex systems and artificial intelligence topics.

 

><><><><><><><><><><><><><><><><><><><><><><><><><><><><

 

Assignment Details

 

Portfolio Task 1: Design and Build an Automated Agent

 

Indicative portfolio task weighting: 60%.

Due date: Week 12.

What to submit?: An individual software development project. See below for more details.

Word limit: N/A.

 

For this portfolio task you are required to design and build a simulation (i.e. a virtual environment) and an automated virtual agent (i.e. robot that uses the virtual environment) that will act and react to its environment. By the end of this task you will have created a software simulator that simulates a virtual environment. This task provides students with the practical experience of developing a software simulator and virtual agent that will demonstrate the student’s knowledge and skills in the field.

 

You should build and document an autonomous agent written using the module tools, namely, Unity and C#. The agent should be able to:

• navigate a known waypoint graph environment in a simulated world.

• follow instructions based on a predetermined algorithm, but also be able to adapt to its environment so becoming an ‘intelligent agent’.

• interact with other agents for a collaborative goal.

 

Below is a detailed overview of key elements of this portfolio task. This task is split into three parts. Each part requires an again to be developed (i.e. coded).

 

Virtual Agent and Virtual Environment

 

In the future robots or drones may deliver or collect things (e.g. parcels or people). In this assignment you are required to develop an autonomous automated agent that represents a delivery or collection agent. In general, the agent should collect or deliver things from a start location. It should move to one or more delivery or collection locations. The agent should then return to the start location. The agent should act and react to its environment. See the parts below for more detail.

 

For simplicity, in this document I will refer to this scenario as a delivery or collection agent; however, you are encouraged to apply a theme of your choice to the simulation and virtual agent. Students are encouraged to be creative but should bear in mind the feasibility of the implementation and the requirements in this document as a constraint.

 

Here are some examples of possible agent themes. They are split into two types, delivery and collection. In a delivery scenario an item or items are transported to a goal(s) and the delivery agent returns to a home location. In a collection scenario an item or items are picked up from a goal(s) and the collection agent returns to a home location. They are essentially the same scenario; however, in the delivery scenario an agent has items before the

 

goal(s) are reached. In the collection scenario the agent has items after the goal(s) have been reached.

 

Delivery scenario examples:

• Humanoid agent delivering parcels.

• Vehicle (e.g. lorry) agent delivering parcels.

• Animal storing food at locations for the winter.

• Drone agent delivering parcels.

• Simple taxi driver dropping off passenger(s).

o No passenger pick-up required. Taxi already has passenger(s).

 

Collection scenario examples:

• Lumberjack cutting down trees and returning to a sawmill.

• Animal collecting food and returning to a home.

• Humanoid or vehicle (e.g. lorry) agent collecting parcels.

• Simple taxi driver collecting passenger(s).

o No passenger drop-off required. Passengers are taken to taxi home location.

 

You can also choose an environment theme. Typically, this would match the agent theme. For example:

• Small area with house or drop-boxes / points.

• Larger area with roads, buildings or drop-boxes / points.

• Forest with trees and sawmill.

• Land animal environment (e.g. ants or tigers), home location and food locations.

• Underwater animal environment (e.g. fish), home location and food locations.

• Air environment (e.g. birds), home location and food locations.

• Medieval (e.g. Footman collecting food).

• Futuristic (e.g. robots).

 

You are encouraged to apply a theme to your agent and environment; however, a simple robot delivery theme is fine. As we stated earlier, in this document I will refer to the assignment scenario as a delivery or collection agent; however, your theme could represent something else, such as a lumberjack cutting down trees and returning to a sawmill.

 

Important - Remember, you must only implement one type of agent (e.g. delivery or collection) for all parts of the assignment. You must keep the agent type and environment theme the same for all parts of the assignment.

 

Your also need to create a simple virtual environment. As discussed above, you can apply a theme to the environment.

 

You need to create a waypoint graph representation of the environment that your agents will use to navigate to locations. Your waypoint graph should have at least 12 nodes. You should create a standard waypoint

 

graph with at least 12 nodes and a reasonable set of connections (i.e. edges) between the nodes. The graph should be able to work with a standard pathfinding algorithm. A user should be able set a start location and multiple goal locations (up to 8 goal locations). A user should be able to do this via an interface or the Unity Inspector. The start location cannot be a goal location.

 

OR, you can create a simple waypoint graph where every waypoint node is connected to every other waypoint node via a straight-line connection. In this type of graph / environment an agent can move in a straight-line between any node in the graph (i.e. a straight-line between any location in the environment). This means an agent can use a simple straight-line movement algorithm to move from a start node to any other node, such as a goal node. The agent would not need to use a pathfinding algorithm. A user should be able set a start location and multiple goal locations (up to 8 goal locations). A user should be able to do this via an interface or the Unity Inspector. The start location cannot be a goal location. If you implement this simple waypoint graph you will only receive a pass mark for the waypoint graph elements of the assignment.

 

You should implement the world representation (waypoint graph / map) and pathfinding algorithm yourself. You should not use navigation methods built into Unity. If you do use built-in Unity techniques, you will receive 0% for the waypoint graph elements of the assignment.

 

Measuring Performance

 

The performance of all the agents you create should be measured during all their runs / trips / journeys. Performance measures should include time and total distance. During the simulation, a stopwatch should be used to time the duration for the total task time. The output from performance measures can be displayed via a user interface or printed to the Unity console.

Part 1 - Virtual Agent for a Known Environment and Single Delivery or

Collection Location (Week 4)

You are required to develop an autonomous automated agent that represents a delivery or collection agent (e.g. robot). The agent should start at a home location and deliver or collect an item (e.g. parcel) from a goal location. The agent should then return home.

Important - The exact representation of your agent and environment will depend on your selected theme (e.g. a robot or drone that delivers parcels). See above for details.

The agent you create should be able to navigate a waypoint graph representation of your virtual environment. The agent should be able to move from a start location (e.g. a home location or any node on the graph) and navigate (using a pathfinding technique) to another node on the graph (e.g. a

delivery location / waypoint node). When the agent has reached their target, they should deliver or collect their item and return to the start location.

The act of delivering or collecting an item does not need to be animated / virtually recreated. For example, in a delivery scenario you can simply use a box / parcel 3D model that disappears into the delivery location.

 

The agent in this part of the task has full knowledge of the virtual environment. The agent can see the whole environment and can use traditional navigation algorithms to move to target locations.

 

The agent should be able navigate using one of the following techniques:

• Standard waypoint graph and A* pathfinding.

• Simple waypoint graph and straight-line movement.

o Note, you will only receive a pass mark for the waypoint graph elements of the assignment if you use this technique.

 

You should implement the world representation (waypoint graph / map) and pathfinding algorithm yourself. You should not use navigation methods built into Unity.

 

In this part of the task the agent only has one goal location to deliver or collect an item. There is only one start location.

 

Don’t forget to include performance information (see above) in the agent code.

 

Part 2 - Collaborative Virtual Agent for a Known Environment and Single

Delivery Location with Multiple Items (Week 8)

 

The second agent builds upon the work you completed for the first agent. You should use the same agent and environment theme. However, note in this scenario the agent has different abilities / behaviour.

 

You are required to develop an autonomous automated agent that represents a delivery or collection agent (e.g. robot). The agent should start at a home location and deliver or collect an item (e.g. parcel) from a goal location. The agent should then return home. The agent should be able to act and re-act to obstacles and other instances of itself in the environment.

 

In this part the agent should be able to carry at least 10 items (e.g. parcels). The number of items an agent is going to carry should be able to be set in the Inspector or via a user interface. The speed of the agent should be affected by the number of parcels it is carrying. The speed of the agent should drop 10% for each parcel the agent is carrying. The speed of the agent should drop a maximum of 90% its original speed.

 

The agent should also include some sort of visual representation of the items it is carrying. For example, you could add a 3D model for each parcel the

 

agent is carrying, or you could simply output a number above the agent to indicate the number of parcels it holds.

 

The agent should be able to navigate environment (using a waypoint graph) that contains many agents. The agent should be able to move from a start location (e.g. a home location or any node on the graph) and navigate (using a pathfinding technique) to another node on the graph (e.g. a delivery location / waypoint node). When the agent has reached their target, they should deliver or collect their item(s) and return to the start location. You should be able to add at least three agents into the environment.

 

In addition, the agent should monitor its environment for other agents. The agent should collaborate with other agents by monitoring its separation and speed. The agent should adjust its speed (generally slow) when other agents come within a safety zone. If other agents get too close the agent should stop. The agents should communicate and collaborate / negotiate in order to allow one agent to keep moving. You don’t want both agents to stop and continually block each other and the waypoint map forever.

Your collaboration algorithm should consider the agents speed and immediate direction / destination when deciding which agent should move first / have right of way. Remember, your agents speed should slow based on the number of items it is carrying. Therefore, you want to avoid a slow agent blocking a faster agent.

Don’t forget to include performance information (see above) in the agent code. You should also output information about collaboration encounters between agents.

 

Attachments:

Related Questions

. Introgramming & Unix Fall 2018, CRN 44882, Oakland University Homework Assignment 6 - Using Arrays and Functions in C

DescriptionIn this final assignment, the students will demonstrate their ability to apply two ma

. The standard path finding involves finding the (shortest) path from an origin to a destination, typically on a map. This is an

Path finding involves finding a path from A to B. Typically we want the path to have certain properties,such as being the shortest or to avoid going t

. Develop a program to emulate a purchase transaction at a retail store. This program will have two classes, a LineItem class and a Transaction class. The LineItem class will represent an individual

Develop a program to emulate a purchase transaction at a retail store. Thisprogram will have two classes, a LineItem class and a Transaction class. Th

. SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of Sea Ports. Here are the classes and their instance variables we wish to define:

1 Project 1 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of

. Project 2 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of Sea Ports. Here are the classes and their instance variables we wish to define:

1 Project 2 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of