add custom ctos and stoc

ygopro-server.coffee

@@ -1615,16 +1615,25 @@ net.createServer (client) ->
             cancel = false
             if settings.modules.reconnect.enabled and client.pre_reconnecting and ygopro.constants.CTOS[ctos_proto] != 'UPDATE_DECK'
               cancel = true
+            b = ctos_buffer.slice(3, ctos_message_length - 1 + 3)
+            info = null
+            if struct = ygopro.structs[ygopro.proto_structs.CTOS[ygopro.constants.CTOS[ctos_proto]]]
+              struct._setBuff(b)
+              info = _.clone(struct.fields)
+            if ygopro.ctos_follows_before[ctos_proto] and !cancel
+              for ctos_event in ygopro.ctos_follows_before[ctos_proto]
+                result = ctos_event.callback b, info, client, client.server, datas
+                if result and ctos_event.synchronous
+                  cancel = true
             if ygopro.ctos_follows[ctos_proto] and !cancel
-              b = ctos_buffer.slice(3, ctos_message_length - 1 + 3)
-              info = null
-              if struct = ygopro.structs[ygopro.proto_structs.CTOS[ygopro.constants.CTOS[ctos_proto]]]
-                struct._setBuff(b)
-                info = _.clone(struct.fields)
-              if ygopro.ctos_follows[ctos_proto].synchronous
-                cancel = ygopro.ctos_follows[ctos_proto].callback b, info, client, client.server, datas
-              else
-                ygopro.ctos_follows[ctos_proto].callback b, info, client, client.server, datas
+              result = ygopro.ctos_follows[ctos_proto].callback b, info, client, client.server, datas
+              if result and ygopro.ctos_follows[ctos_proto].synchronous
+                cancel = true
+            if ygopro.ctos_follows_after[ctos_proto] and !cancel
+              for ctos_event in ygopro.ctos_follows_after[ctos_proto]
+                result = ctos_event.callback b, info, client, client.server, datas
+                if result and ctos_event.synchronous
+                  cancel = true
             datas.push ctos_buffer.slice(0, 2 + ctos_message_length) unless cancel
             ctos_buffer = ctos_buffer.slice(2 + ctos_message_length)
             ctos_message_length = 0
@@ -1683,17 +1692,25 @@ net.createServer (client) ->
         if stoc_buffer.length >= 2 + stoc_message_length
           #console.log "STOC", ygopro.constants.STOC[stoc_proto]
           cancel = false
-          stanzas = stoc_proto
-          if ygopro.stoc_follows[stoc_proto]
-            b = stoc_buffer.slice(3, stoc_message_length - 1 + 3)
-            info = null
-            if struct = ygopro.structs[ygopro.proto_structs.STOC[ygopro.constants.STOC[stoc_proto]]]
-              struct._setBuff(b)
-              info = _.clone(struct.fields)
-            if ygopro.stoc_follows[stoc_proto].synchronous
-              cancel = ygopro.stoc_follows[stoc_proto].callback b, info, server.client, server, datas
-            else
-              ygopro.stoc_follows[stoc_proto].callback b, info, server.client, server, datas
+          b = stoc_buffer.slice(3, stoc_message_length - 1 + 3)
+          info = null
+          if struct = ygopro.structs[ygopro.proto_structs.STOC[ygopro.constants.STOC[stoc_proto]]]
+            struct._setBuff(b)
+            info = _.clone(struct.fields)
+          if ygopro.stoc_follows_before[stoc_proto] and !cancel
+            for stoc_event in ygopro.stoc_follows_before[stoc_proto]
+              result = stoc_event.callback b, info, server.client, server, datas
+              if result and stoc_event.synchronous
+                cancel = true
+          if ygopro.stoc_follows[stoc_proto] and !cancel
+            result = ygopro.stoc_follows[stoc_proto].callback b, info, server.client, server, datas
+            if result and ygopro.stoc_follows[stoc_proto].synchronous
+              cancel = true
+          if ygopro.stoc_follows_after[stoc_proto] and !cancel
+            for stoc_event in ygopro.stoc_follows_after[stoc_proto]
+              result = stoc_event.callback b, info, server.client, server, datas
+              if result and stoc_event.synchronous
+                cancel = true
           datas.push stoc_buffer.slice(0, 2 + stoc_message_length) unless cancel
           stoc_buffer = stoc_buffer.slice(2 + stoc_message_length)
           stoc_message_length = 0

ygopro-server.js

