public static string[] Tokenize(string line)
{
GameInterface.Cmd_TokenizeString(line);
var argc = GameInterface.Cmd_Argc();
if (argc == 0)
{
return(new string[0]);
}
var tokenized = new string[argc];
for (int i = 0; i < argc; i++)
{
tokenized[i] = GameInterface.Cmd_Argv(i);
}
GameInterface.Cmd_EndTokenizedString();
return(tokenized);
}
public static bool HandleServerCommand(string commandName)
{
string[] args = new string[GameInterface.Cmd_Argc()];
for (int i = 0; i < args.Length; i++)
{
args[i] = GameInterface.Cmd_Argv(i);
}
bool eat = false;
ScriptProcessor.RunAll(script =>
{
eat = script.OnServerCommand(commandName.ToLowerInvariant(), args);
});
return(eat);
}
public static void HandleCall(int entityRef, CallType funcID)
{
var entity = Entity.GetEntity(entityRef);
int numArgs = GameInterface.Notify_NumArgs();
var paras = CollectParameters(numArgs);
switch (funcID)
{
case CallType.StartGameType:
ScriptProcessor.RunAll(script => script.OnStartGameType());
break;
case CallType.PlayerConnect:
//ScriptProcessor.RunAll(script => script.OnPlayerConnect(entity));
break;
case CallType.PlayerDisconnect:
ScriptProcessor.RunAll(script => script.OnPlayerDisconnect(entity));
break;
case CallType.PlayerDamage:
if (paras[6].IsNull)
{
paras[6] = new Vector3(0, 0, 0);
}
if (paras[7].IsNull)
{
paras[7] = new Vector3(0, 0, 0);
}
ScriptProcessor.RunAll(script => script.OnPlayerDamage(entity, paras[0].As <Entity>(), paras[1].As <Entity>(), paras[2].As <int>(), paras[3].As <int>(), paras[4].As <string>(), paras[5].As <string>(), paras[6].As <Vector3>(), paras[7].As <Vector3>(), paras[8].As <string>()));
break;
case CallType.PlayerKilled:
if (paras[5].IsNull)
{
paras[5] = new Vector3(0, 0, 0);
}
ScriptProcessor.RunAll(script => script.OnPlayerKilled(entity, paras[0].As <Entity>(), paras[1].As <Entity>(), paras[2].As <int>(), paras[3].As <string>(), paras[4].As <string>(), paras[5].As <Vector3>(), paras[6].As <string>()));
break;
}
}
public WebHome()
: base()
{
Get["/"] = parameters =>
{
// fetch stat points
var oneDayAgo = DateTime.UtcNow - new TimeSpan(24, 0, 0);
var statPoints = WebBaseScript.Database.Table <PlayerCountStatisticPoint>().Where(p => p.Time >= oneDayAgo);
return(View["Index", new
{
StatPoints = statPoints,
MapName = GameInterface.GetDvar("mapname", ""),
GameType = GameInterface.GetDvar("g_gametype", "dm"),
PlayerLimit = GameInterface.GetDvar("sv_maxclients", "0"),
PlayerCount = WebBaseScript.NumPlayers
}]);
};
}
public static bool HandleClientCommand(string commandName, int entity)
{
string[] args = new string[GameInterface.Cmd_Argc_sv()];
for (int i = 0; i < args.Length; i++)
{
args[i] = GameInterface.Cmd_Argv_sv(i);
}
Entity entObj = Entity.GetEntity(entity);
bool handled = false;
ScriptProcessor.RunAll(script =>
{
handled = script.OnClientCommand(entObj, commandName.ToLowerInvariant(), args);
});
return(handled);
}
private static Parameter[] CollectParameters(int numArgs)
{
var paras = new Parameter[numArgs];
for (int i = 0; i < numArgs; i++)
{
var ptype = GameInterface.Script_GetType(i);
object value = null;
switch (ptype)
{
case VariableType.Integer:
value = GameInterface.Script_GetInt(i);
break;
case VariableType.String:
value = Marshal.PtrToStringAnsi(GameInterface.Script_GetString(i));
break;
case VariableType.Float:
value = GameInterface.Script_GetFloat(i);
break;
case VariableType.Entity:
value = Entity.GetEntity(GameInterface.Script_GetEntRef(i));
break;
case VariableType.Vector:
Vector3 v;
GameInterface.Script_GetVector(i, out v);
value = v;
break;
default:
break;
}
paras[i] = new Parameter(ptype, value);
}
return(paras);
}
public static bool HandleServerCommand(string commandName)
{
var args = new string[GameInterface.Cmd_Argc()];
for (var i = 0; i < args.Length; i++)
{
args[i] = GameInterface.Cmd_Argv(i);
}
var eat = false;
ScriptProcessor.RunAll(script =>
{
var success = script.ProcessServerCommand(commandName.ToLowerInvariant(), args);
if (success)
{
eat = true;
}
});
return(eat);
}
public T GetField <T>(string name)
{
name = name.ToLowerInvariant();
if (!_fieldNames.ContainsKey(name))
{
return((T)_privateFields[name]);
}
object returnValue = null;
int fieldID = _fieldNames[name];
GameInterface.Script_GetField(_entRef, fieldID);
switch (GameInterface.Script_GetType(0))
{
case VariableType.Integer:
returnValue = GameInterface.Script_GetInt(0);
break;
case VariableType.Float:
returnValue = GameInterface.Script_GetFloat(0);
break;
case VariableType.String:
returnValue = GameInterface.Script_GetString(0);
break;
case VariableType.Vector:
Vector3 outValue;
GameInterface.Script_GetVector(0, out outValue);
returnValue = outValue;
break;
}
GameInterface.Script_CleanReturnStack();
return((T)Convert.ChangeType(returnValue, typeof(T)));
}
public static void HandleNotify(int entity)
{
string type = Marshal.PtrToStringAnsi(GameInterface.Notify_Type());
int numArgs = GameInterface.Notify_NumArgs();
var paras = CollectParameters(numArgs);
if (type != "touch")
{
// dispatch the thingy
if (GameInterface.Script_GetObjectType(entity) == 21) // actual entity
{
var entRef = GameInterface.Script_ToEntRef(entity);
var entObj = Entity.GetEntity(entRef);
//Log.Write(LogLevel.Trace, "{0} on object {1}, entRef {2} (entity object {3})", type, entity, entRef, entObj);
entObj.HandleNotify(entity, type, paras);
}
ScriptProcessor.RunAll(script => script.HandleNotify(entity, type, paras));
}
}
public static bool HandleClientCommand(string commandName, int entity)
{
var args = new string[GameInterface.Cmd_Argc_sv()];
for (var i = 0; i < args.Length; i++)
{
args[i] = GameInterface.Cmd_Argv_sv(i);
}
var entObj = Entity.GetEntity(entity);
var handled = false;
ScriptProcessor.RunAll(script =>
{
var success = script.ProcessClientCommand(commandName.ToLowerInvariant(), entObj, args);
if (success)
{
handled = true;
}
});
return(handled);
}
public static void RotateMap()
{
try
{
if (CurrentPlaylist.Count == 0)
{
BuildPlaylist(GameInterface.GetDvar("mapname", ""));
if (CurrentPlaylist.Count == 0)
{
Utilities.ExecuteCommand("map_restart");
return;
}
}
var nextEntry = CurrentPlaylist[0];
CurrentPlaylist.RemoveAt(0);
GameType = nextEntry.GameType;
ApplyVariables(Rules);
ApplyVariables(Values);
ApplyVariables(nextEntry.GameType.Rules);
ApplyVariables(nextEntry.GameType.Values);
ApplyVariables(Playlist.Rules);
ApplyVariables(Playlist.Values);
Utilities.ExecuteCommand("ui_gametype {0}; g_gametype {1}; map {2}; ", nextEntry.GameType.Script, nextEntry.GameType.Script, nextEntry.Map);
}
catch (Exception ex)
{
Log.Error("Error during map rotation: " + ex.ToString());
Utilities.ExecuteCommand("map_restart");
}
}
public static bool HandleClientConnect(string connectString)
{
bool eat = false;
try
{
string playerName = connectString.Split(new[] { "name" }, StringSplitOptions.None)[1];
string playerHWID = connectString.Split(new[] { "HWID" }, StringSplitOptions.None)[1];
string playerXUID = connectString.Split(new[] { "XUID" }, StringSplitOptions.None)[1];
string playerIP = connectString.Split(new[] { "IP-string" }, StringSplitOptions.None)[1];
string playerSID = connectString.Split(new[] { "steamid" }, StringSplitOptions.None)[1];
string playerXNA = connectString.Split(new[] { "xnaddr" }, StringSplitOptions.None)[1];
ScriptProcessor.RunAll(script =>
{
string error = script.OnPlayerRequestConnection(playerName, playerHWID, playerXUID, playerIP, playerSID, playerXNA);
if (string.IsNullOrEmpty(error))
{
return;
}
eat = true;
GameInterface.SetConnectErrorMsg(error);
});
return(eat);
}
catch (Exception ex)
{
Utilities.PrintToConsole($"[InfinityScript] An error occurred during the handling of a client connecting!: {ex.Message}\nAdditional Info:{ex.Data}");
return(false);
}
}
public static void RawSayTo(int entref, string message)
{
GameInterface.SV_GameSendServerCommand(entref, -1, message);
}
public static byte[] HandleWebRequest(string method, string uri, string query, int numHeaders, int remoteIP)
{
var headers = new Dictionary <string, string>();
for (int i = 0; i < numHeaders; i++)
{
var header = GameInterface.GetHTTPHeader(i);
var headerParts = header.Split(new[] { ": " }, 2, StringSplitOptions.None);
if (headerParts.Length < 2)
{
continue;
}
headers[headerParts[0]] = headerParts[1];
}
try
{
return(WebManager.HandleRequest(method, uri.Split('?')[0], query, headers, new IPAddress(BitConverter.GetBytes(IPAddress.NetworkToHostOrder(remoteIP)))));
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
Log.Error(ex.InnerException);
}
Log.Error(ex);
return(Encoding.UTF8.GetBytes("HTTP/1.0 500 Internal Server Error\r\n\r\n" + ex.Message));
}
/*var requestData = new Dictionary<string, object>();
* requestData["owin.RequestBody"] = Stream.Null;
* requestData["owin.RequestHeaders"] = headers;
* requestData["owin.RequestMethod"] = method;
* requestData["owin.RequestPath"] = uri.Substring(1).Split('?')[0];
* requestData["owin.RequestPathBase"] = "/";
* requestData["owin.RequestProtocol"] = "HTTP/1.0";
* requestData["owin.RequestQueryString"] = query;
* requestData["owin.RequestScheme"] = "http";
*
* requestData["owin.Version"] = "1.0";
* requestData["owin.CallCancelled"] = new System.Threading.CancellationToken();
*
* WebManager.HandleRequest(requestData);
*
* try
* {
* foreach (var data in requestData)
* {
* Log.Debug(data.Key + ": " + data.Value.ToString());
* }
*
* var responseStream = requestData["owin.ResponseBody"] as Stream;
* var responseHeaders = requestData["owin.ResponseHeaders"] as IDictionary<string, string[]>;
* var responseStatusCode = requestData.ContainsKey("owin.ResponseStatusCode") ? (int)requestData["owin.ResponseStatusCode"] : 200;
*
* var response = new StringBuilder();
* response.Append("HTTP/1.0 ");
* response.Append(responseStatusCode.ToString());
* response.Append(" ");
* response.Append(_statusCodes[responseStatusCode]);
* response.Append("\r\n");
*
* foreach (var header in responseHeaders)
* {
* response.Append(header.Key);
* response.Append(": ");
* response.Append(string.Join(", ", header.Value));
* response.Append("\r\n");
* }
*
* response.Append("\r\n");
*
* var headerBytes = Encoding.UTF8.GetBytes(response.ToString());
* var dataBytes = new byte[responseStream.Length + headerBytes.Length];
* Array.Copy(headerBytes, dataBytes, headerBytes.Length);
*
* responseStream.Read(dataBytes, headerBytes.Length, (int)responseStream.Length);
*
* return dataBytes;
* }
* catch (Exception ex)
* {
* Log.Error(ex);
* return Encoding.UTF8.GetBytes("HTTP/1.0 500 Internal Server Error\r\n\r\n" + ex.Message);
* }*/
}
public static void ExecuteCommand(string command)
{
GameInterface.Cbuf_AddText(command + "\n");
}
public static void RawSayAll(string message)
{
GameInterface.SV_GameSendServerCommand(-1, -1, message);
}
public static void SetDropItemEnabled(bool enabled)
{
GameInterface.SetDropItemEnabled(enabled);
}
private static void BuildPlaylist(string currentMap = "")
{
// generate a list containing unique maps, with entries the number of times as the weight indicates
var list = new List <PlaylistEntry>();
var mapsDone = new HashSet <string>();
var rnd = new Random();
var curPlaylistId = int.Parse(GameInterface.GetDvar("playlist", "0"));
if (curPlaylistId < 0 || curPlaylistId > PlaylistSet.Playlists.Length)
{
Log.Debug("curPlaylistId seems invalid.");
return;
}
var curPlaylist = PlaylistSet.Playlists[curPlaylistId];
if (curPlaylist == null)
{
Log.Debug("curPlaylistId seems null.");
return;
}
Playlist = curPlaylist;
var newEntries = from e in curPlaylist.Entries
orderby rnd.Next()
select e;
foreach (var entry in newEntries)
{
if (!mapsDone.Contains(entry.Map))
{
list.Add(entry);
mapsDone.Add(entry.Map);
}
}
// duplicate the entries with a >1 weight
var duplicateList = list.GetRange(0, list.Count);
foreach (var entry in duplicateList)
{
if (entry.Weight > 1)
{
for (int i = 1; i < entry.Weight; i++)
{
list.Add(entry);
}
}
}
// shuffle the list, again
list = (from e in list
orderby rnd.Next()
select e).ToList();
// remove current map from start of list, so we won't rotate to the same map
if (list.Count > 0 && list[0].Map == currentMap)
{
list.RemoveAt(0);
}
CurrentPlaylist = list;
}
public void LogMessage(string source, string message, LogLevel level)
{
GameInterface.Print("[" + source + "] " + message + "\n");
}
static WebBaseScript()
{
Database = new SQLiteConnection("zone/" + GameInterface.GetDvar("sv_baseConfigName", "dummy") + ".iw4db", true);
Database.CreateTable <PlayerCountStatisticPoint>();
}
public static byte[] HandleRequest(string method, string uri, string query, Dictionary <string, string> headers, IPAddress ip)
{
var nuri = new Url
{
Scheme = "http",
HostName = GetHeader(headers, "Host"),
Port = null,
BasePath = "",
Path = uri,
Query = query
};
var contentLength = ExpectedLength(headers);
var bodyStream = Stream.Null;
if (contentLength > 0)
{
var bodyBytes = GameInterface.ReadHTTPBody((int)contentLength);
bodyStream = new MemoryStream(bodyBytes);
}
var body = new RequestStream(bodyStream, contentLength, false);
var headerDictionary = headers.ToDictionary(kv => kv.Key, kv => (IEnumerable <string>) new[] { kv.Value }, StringComparer.OrdinalIgnoreCase);
var request = new Request(method, nuri, body, headerDictionary, ip.ToString());
var context = _engine.HandleRequest(request);
var responseStatusCode = context.Response.StatusCode;
var responseStream = new MemoryStream();
context.Response.Contents(responseStream);
responseStream.Position = 0;
var response = new StringBuilder();
response.Append("HTTP/1.0 ");
response.Append(((int)responseStatusCode).ToString());
response.Append(" ");
response.Append(_statusCodes[(int)responseStatusCode]);
response.Append("\r\n");
foreach (var header in context.Response.Headers)
{
response.Append(header.Key);
response.Append(": ");
response.Append(string.Join(", ", header.Value));
response.Append("\r\n");
}
if (context.Response.ContentType != null)
{
response.Append("Content-Type: ");
response.Append(context.Response.ContentType);
response.Append("\r\n");
}
if (context.Response.Cookies != null && context.Response.Cookies.Count != 0)
{
var cookies = context.Response.Cookies.Select(cookie => cookie.ToString()).ToArray();
response.Append("Set-Cookie: ");
response.Append(string.Join(", ", cookies));
response.Append("\r\n");
}
response.Append("\r\n");
var headerBytes = Encoding.UTF8.GetBytes(response.ToString());
var dataBytes = new byte[responseStream.Length + headerBytes.Length];
Array.Copy(headerBytes, dataBytes, headerBytes.Length);
responseStream.Read(dataBytes, headerBytes.Length, (int)responseStream.Length);
//Log.Debug(context.Trace.TraceLog.ToString());
context.Dispose();
return(dataBytes);
}
