spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

                //...
                using EventPtr = void*;
                using InstancePtr = void*;
                //...

                template<typename TEvent, class TClass, void(TClass::*TCallback)(TEvent*)>                
                static inline void MethodCallback(InstancePtr instance, EventPtr event){
                    (static_cast<TClass*>(instance)->*TCallback)(static_cast<TEvent*>(event));
                }

C-/C++-Quelltext

                using CallbackPtr   = void(*)(InstancePtr, EventPtr);
                using Callback      = std::pair<InstancePtr, CallbackPtr>;

C-/C++-Quelltext

                using CallbackList = std::vector<Callback>;
                using UUID         = uint32_t;
                using Connections  = std::map<uint32_t, CallbackList>;
                Connections connections;

C-/C++-Quelltext

               template<struct TEvent, class TClass, void(TClass::*TCallback)(TEvent*)>
               void bind(TClass* instance){
                   uint32_t uuid{TEvent::uuid()};
                 
                   connections[uuid].emplace_back(nullptr,// Eigentlich sollte hier [b]instance[/b] stehen.
                                                  &MethodCallback<TEvent, TClass, TCallback>);
               }

C-/C++-Quelltext

                template<typename TEvent>
                void    emit(TEvent* event){
                    for(auto cb : connections[TEvent::uuid()])
                        cb.second(cb.first, event); // <- Hier nullptr exception erwartet.
                        
                        // Vergleich mit vorherigen Codebeispiel
                        // std::pair.first  -> Pointer zur Instanz der Klasse
                        // std::pair.second -> Pointer zur Methode
                }

Java-Quelltext

package main;

public class Main {
    
    public static class ServerConnection {
        void sendRegistartionAborted() {
            System.out.println("RegistrationAborted - sent");
        }
        void sendCrashed(int playerID) {
            System.out.println("Crashed(" + new Integer(playerID) + ") - sent");
        }
        void sendKicked(int playerID, String msg) {
            System.out.println("Kicked(" + new Integer(playerID) +
                               ", \"" + msg + "\") - sent");
        }
    }

    public interface Event {
        public void send(ServerConnection con);
    }

    enum Events implements Event {
        RegistrationAborted {
            @Override
            public void init() {
                System.out.println("RegistrationAborted - Init");
            }
            
            @Override
            public void send(ServerConnection con) {
                con.sendRegistartionAborted();
            }
        },
        Crashed {
            private int i;
            
            @Override
            public void init(int i) {
                System.out.println("Crashed - Init");
                
                this.i = i;
            }
            
            @Override
            public void send(ServerConnection con) {
                con.sendCrashed(this.i);
            }
        },
        Kicked {
            private int i;
            private String msg;
            
            @Override
            public void init(int i, String msg) {
                System.out.println("Kicked - Init");
                
                this.i = i;
                this.msg = msg;
            }
            
            @Override
            public void send(ServerConnection con) {
                con.sendKicked(this.i, this.msg);
            }
        };

        public void init()
        { throw new IllegalArgumentException("Undefined for this enum value"); }
        public void init(int val)
        { throw new IllegalArgumentException("Undefined for this enum value"); }
        public void init(int val, String msg)
        { throw new IllegalArgumentException("Undefined for this enum value"); }
    }

    public static void main(String[] args) {
        ServerConnection sv = new ServerConnection();
        
        Events.Crashed.init(100);
        Events.Crashed.send(sv);
        
        Events.Kicked.init(123, "Being dumb");
        Events.Kicked.send(sv);
        
        Events.RegistrationAborted.init();
        Events.RegistrationAborted.send(sv);
        
        System.out.println();
        
        Events ev = Events.Crashed;
        ev.init(556);
        Events.Crashed.send(sv);
    }

}

C-/C++-Quelltext

std::vector<std::vector<std::vector<std::vector<char>>>>