@@ -2037,7 +2037,7 @@
     }
     client.pre_establish_buffers = new Array();
     client.on('data', function(ctos_buffer) {
-      var b, bad_ip_count, buffer, cancel, ctos_message_length, ctos_proto, datas, info, len2, len3, looplimit, m, n, room, struct;
+      var b, bad_ip_count, buffer, cancel, ctos_event, ctos_message_length, ctos_proto, datas, info, len2, len3, len4, len5, looplimit, m, n, o, p, ref2, ref3, result, room, struct;
       if (client.is_post_watcher) {
         room = ROOM_all[client.rid];
         if (room && !CLIENT_is_banned_by_mc(client)) {
@@ -2071,17 +2071,36 @@
               if (settings.modules.reconnect.enabled && client.pre_reconnecting && ygopro.constants.CTOS[ctos_proto] !== 'UPDATE_DECK') {
                 cancel = true;
               }
+              b = ctos_buffer.slice(3, ctos_message_length - 1 + 3);
+              info = null;
+              if (struct = ygopro.structs[ygopro.proto_structs.CTOS[ygopro.constants.CTOS[ctos_proto]]]) {
+                struct._setBuff(b);
+                info = _.clone(struct.fields);
+              }
+              if (ygopro.ctos_follows_before[ctos_proto] && !cancel) {
+                ref2 = ygopro.ctos_follows_before[ctos_proto];
+                for (m = 0, len2 = ref2.length; m < len2; m++) {
+                  ctos_event = ref2[m];
+                  result = ctos_event.callback(b, info, client, client.server, datas);
+                  if (result && ctos_event.synchronous) {
+                    cancel = true;
+                  }
+                }
+              }
               if (ygopro.ctos_follows[ctos_proto] && !cancel) {
-                b = ctos_buffer.slice(3, ctos_message_length - 1 + 3);
-                info = null;
-                if (struct = ygopro.structs[ygopro.proto_structs.CTOS[ygopro.constants.CTOS[ctos_proto]]]) {
-                  struct._setBuff(b);
-                  info = _.clone(struct.fields);
+                result = ygopro.ctos_follows[ctos_proto].callback(b, info, client, client.server, datas);
+                if (result && ygopro.ctos_follows[ctos_proto].synchronous) {
+                  cancel = true;
                 }
-                if (ygopro.ctos_follows[ctos_proto].synchronous) {
-                  cancel = ygopro.ctos_follows[ctos_proto].callback(b, info, client, client.server, datas);
-                } else {
-                  ygopro.ctos_follows[ctos_proto].callback(b, info, client, client.server, datas);
+              }
+              if (ygopro.ctos_follows_after[ctos_proto] && !cancel) {
+                ref3 = ygopro.ctos_follows_after[ctos_proto];
+                for (n = 0, len3 = ref3.length; n < len3; n++) {
+                  ctos_event = ref3[n];
+                  result = ctos_event.callback(b, info, client, client.server, datas);
+                  if (result && ctos_event.synchronous) {
+                    cancel = true;
+                  }
                 }
               }
               if (!cancel) {
@@ -2114,20 +2133,20 @@
           return;
         }
         if (client.established) {
-          for (m = 0, len2 = datas.length; m < len2; m++) {
-            buffer = datas[m];
+          for (o = 0, len4 = datas.length; o < len4; o++) {
+            buffer = datas[o];
             client.server.write(buffer);
           }
         } else {
-          for (n = 0, len3 = datas.length; n < len3; n++) {
-            buffer = datas[n];
+          for (p = 0, len5 = datas.length; p < len5; p++) {
+            buffer = datas[p];
             client.pre_establish_buffers.push(buffer);
           }
         }
       }
     });
     server.on('data', function(stoc_buffer) {
-      var b, buffer, cancel, datas, info, len2, looplimit, m, stanzas, stoc_message_length, stoc_proto, struct;
+      var b, buffer, cancel, datas, info, len2, len3, len4, looplimit, m, n, o, ref2, ref3, result, stoc_event, stoc_message_length, stoc_proto, struct;
       stoc_message_length = 0;
       stoc_proto = 0;
       datas = [];
@@ -2152,18 +2171,36 @@
         } else {
           if (stoc_buffer.length >= 2 + stoc_message_length) {
             cancel = false;
-            stanzas = stoc_proto;
-            if (ygopro.stoc_follows[stoc_proto]) {
-              b = stoc_buffer.slice(3, stoc_message_length - 1 + 3);
-              info = null;
-              if (struct = ygopro.structs[ygopro.proto_structs.STOC[ygopro.constants.STOC[stoc_proto]]]) {
-                struct._setBuff(b);
-                info = _.clone(struct.fields);
+            b = stoc_buffer.slice(3, stoc_message_length - 1 + 3);
+            info = null;
+            if (struct = ygopro.structs[ygopro.proto_structs.STOC[ygopro.constants.STOC[stoc_proto]]]) {
+              struct._setBuff(b);
+              info = _.clone(struct.fields);
+            }
+            if (ygopro.stoc_follows_before[stoc_proto] && !cancel) {
+              ref2 = ygopro.stoc_follows_before[stoc_proto];
+              for (m = 0, len2 = ref2.length; m < len2; m++) {
+                stoc_event = ref2[m];
+                result = stoc_event.callback(b, info, server.client, server, datas);
+                if (result && stoc_event.synchronous) {
+                  cancel = true;
+                }
               }
-              if (ygopro.stoc_follows[stoc_proto].synchronous) {
-                cancel = ygopro.stoc_follows[stoc_proto].callback(b, info, server.client, server, datas);
-              } else {
-                ygopro.stoc_follows[stoc_proto].callback(b, info, server.client, server, datas);
+            }
+            if (ygopro.stoc_follows[stoc_proto] && !cancel) {
+              result = ygopro.stoc_follows[stoc_proto].callback(b, info, server.client, server, datas);
+              if (result && ygopro.stoc_follows[stoc_proto].synchronous) {
+                cancel = true;
+              }
+            }
+            if (ygopro.stoc_follows_after[stoc_proto] && !cancel) {
+              ref3 = ygopro.stoc_follows_after[stoc_proto];
+              for (n = 0, len3 = ref3.length; n < len3; n++) {
+                stoc_event = ref3[n];
+                result = stoc_event.callback(b, info, server.client, server, datas);
+                if (result && stoc_event.synchronous) {
+                  cancel = true;
+                }
               }
             }
             if (!cancel) {
@@ -2185,8 +2222,8 @@
         }
       }
       if (server.client && !server.client.closed) {
-        for (m = 0, len2 = datas.length; m < len2; m++) {
-          buffer = datas[m];
+        for (o = 0, len4 = datas.length; o < len4; o++) {
+          buffer = datas[o];
           server.client.write(buffer);
         }
       }

ygopro.coffee

@@ -37,26 +37,55 @@ for name, declaration of structs_declaration
 
 #消息跟踪函数 需要重构, 另暂时只支持异步, 同步没做.
 @stoc_follows = {}
+@stoc_follows_before = {}
+@stoc_follows_after = {}
 @ctos_follows = {}
+@ctos_follows_before = {}
+@ctos_follows_after = {}
+
+@replace_proto = (proto, tp) ->
+  if typeof(proto) != "string"
+    return proto
+  changed_proto = proto
+  for key, value of @constants[tp]
+    if value == proto
+      changed_proto = key
+      break
+  throw "unknown proto" if !@constants[tp][changed_proto]
+  return changed_proto
+
 @stoc_follow = (proto, synchronous, callback)->
-  if typeof proto == 'string'
-    for key, value of @constants.STOC
-      if value == proto
-        proto = key
-        break
-    throw "unknown proto" if !@constants.STOC[proto]
-  @stoc_follows[proto] = {callback: callback, synchronous: synchronous}
+  changed_proto = @replace_proto(proto, "STOC")
+  @stoc_follows[changed_proto] = {callback: callback, synchronous: synchronous}
+  return
+@stoc_follow_before = (proto, synchronous, callback)->
+  changed_proto = @replace_proto(proto, "STOC")
+  if !@stoc_follows_before[changed_proto]
+    @stoc_follows_before[changed_proto] = []
+  @stoc_follows_before[changed_proto].push({callback: callback, synchronous: synchronous})
+  return
+@stoc_follow_after = (proto, synchronous, callback)->
+  changed_proto = @replace_proto(proto, "STOC")
+  if !@stoc_follows_after[changed_proto]
+    @stoc_follows_after[changed_proto] = []
+  @stoc_follows_after[changed_proto].push({callback: callback, synchronous: synchronous})
   return
 @ctos_follow = (proto, synchronous, callback)->
-  if typeof proto == 'string'
-    for key, value of @constants.CTOS
-      if value == proto
-        proto = key
-        break
-    throw "unknown proto" if !@constants.CTOS[proto]
-  @ctos_follows[proto] = {callback: callback, synchronous: synchronous}
+  changed_proto = @replace_proto(proto, "CTOS")
+  @ctos_follows[changed_proto] = {callback: callback, synchronous: synchronous}
+  return
+@ctos_follow_before = (proto, synchronous, callback)->
+  changed_proto = @replace_proto(proto, "CTOS")
+  if !@ctos_follows_before[changed_proto]
+    @ctos_follows_before[changed_proto] = []
+  @ctos_follows_before[changed_proto].push({callback: callback, synchronous: synchronous})
+  return
+@ctos_follow_after = (proto, synchronous, callback)->
+  changed_proto = @replace_proto(proto, "CTOS")
+  if !@ctos_follows_after[changed_proto]
+    @ctos_follows_after[changed_proto] = []
+  @ctos_follows_after[changed_proto].push({callback: callback, synchronous: synchronous})
   return
-
 
 #消息发送函数,至少要把俩合起来....
 @stoc_send = (socket, proto, info)->
@@ -171,4 +200,4 @@ for name, declaration of structs_declaration
   if client
     client.system_kicked = true
     client.destroy()
-  return
+  return
\ No newline at end of file

ygopro.js

@@ -58,50 +58,102 @@
 
   this.stoc_follows = {};
 
+  this.stoc_follows_before = {};
+
+  this.stoc_follows_after = {};
+
   this.ctos_follows = {};
 
-  this.stoc_follow = function(proto, synchronous, callback) {
-    var key, ref, value;
-    if (typeof proto === 'string') {
-      ref = this.constants.STOC;
-      for (key in ref) {
-        value = ref[key];
-        if (value === proto) {
-          proto = key;
-          break;
-        }
-      }
-      if (!this.constants.STOC[proto]) {
-        throw "unknown proto";
+  this.ctos_follows_before = {};
+
+  this.ctos_follows_after = {};
+
+  this.replace_proto = function(proto, tp) {
+    var changed_proto, key, ref, value;
+    if (typeof proto !== "string") {
+      return proto;
+    }
+    changed_proto = proto;
+    ref = this.constants[tp];
+    for (key in ref) {
+      value = ref[key];
+      if (value === proto) {
+        changed_proto = key;
+        break;
       }
     }
-    this.stoc_follows[proto] = {
+    if (!this.constants[tp][changed_proto]) {
+      throw "unknown proto";
+    }
+    return changed_proto;
+  };
+
+  this.stoc_follow = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "STOC");
+    this.stoc_follows[changed_proto] = {
       callback: callback,
       synchronous: synchronous
     };
   };
 
-  this.ctos_follow = function(proto, synchronous, callback) {
-    var key, ref, value;
-    if (typeof proto === 'string') {
-      ref = this.constants.CTOS;
-      for (key in ref) {
-        value = ref[key];
-        if (value === proto) {
-          proto = key;
-          break;
-        }
-      }
-      if (!this.constants.CTOS[proto]) {
-        throw "unknown proto";
-      }
+  this.stoc_follow_before = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "STOC");
+    if (!this.stoc_follows_before[changed_proto]) {
+      this.stoc_follows_before[changed_proto] = [];
     }
-    this.ctos_follows[proto] = {
+    this.stoc_follows_before[changed_proto].push({
+      callback: callback,
+      synchronous: synchronous
+    });
+  };
+
+  this.stoc_follow_after = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "STOC");
+    if (!this.stoc_follows_after[changed_proto]) {
+      this.stoc_follows_after[changed_proto] = [];
+    }
+    this.stoc_follows_after[changed_proto].push({
+      callback: callback,
+      synchronous: synchronous
+    });
+  };
+
+  this.ctos_follow = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "CTOS");
+    this.ctos_follows[changed_proto] = {
       callback: callback,
       synchronous: synchronous
     };
   };
 
+  this.ctos_follow_before = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "CTOS");
+    if (!this.ctos_follows_before[changed_proto]) {
+      this.ctos_follows_before[changed_proto] = [];
+    }
+    this.ctos_follows_before[changed_proto].push({
+      callback: callback,
+      synchronous: synchronous
+    });
+  };
+
+  this.ctos_follow_after = function(proto, synchronous, callback) {
+    var changed_proto;
+    changed_proto = this.replace_proto(proto, "CTOS");
+    if (!this.ctos_follows_after[changed_proto]) {
+      this.ctos_follows_after[changed_proto] = [];
+    }
+    this.ctos_follows_after[changed_proto].push({
+      callback: callback,
+      synchronous: synchronous
+    });
+  };
+
   this.stoc_send = function(socket, proto, info) {
     var buffer, header, key, ref, struct, value;
     if (socket.closed) {