Set winsock = Wscript.CreateObject("MSWINSOCK.Winsock", "winsock_")

[string "Alias: "]:14: unfinished string near '"'

<aliases>
  <alias
   match="testconnect"
   enabled="y"
   send_to="12"
   sequence="100"
  >
  <send>local socket = require("socket")
host = host or "localhost"
port = port or 3000
if arg then
&#9;host = arg[1] or host
&#9;port = arg[2] or port
end
print("Attempting connection to host '" ..host.. "' and port " ..port.. "...")
c = assert(socket.connect(host, port))
print("Connected! Please type stuff (empty line to stop):")
--l = io.read()
l = "this is from MUSHClient test"
while l and l ~= "" and not e do
&#9;assert(c:send(l .. "\n"))
&#9;--l = io.read()
    l = ""
end
</send>
  </alias>
</aliases>

[string "Alias: "]:14: unfinished string near '"'

assert(c:send(l .. "\n"))

assert(c:send(l .. "\\n"))

function HealMeUpScotty(name, line, wildcards, styles)
  -- 'name' holds the name of your trigger/alias/timer, or a
  --     unique id if you did not give it a name.
  -- 'line' holds the plain text that your trigger matched on.
  -- 'wildcards' is an array with all captured groups in your
  --     regular expression.
  -- 'styles' is an array that describes the colours and other
  --     information of your matched text in detail.
  --     (Triggers only.)
  Note("Scotty heals you up!")
end

function helloWorld(arg1)
    if (tonumber(arg1)==1) then
        Note("hello world!")
    elseif (tonumber(arg1)==2) then
        Note("HELLO WORLD!")
    end
end

<aliases>
  <alias
   match="dohello"
   enabled="y"
   send_to="12"
   sequence="100"
  >
  <send>helloWorld(2)</send>
  </alias>
</aliases>

<aliases>
  <alias
   match="!!!"
   enabled="y"
   script="OligoTest"
  >
  </alias>
</aliases>

function OligoTest(name, line, wildcards)
  Note("Oligo tests the living daylights out of this alias.")
end

<aliases>
  <alias
   script="OligoTest"
   match="^blah( [A-Za-z]+)?"
   enabled="y"
   regexp="y"
   send_to="12"
  >
  </alias>
</aliases>

function OligoTest(name, line)--, line, wildcards)
    Note("name: "..name)

    Note("line: "..line)
    --[[
    Note("wildcards: ")
    for i,v in ipairs(wildcards)
    do
        tmp = Trim(v)
        Note(i..": "..tmp)
    end
    --]]
    Note ("in OligoTest")
end

<aliases>
  <alias
   script="testConnect"
   match="testconnect"
   enabled="y"
   send_to="12"
   sequence="100"
  >
  </alias>
</aliases>

function testConnect(name,line,wildscards)
  local socket = require("socket")
  host = "localhost"
  port = 3000
  Note("Attempting connection to host '" ..host.. "' and port " ..port.. "...")

  c = assert(socket.connect(host, port))
  Note("Connected!")
  --l = io.read()
  l = "this is from MUSHClient test";
  assert(c:send(l.."\n"))
  l, e = c:receive()
  while not e do
    Note(l)
    l, e = c:receive()
  end
  Note("end of testConnect()")
end

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using System.Collections;

namespace ClanServer
{
  public class ArcticChar
  {
    public ArcticChar(NetworkStream pArg)
    {
      socketStream = pArg;
    }
    public int currentMV { get; set; }
    public int maxMV { get; set; }
    public int currentHP { get; set; }
    public int maxHP { get; set; }
    public int charClass { get; set; }
    public int charName { get; set; }
    public NetworkStream socketStream { get; set; }
  }

  //http://www.switchonthecode.com/tutorials/csharp-tutorial-simple-threaded-tcp-server
  class ClanServer2
  {
    private TcpListener tcpListener;
    private Thread listenThread;
    private ArrayList clientList;

    public ClanServer2()
    {
      this.tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), 3000);
      this.listenThread = new Thread(new ThreadStart(ListenForClients));
      this.listenThread.Start();
      Console.WriteLine("Awaiting new connections, server started...");
    }

    private void ListenForClients()
    {
      this.tcpListener.Start();
      clientList = new ArrayList();
      while (true)
      {
        //blocks until a client has connected to the server
        TcpClient client = this.tcpListener.AcceptTcpClient();

        //create a thread to handle communication 
        //with connected client
        Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientComm));
        Console.WriteLine("New connection received...");
        clientThread.Start(client);
      }
    }

    private void HandleClientComm(object client)
    {
      TcpClient tcpClient = (TcpClient)client;
      NetworkStream clientStream = tcpClient.GetStream();

      clientList.Add(new ArcticChar(clientStream));

      byte[] message = new byte[4096];
      int bytesRead;
      byte[] outboundMsg = new byte[4096];
      outboundMsg = new ASCIIEncoding().GetBytes("here welcome message from server\r\n");
      int bytesSent = outboundMsg.Length;

      while (true)
      {
        bytesRead = 0;

        try
        {
          //blocks until a client sends a message
          bytesRead = clientStream.Read(message, 0, 4096);
          clientStream.Write(outboundMsg, 0, bytesSent);
          clientStream.Flush();
        }
        catch
        {
          //a socket error has occured
          break;
        }

        if (bytesRead == 0)
        {
          Console.WriteLine("the client has disconnected from the server");
          break;
        }

        //message has successfully been received
        ASCIIEncoding encoder = new ASCIIEncoding();
        //System.Diagnostics.Debug.WriteLine(encoder.GetString(message, 0, bytesRead));
        Console.WriteLine(encoder.GetString(message, 0, bytesRead));
      }

      tcpClient.Close();
    }

    public static int Main(String[] args)
    {
      ClanServer2 server = new ClanServer2();
      return 0;
    }
  }

  
}