gerona | Generic Robot Navigation ) is a modular robot navigation | Robotics library

To get source and destination, you will need to do an array_diff of all Departure and Arrival keys.

Now, you just need to iterate from source to destination data and print the text according to the Transportation. To get the value of any departure data in O(1) time on average, you can re-index your data using array_column.

Snippet:

The code you provided violates a few rules for OOP hence can not be considered as such.

It is a representation of objects that interact with each other in order to create your program, instead of scripts that call each other (hope this makes sense). You have to start thinking how you can represent your problem into objects.

Let's say you have a car to represent in PHP.

You will start to think you can have:

1. A car class;
2. A Wheel class (you car can have 4 wheels);
3. Then you think "But a car is a vehicle and, for example, a bike only have 2 wheels" and then you create your "Vehicle class";
4. Then you enhance your Car Class and extend it from Vehicle;
5. Now, each Vehicle have tyres, but you do not specify how many, that is for each type to decide, not the parent class that "abstracts them".

And so on. You quickly see here that to tackle this problem (and we are on the very start) you already have;

1. Abstract Class Vehicle;
2. Car Class (that extends Vehicle);
3. Bike Class (that extends Vehicle);
4. Wheel Class (That can be added to Vehicle types -> Your Car and your Bike);

When you want to move to OOP there are a few rules you need to consider:

1. Encapsulation;
2. Polymorphism;
3. Open/Close implementation;
4. Inheritance;
5. Open Recursion;

You want to restrict your Class objects to only understand "what they are". So a Car does not hold logic for a Bike and vice-versa.

1. Encapsulation -> This prevents external code from manipulating or "holding concern" to what happens on the target class internally;

It refers to the use of private and protected methods; How the Car class behaves and what it triggers to work in whatever logic you decide a Car should work, is completely hidden for the other classes like Bike. They do not need to know what clicks on each other!

2. Polymorphism -> For example, the number of tyres, or even the Tyre types for each Vehicle, it will be different. Therefore you can declare the Vehicle can addTyres BUT each Vehicle type (like Car and Bike) will implement how to addTyres differently (You can limit bikes to have 2 tyres only whilst cars have 4);

3. Open/Close implementation -> When you create classes you should think on them as they should be OPEN for extension BUT CLOSED for modification. This means you can extend their behaviour BUT you should never have to go back and change your object behaviour;

4. Inheritance -> Allows your Classes to implement "hierarchy". Think of it as "parent" and "children". What came "First" and what came "after". Like a Shape is a parent of a Circle. If you announcing your argument, Shape is very abstract as it represents anything from Squares, Triangles, Circles, etc. But if you refer to a Square you know about it in more detail, like vertices, angles, etc! Shapes represent that but refine nothing towards what type, just what structure should be but not "how it will be";

5. Open Recursion -> Classes are able to call each other and even other classes. That is how they interact. Hell they can even have other objects as part of their attributes;

In a very resumed source this is a very BRIEF introduction to OOP! Once you get the hang of it it is amazing and you will have such a powerful logical code and so organised I swear to you, you will not go back :3

But yeah, this is not enough to even begin telling you OOP! :x Just think of it this way, it is a walk, not a destination :D

PS: A great way to start getting used to OOP is also starting to look at Design Patterns

I have achieved my purpose. I have got it like:

here is a way. Finding the start, and search the path, by iteration :