How to implement logic based on a relationship matrix - c++

Question

Consider that I have a symmetrical relationship matrix, similar to this:
Except that each "outcome" is a small piece of code.
My scenario: I have a bunch of Entity objects that "collide" with eachother. Each entity has a CollisionType value (an enum). In the design, a relationship matrix exists which describes how the entities behave when different CollisionTypes meet each other.
I'm wondering: How would I represent the relationships, and also implement logic on top of it, in an clean and high-performance manner which is easy to add new CollisionTypes to? In my mind it looks something like a 2D Switch statement.
Example (poor) solution:
void CollideEntities( Entity e1, Entity e2 ) {
CollisionType t1 = e1.GetCollisionType();
CollisionType t2 = e2.GetCollisionType();
// perform basic logic based on t1 & t2
if ( (t1 == COL_SOLID && t2 == COL_SQUISHY) || (t1 == COL_SQUISHY && t2 == COL_SOLID) ) {
// do stuff..
} else if ( (t1 == COL_SOLID && t2 == COL_DAMAGE) || (t1 == COL_DAMAGE && t2 == COL_SOLID) ) {
// do other stuff..
} // and so on...
}
Many potential solutions are apparent to me, but none of them strike me as particularly clean or efficient or easy to add new types to...

Answer 1

I wouldn't do it that way. I'd have a Map where the key would look up a Command object containing the desired behavior.
Another possibility would be a Visitor pattern (aka "double dispatch").

Answer 2

Try this:
#include <vector>
#include <iostream>
class Symmetric_matrix {
private:
size_t size1;
// The next should be <bool> rather than <int>,
// but the writer's compiler objects.
std::vector<int> outcomes;
public:
size_t size() const { return size1; }
int &operator()(const size_t i, const size_t j) {
const size_t a = i <= j ? i : j;
const size_t b = i <= j ? j : i;
return outcomes[(b*(b-1))/2 + a];
}
Symmetric_matrix(const size_t size0)
: size1(size0), outcomes((size()*(size()-1))/2, false) {}
};
// Here is a test driver.
int main() {
Symmetric_matrix sm(5);
sm(0, 1) = true;
sm(0, 3) = true;
sm(1, 3) = true;
sm(2, 3) = true;
sm(3, 4) = true;
std::cout << "buyer-approver : " << sm(0, 2) << "\n";
std::cout << "approver-buyer : " << sm(2, 0) << "\n";
std::cout << "approver-requisition: " << sm(2, 3) << "\n";
std::cout << "requisition-approver: " << sm(3, 2) << "\n";
return 0;
}
Your question is an interesting one. As you have observed, one need only store the upper or the lower triangle of the matrix, not both.
But what's the (b*(b-1))/2 about, you ask? Answer: it comes of the curious arithmetical fact that 0 + 1 + 2 + ... + (b-1) == (b*(b-1))/2 (try it).
Of course, my sample code could stand some improvement. For one thing, for some reason (advice is requested), my code fails when it uses a std::vector<bool>, so I have used a std::vector<int> as a workaround. For another, it does not include proper handling for the case i == j. What it does do however is to convey the essential technique. You can fill out details at your discretion.
(Update: It has later occurred to my why the std::vector<bool> fails. It fails because std::vector<bool> is implemented as an array of bits, whereas a single bit cannot be an lvalue because it has no address of its own. With clever coding, by having the operator()() return a manipulator of some specially defined type, one could probably finesse the problem without altering main(), but it is probably easiest just to define and use a set() member function if the <bool> is what we want to use.)