Jupiter-Bot/Config.ini

; Example Configuration File
; The configuration file should be named: Config.ini
; Eventually, the configuration file format itself will be an option.
;
; Definitions:
; A String is a series of characters (Text)
; An Integer is a whole number.
; A Bool is either true or false.
; A Float is a decimal number.
;
; [Config]
; This block is used to define settings that are global in nature.
; Currently, there is a "Servers" option to specify what sections
; to look at for server configuration options, and a "Plugins"
; option that specifies which plugins to load from the Plugins
; folder.
; DO NOT INCLUDE A PLUGIN'S FILE EXTENSION (.dll or .so).
;
; Required Settings:
; Servers=String (Format: Server1 Server2)
;
; Optional Settings:
; Plugins=String (Format: Plugin1 Plugin2)
; PluginsDirectory=String (Default: Plugins\)
;

[Config]
Servers=CnCIRC
Plugins=CoreCommands PluginManager ExtraCommands RenX.Core RenX.Commands RenX.Logging RenX.Medals RenX.SetJoin

; [Default]
;
; This block is referenced only when a setting is not
; specified in a server's block. If a value is located
; neither in the server's block nor this one, then a
; crash or other unexpected behavior may occur. It is
; therefore recommended to have some sort of default
; value for all possible settings.
;
; Channel Configuring:
; Channels are given "types", which can determine various things such
; as auto-parting. A Channel of type -1 will automatically part itself.
; Channels can be configured in two ways: Active and Passive.
; Active channels are joined automatically. Passive channels are not,
; but can still be configured.
;
; Active Channels:
; Channel.Integer=String (Format: #Example [Password])
; Channel.Integer.Type=Integer (-1 is auto-part)
;
; Passive Channels:
; Channel.String.Type=Integer
;
; Client address and port:
; The client address and port settings are entirely optional. These are
; only used under very special circumstances, and should otherwise
; not be specified. Unless you have a valid reason to need to bind the
; client to a specific address/port (such as connection limiations on a
; per-IP basis), do not set these.
;
; Settings:
; Hostname=String ("irc.cncirc.net" if unspecified)
; Port=Positive Integer (194 or 994 if unspecified)
; SSL=Bool
; STARTTLS=Bool (True if unspecified)
; Certificate=String (No SSL certificate used if unspecified)
; Key=String (Certificate file used if unspecified)
; SASL.Password=String (SASL disabled if unspecified)
; SASL.Account=String (Nickname if unspecified)
; Nick=String ("Jupiter" if unspecified)
; AltNick=String
; RealName=String ("Jupiter IRC Client" if unspecified)
; Channel.Type=Integer
; RawData.Integer=String (Example: OPER UserName Password)
; LogFile=String
; AutoJoinOnKick=Bool
; AutoPartMessage=String
; AutoReconnectDelay=Integer (Measured in seconds)
; MaxReconnectAttempts=Integer
; PrintOutput=Bool
; Prefix=String
; ClientAddress=String (Unused if unspecified)
; ClientPort=Integer (Unused if above is unspecified; defaults to 0)
;

[Default]
Port=6667
Nick=Jupiter
AltNick=Jupiter`
RealName=Jupiter IRC Framework by Agent
AutoPartMessage=Auto-Parting Enabled
AutoReconnect=1
MaxReconnectAttempts=3
AutoReconnectDelay=5
PrintOutput=1
Channel.Type=-1
Prefix=!

; [(ServerName)]
;
; Anything which can be set within the Default block can
; also be applied here. Values here supercede any value
; which is set within the Default block.
;

[CnCIRC]
; CnCIRC includes the Renegade X IRC server. :)
Hostname=irc.cncirc.net
Nick=RenXBot
AltNick=RXBot`
Channel.1=#RenX-IRC
Channel.1.Type=1
Channel.2=#RenX-IRC.Admin
Channel.2.Type=2
SASL.Password=your_NickServ_Password
LogFile=CnCIRC.txt

[CT]
Hostname=irc.ConstructiveTyranny.com
Nick=RenXBot
Channel.1=#RenX-IRC
Channel.1.Type=1
RawData.1=PRIVMSG NickServ :IDENTIFY your_NickServ_Password
LogFile=CT.txt

[EKT]
Hostname=irc.EliteKamikazeTeam.com
Nick=RenXBot
Channel.1=#RenX-IRC
Channel.1.Type=1
RawData.1=PRIVMSG NickServ :IDENTIFY your_NickServ_Password
LogFile=EKT.txt

[St0rm]
Hostname=irc.st0rm.net
Nick=RenXBot
AltNick=RXBot`
Channel.1=#RenX-IRC
Channel.1.Type=1
RawData.1=PRIVMSG NickServ :IDENTIFY your_NickServ_Password
LogFile=St0rm.txt

; [DefaultCommands]
; You can modify the access requirements for any command here.
; Values set here will be set across all servers that do not have
; server-specific values set.
;
; To disable a command, set its access requirement to -1.
;
; Syntax: CommandTrigger=AccessLevel
;

[DefaultCommands]
msg=1

; [(ServerName)Commands]
; You can modify the access requirements for any command here, on a
; per-server basis. Values specified here supercede those which are set
; in the DefaultCommands block.
;

[CnCIRCCommands]
msg=0

; ***************************************
; Module Configurations
; ***************************************

; [RenX]
;
; Define servers for the RenX module to connect to here.
; The "Servers" setting here operates similarly to the "Servers" setting
; in the [Config] section. Specify a space-deliminated list here to point
; to configuration sections for each individual Renegade-X server.
;
; Settings:
; Servers=String (Format: Server1 Server2)
; TranslationsFile=String (Default: Translations.ini)
; CommandsFile=String (Default: RenXGameCommands.ini)
; TagDefinitions=String (Default: RenX.Tags)
;

[RenX]
Servers=RenX-Server1 RenX-Server2
; !!!!! READ THIS !!!!!
; MAKE SURE TO SCROLL DOWN AND CHECK OUT THE SETTINGS
; FOR THE ANTI-CHEAT. THE SETTINGS FOR THE ANTI-CHEAT
; ARE UNDER [RenX.ExcessiveHeadshots].
; !!!!! READ THIS !!!!!!

; Here is where you define each individual Renegade-X server!
; Server types are tied to channel types, such that servers will
; report only to a specific channel type, and commands executed
; in a channel will only affect servers with the same type as that
; channel. If left unspecified the type will be 0, which is the same
; as the default channel type.
;
; AdminChanType defines the type for administrator channels.
; This channel will include more verbose output, such as player IP
; addresses, Steam IDs, and events unaccounted for.
;
; Settings:
; Hostname=String (Default: Localhost)
; Port=Integer (Default: 7777)
; ClientAddress=String (Unused if unspecified)
; Password=String (Default: renx)
; ChanType=Integer (Default: 0)
; AdminChanType=Integer (Default: 0)
; CommandPrefix=String (Empty if unspecified)
; IRCPrefix=String (Unused if unspecified)
; Rules=String (Default: Anarchy!)
; ReconnectDelay=Integer (Default: 60; seconds between reconnect attempts)
; MaxReconnectAttempts=Integer (Default: -1; A negative value means no limit)
; UUIDMode=Integer (Default: 0; Steam=0, Nickname=1)
; RCONBan=Bool (Default: true)
; LocalIPBan=Bool (Default: true)
; LocalSteamBan=Bool (Default: true)
; LocalNameBan=Bool (Default: false)
; SteamFormat=Integer (Default: 16; Hex=16, Integer=10, Octal=8)
; NeverSay=Bool (Forces the bot to PM players instead of using "say"; Default: false)
;

[RenX-Server1]
Hostname=Localhost
Port=7777
Password=renx
ChanType=1
AdminChanType=2
CommandPrefix=!
Rules=Hacking, cheating, or exploitation of any form is strictly prohibited. Please respect all players.

[RenX-Server2]
Hostname=Localhost
Port=7778
Password=renx
ChanType=3
AdminChanType=2
CommandPrefix=!
IRCPrefix=07[Marathon]

; [RenX.Tags]
;
; ***** Global Tags *****
; DateTag=String (Default: {DATE})
; TimeTag=String (Default: {TIME})
;
; ***** Server Tags *****
; RCONVersionTag=String (Default: {RVER})
; GameVersionTag=String (Default: {GVER})
; XRCONVersionTag=String (Default: {XVER})
; RulesTag=String (Default: {RULES})
;
; ***** Player Tags ******
; NameTag=String (Default: {NAME})
; RawNameTag=String (Default: {RNAME})
; IPTag=String (Default: {IP})
; SteamTag=String (Default: {STEAM})
; UUIDTag=String (Default: {UUID})
; IDTag=String (Default: {ID})
; AdminTag=String (Default: {ADMIN})
; TeamColorTag=String (Default: {TCOLOR})
; ShortTeamTag=String (Default: {TEAMS})
; LongTeamTag=String (Default: {TEAML})
; PingTag=String (Default: {PING})
; ScoreTag=String (Default: {SCORE})
; CreditsTag=String (Default: {CREDITS})
; KillsTag=String (Default: {KILLS})
; DeathsTag=String (Default: {DEATHS})
; KDRTag=String (Default: {KDR})
; SuicidesTag=String (Default: {SUICIDES})
; HeadshotsTag=String (Default: {HEADSHOTS})
; VehicleKillsTag=String (Default: {VEHICLEKILLS})
; BuildingKillsTag=String (Default: {BUILDINGKILLS})
; DefenceKillsTag=String (Default: {DEFENCEKILLS})
; WinsTag=String (Default: {WINS})
; LosesTag=String (Default: {LOSES})
; BeaconPlacementsTag=String (Default: {BEACONPLACEMENTS})
; AccessTag=String (Default: {ACCESS})
;
; ***** Victim Tags *****
; VictimNameTag=String (Default: {VNAME})
; VictimIPTag=String (Default: {VRNAME})
; VictimSteamTag=String (Default: {VSTEAM})
; VictimUUIDTag=String (Default: {VUUID})
; VictimIDTag=String (Default: {VID})
; VictimAdminTag=String (Default: {VADMIN})
; VictimTeamColorTag=String (Default: {VTCOLOR})
; VictimShortTeamTag=String (Default: {VTEAMS})
; VictimLongTeamTag=String (Default: {VTEAML})
; VictimPingTag=String (Default: {VPING})
; VictimScoreTag=String (Default: {VSCORE})
; VictimCreditsTag=String (Default: {VCREDITS})
; VictimKillsTag=String (Default: {VKILLS})
; VictimDeathsTag=String (Default: {VDEATHS})
; VictimKDRTag=String (Default: {VKDR})
; VictimSuicidesTag=String (Default: {VSUICIDES})
; VictimHeadshotsTag=String (Default: {VHEADSHOTS})
; VictimVehicleKillsTag=String (Default: {VVEHICLEKILLS})
; VictimBuildingKillsTag=String (Default: {VBUILDINGKILLS})
; VictimDefenceKillsTag=String (Default: {VDEFENCEKILLS})
; VictimWinsTag=String (Default: {VWINS})
; VictimLosesTag=String (Default: {VLOSES})
; VictimBeaconPlacementsTag=String (Default: {VBEACONPLACEMENTS})
; VictimAccessTag=String (Default: {VACCESS})
;
; ***** Other Tags *****
; WeaponTag=String (Default: {WEAPON})
; ObjectTag=String (Default: {OBJECT})
; MessageTag=String (Default: {MESSAGE})
; NewNameTag=String (Default: {NNAME}; used exclusively for NameChangeFormat)
; WinScoreTag=String (Default: {WINSCORE}; used exclusively for GameOver formats)
; LoseScoreTag=String (Default: {LOSESCORE}; used exclusively for GameOver formats)
;

[RenX.Tags]

; [RenX.Commands]
; TBanTime=Integer (Default: 86400; Time in seconds)
; PlayerInfoFormat=String (Default: 03[Player Info]{TCOLOR} Name: {RNAME} - ID: {ID} - Team: {TEAML} - Vehicle Kills: {VEHICLEKILLS} - Building Kills {BUILDINGKILLS} - Kills {KILLS} - Deaths: {DEATHS} - KDR: {KDR} - Access: {ACCESS}")
; AdminPlayerInfoFormat=String (Default: PlayerInfoFormat - IP: {IP} - Steam ID: {STEAM})
;

[RenX.Commands]
TBanTime=86400

; [RenX.ModSystem]
; ModsFile=String (Default: Mods.ini)
;

[RenX.ModSystem]
ModsFile=Mods.ini

; [RenX.ExcessiveHeadshots]
; This is a completely optional statistic-based anti-cheat.
; The average aimbotter with rate-of-fire hacks will generally manage
; a headshot-kill ratio of about .66.
;
; These settings are all entirely optional; if they're not specified,
; then they will still default to the values listed below.
;
; HOW IT WORKS:
; Each setting is used for matching conditions in a flag-testing process.
; When the proper number of flags have been thrown, the player will
; be immediately banned from the server. To set the number of flags,
; set the "Flags" setting.
;
; Settings:
; HeadshotKillRatio=Float (Headshots/Kills)
; Kills=Integer (How many kills before a flag is set)
; KillDeathRatio=Float (Kills / Deaths)
; KillsPerSecond=Float (Kills / Player game time in seconds)
; MaxGameTime=Integer (Seconds after joining before dropping flag)
; Flags=Integer (Must be AT LEAST 2)
;
; Example scenario using default settings:
; A player joins your server. Within 2 minutes, they've racked 10 kills.
; Since they've been in-game for less than 180 seconds, they have 1
; flag against them. Since they've reached 10 kills, they have another
; flag against them. Since they've obtained 10 kills in 120 seconds, their
; KPS is 0.08, which does not set off a flag. They now have 3 flags. If
; they get one more flag on this kill, they will be banned. The final flag
; in this scenario is the headshot-kill ratio. If half of their kills are from
; headshots, the final flag is set, and they're banned. If it's below half,
; they get to stay and enjoy the game.
;

[RenX.ExcessiveHeadshots]
HeadshotKillRatio=0.5
Kills=10
KillDeathRatio=5.0
KillsPerSecond=0.1
MaxGameTime=180
Flags=4

; [RenX.Logging]
;
; This plugin logs game events to IRC public and administrative channels.
; To prevent an event from logging to public channels, set the below
; corresponding setting to "false". Some events are set to "false" by default.
;
; To disable an event completely, set its logging format to an empty string.
; For an example, refer to the default CommandFormat value.
;
; Settings:
; JoinPublic=Bool (Default: true)
; PartPublic=Bool (Default: true)
; NameChangePublic=Bool (Default: true)
; TeamChangePublic=Bool (Default: true)
; PlayerPublic=Bool (Default: false)
; ChatPublic=Bool (Default: true)
; TeamChatPublic=Bool (Default: true)
; HostChatPublic=Bool (Default: true)
; HostPagePublic=Bool (Default: false)
; OtherPublic=Bool (Default: false)
; DeployPublic=Bool (Default: true)
; MineDeployPublic=Bool (Default: false)
; DisarmPublic=Bool (Default: true)
; MineDisarmPublic=Bool (Default: false)
; ExplodePublic=Bool (Default: false)
; SuicidePublic=Bool (Default: true)
; KillPublic=Bool (Default: true)
; DiePublic=Bool (Default: true)
; DestroyPublic=Bool (Default: true)
; CapturePublic=Bool (Default: true)
; NeutralizePublic=Bool (Default: true)
; CharacterPurchasePublic=Bool (Default: false)
; ItemPurchasePublic=Bool (Default: false)
; WeaponPurchasePublic=Bool (Default: false)
; RefillPurchasePublic=Bool (Default: false)
; VehiclePurchasePublic=Bool (Default: false)
; VehicleSpawnPublic=Bool (Default: true)
; SpawnPublic=Bool (Default: true)
; BotJoinPublic=Bool (Default: true)
; VehicleCratePublic=Bool (Default: false)
; DeathCratePublic=Bool (Default: false)
; MoneyCratePublic=Bool (Default: false)
; CharacterCratePublic=Bool (Default: false)
; SpyCratePublic=Bool (Default: false)
; RefillCratePublic=Bool (Default: false)
; StealPublic=Bool (Default: true)
; DonatePublic=Bool (Default: true)
; GamePublic=Bool (Default: true)
; GameOverPublic=Bool (Default: true)
; ExecutePublic=Bool (Default: false)
; SubscribePublic=Bool (Default: false)
; RCONPublic=Bool (Default: false)
; AdminLoginPublic=Bool (Default: true)
; AdminGrantPublic=Bool (Default: true)
; AdminLogoutPublic=Bool (Default: true)
; AdminPublic=Bool (Default: false)
; VoteCallPublic=Bool (Default: true)
; VoteOverPublic=Bool (Default: true)
; VoteCancelPublic=Bool (Default: true)
; VotePublic=Bool (Default: false)
; MapChangePublic=Bool (Default: true)
; MapLoadPublic=Bool (Default: true)
; MapPublic=Bool (Default: false)
; DemoRecordPublic=Bool (Default: true)
; DemoRecordStopPublic=Bool (Default: true)
; DemoPublic=Bool (Default: false)
; LogPublic=Bool (Default: false)
; CommandPublic=Bool (Default: false)
; ErrorPublic=Bool (Default: false)
; VersionPublic=Bool (Default: true)
; AuthorizedPublic=Bool (Default: true)
; OtherPublic=Bool (Default: false)
;
; ***** Formats *****
; JoinPublicFormat=String (Default: 12[Join] {NAME} joined the game fighting for the {TEAML}!)
; JoinAdminFormat=String (Default: 12[Join] {NAME} joined the game fighting for the {TEAML} from {IP} using Steam ID {STEAM}.)
; JoinNoSteamAdminFormat=String (Default: 12[Join] {NAME} joined the game fighting for the {TEAML} from {IP}, but is not using Steam.)
; PartFormat=String (Default: 12[Part] {NAME} has left the {TEAML}.)
; PlayerExecuteFormat=String (Default: {NAME}07 executed: {MESSAGE})
; PlayerFormat=String (Default: 12[Player] {MESSAGE})
; NameChangeFormat=String (Default: {NAME} has changed their name to {NNAME}.)
; TeamChangeFormat=String (Default: {NAME} switched teams!)
; ChatFormat=String (Default: {NAME}: {MESSAGE})
; TeamChatFormat=String (Default: {NAME}: {MESSAGE})
; HostChatFormat=String (Default: 12Host0: {MESSAGE})
; HostPageFormat=String (Default: 12(Host -> {RNAME}): {MESSAGE})
; OtherChatFormat=String (Default: 06[Other Chat] {MESSAGE})
; DeployFormat=String (Default: {NAME} deployed a {OBJECT})
; MineDeplyFormat=String (Default: DeployFormat)
; DisarmFormat=String (Default: {NAME} disarmed {VNAME}'s {OBJECT})
; MineDisarmFormat=String (Default: DisarmFormat)
; DisarmNoOwnerFormat=String (Default: {NAME} disarmed a {OBJECT})
; MineDisarmNoOwnerFormat=String (Default: DisarmNoOwnerFormat)
; SuicideFormat=String (Default: {NAME} suicided (death by 12{WEAPON}).)
; KillFormat=String (Default: {NAME} killed {VNAME} ({TCOLOR}{CHAR}/{WEAPON} vs {VTCOLOR}{VCHAR}).)
; KillFormat2=String (Default: {TCOLOR}{NAME} killed {VNAME} (12{WEAPON}).)
; DieFormat=String (Default: {NAME} died (12{WEAPON}).)
; DieFormat2=String (Default: {TCOLOR}{NAME} died (12{WEAPON}).)
; DestroyBuildingFormat=String (Default: {NAME} destroyed the {VTCOLOR}{OBJECT} (12{WEAPON}).)
; DestroyBuildingFormat2=String (Default: {TCOLOR}{NAME} destroyed the {VTCOLOR}{OBJECT} (12{WEAPON}).)
; DestroyDefenceFormat=String (Default: {NAME} destroyed a {VTCOLOR}{OBJECT} (12{WEAPON}).)
; DestroyDefenceFormat2=String (Default: {TCOLOR}{NAME} destroyed a {VTCOLOR}{OBJECT} (12{WEAPON}).)
; DestroyVehicleFormat=String (Default: {NAME} destroyed a {VTCOLOR}{OBJECT} (12{WEAPON}).)
; DestroyVehicleFormat2=String (Default: {TCOLOR}{NAME} destroyed a {VTCOLOR}{OBJECT} (12{WEAPON}).)
; CaptureFormat=String(Default: {NAME} captured the {VTCOLOR}{VNAME}.)
; NeutralizeFormat=String(Default: {NAME} neutralized the {VTCOLOR}{VNAME}.)
; CharacterPurchaseFormat=String(Default: {NAME} purchased a {TCOLOR}{VCHAR}.)
; ItemPurchaseFormat=String(Default: {NAME} purchased a {TCOLOR}{OBJECT}.)
; WeaponPurchaseFormat=String(Default: {NAME} purchased a {TCOLOR}{WEAPON}.)
; RefillPurchaseFormat=String(Default: {NAME} purchased a {TCOLOR}refill.)
; VehiclePurchaseFormat=String(Default: {NAME} purchased a {TCOLOR}{VVEH}.)
; VehicleSpawnFormat=String(Default: A {TCOLOR}{VEH} has spawned.)
; SpawnFormat=String(Default: {NAME} spawned as a {TCOLOR}{VCHAR}.)
; BotJoinFormat=String(Default: {NAME} online.)
; VehicleCrateFormat=String(Default: {NAME} picked up a {VVEH} vehicle crate.)
; DeathCrateFormat=String(Default: {NAME} picked up a 12death crate.)
; MoneyCrateFormat=String(Default: {NAME} picked up 09{OBJECT} credits from a 12money crate.)
; CharacterCrateFormat=String(Default: {NAME} picked up a {TCOLOR}{VCHAR} 12character crate.)
; SpyCrateFormat=String(Default: {NAME} picked up a {TCOLOR}{VCHAR} 12spy crate.)
; RefillCrateFormat=String(Default: {NAME} picked up a {TCOLOR}refill crate.)
; StealFormat=String(Default: {NAME} stole {VNAME}'s {OBJECT}!)
; StealNoOwnerFormat=String(Default: {NAME} stole a 12{OBJET}!)
; DonateFormat=String(Default: {NAME} donated 09{OBJECT} credits to {VNAME}.)
; GameOverFormat=String (Default: 03[Game]{TCOLOR} The {TEAML} won by {MESSAGE})
; GameOverTieNoWinFormat=String (Default: 03[Game]10 The battle ended in a {MESSAGE} - Victory handed to  {TCOLOR}{TEAML})
; GameOverTieFormat=String (Default: 03[Game]10 The battle ended in a {MESSAGE})
; GameOverScoreFormat=String (Default: 03[Game]{TCOLOR} {TEAML}: {WINSCORE} | {VTCOLOR}{VTEAML}: {LOSESCORE})
; GameFormat=String (Default: 03[Game] {MESSAGE})
; ExecuteFormat=String (Default: 07{NAME} executed: {MESSAGE})
; SubscribeFormat=String (Default: 03{NAME} has subscribed to the RCON data stream.)
; RCONFormat=String (Default: 05[RCON] {MESSAGE})
; AdminLoginFormat=String (Default: 07[Admin] {NAME} has logged in with 07{ADMIN} IRCNORMAL privledges.)
; AdminGrantFormat=String (Default: 07[Admin] {NAME} has been granted 07{ADMIN} IRCNORMAL privledges.)
; AdminLogoutFormat=String (Default: 07[Admin] {NAME} has logged out of their 07{ADMIN} IRCNORMAL privledges.)
; AdminFormat=String (Default: 07[Admin] {MESSAGE})
; VoteCallFormat=String(Default: )
; VoteOverSuccessFormat=String(Default: )
; VoteOverFailFormat=String(Default: )
; VoteCancelFormat=String(Default: )
; VoteFormat=String(Default: )
; MapChangeFormat=String(Default: )
; MapLoadFormat=String(Default: )
; MapFormat=String(Default: )
; DemoRecordFormat=String(Default: )
; RCONDemoRecordFormat=String(Default: )
; DemoRecordStopFormat=String(Default: )
; DemoFormat=String(Default: )
; LogFormat=String (Default: 07[Log] {MESSAGE})
; CommandFormat=String (Default: )
; ErrorFormat=String (Default: 04[Error] {MESSAGE})
; VersionFormat=String (Default: 03Renegade X RCON connection established; using RCON verison {RVER} for game version {GVER})
; AuthorizedFormat=String (Default: 03RCON authorization completed.)
; OtherFormat=String (Default: 06[Other] {MESSAGE})
;

[RenX.Logging]
ExecuteFormat=

; [RenX.ExtraLogging]
;
; This plugin enables the dumping RCON's raw output to the console
; and to a file. This is helpful for debugging purposes, as well as just
; general logging.
;
; Settings:
; LogFile=String (File logging disabled if unspecified)
;

[RenX.ExtraLogging]
LogFile=RenX.txt

; [RenX.Ladder]
; LadderDatabase=String (Default: Ladder.db; name of file to store ladder entries in)
; OnlyPure=Bool (Default: false; when true, only "pure" games should count)
; OutputTimes=Bool (Default: true; when true, sort/write statistics are shown)
; MaxLadderCommandPartNameOutput=Integer (Default: 5; how many partial matches to show in "ladder" command)
;

[RenX.Ladder]

; [RenX.Announcements]
;
; This plugin sends global messages to players based on text within a
; file.
; For format specifiers, please see the format table at:
; http://www.cplusplus.com/reference/ctime/strftime/
;
; Settings:
; File=String (Default: Announcements.txt; File containing announcements)
; Delay=Integer (Default: 60; Number of seconds between announcements)
; Random=Bool (Default: false; True causes announcements to have no order)
; DateFormat=String (Default: %A, %B %d, %Y; see above for format specifiers)
; TimeFormat=String (Default: %H:%M:%S; see above for format specifiers)
;

[RenX.Announcements]
File=Announcements.txt
Delay=60
Random=false
DateTag={DATE}
TimeTag={TIME}
RulesTag={RULES}
DateFormat=%A, %B %d, %Y
TimeFormat=%H:%M:%S

; [RenX.Medals]
;
; DataFile=String (Default: Medals.ini)
; JoinMessageFile=String (Default: Medals.Join.ini)
; KillCongratDelay=Integer (Default: 60)
; VehicleKillCongratDelay=Integer (Default: 60)
; KDRCongratDelay=Integer (Default: 60)
;

[RenX.Medals]
DataFile=Medals.ini
JoinMessageFile=Medals.Join.ini

; [RenX.Greetings]
;
; Put each greeting message on its own line in your GreetingsFile.
; NameTag will be replaced by the player's name; IPTag replaced
; with the player's IP; SteamTag replaced with the player's Steam ID;
; and UUIDTag replace with the player's UUID.
;
; GreetingsFile=String (Default: RenX.Greetings.txt)
; NameTag=String (Default: {NAME})
; IPTag=String (Default: {IP})
; SteamTag=String (Default: {STEAM})
; UUIDTag=String (Default: {UUID})
; SendPrivate=Bool (Default: True; Send as a private message?)
; SendMode=Integer (Default: 0; 0 = Random Order, 1 = Sequential Order, 2 = Send All)
;

[RenX.Greetings]
GreetingsFile=RenX.Greetings.txt
NameTag={NAME}

; [RenX.IRCJoin]
;
; PublicOnly=Bool (Default: true; true to only relay for public channels)
; NameTag=String (Default: {NAME})
; ChannelTag=String (Default: {CHAN}
; PartReasonTag=String (Default: {REASON}
; Join.MsgAlways=Bool (Default: false; Message when server is empty)
; Join.MinAccess=Integer (Default: 0; minimum access level to relay)
; Join.MaxAccess=Integer (Default: -1; max access level to relay (-1 to disable))
; Join.Format=String (Default: {NAME} has joined {CHAN}!)
; Part.MsgAlways=Bool (Default: false; Message when server is empty)
; Part.MinAccess=Integer (Default: 0; minimum access level to relay)
; Part.MaxAccess=Integer (Default: -1; max access level to relay (-1 to disable))
; Part.Format=String (Default: {NAME} has left {CHAN} ({REASON})!)
; Part.FormatNoReason=String (Default: {NAME} has left {CHAN}!)
;

[RenX.IRCJoin]
PublicOnly=true
NameTag={NAME}
ChannelTag={CHAN}
PartReasonTag={REASON}
Join.MsgAlways=false
Join.MinAccess=0
Join.MaxAccess=-1
Join.Format={NAME} has joined {CHAN}!)
Part.MsgAlways=false
Part.MinAccess=0
Part.MaxAccess=-1
Part.Format={NAME} has left {CHAN} ({REASON})!
Part.FormatNoReason={NAME} has left {CHAN}!

; [RenX.Warn]
; MaxWarns=Integer (Default: 3)
; WarnAction=Integer (Default: -1; -1 = Kick; 0 = Perm Ban; Other Number (Seconds) = Timed Ban)
;

[RenX.Warn]

; [RenX.MinPlayers]
; PlayerThreshold=Integer (Default: 20; number of players + bots to normalize)
;

[RenX.MinPlayers]

; [SetJoins]
; Join messages are stored here.
; Note: Usage of the "setjoin" command syncs the memory-stored
; file to the drive, which will destroy all comments in the process.
;
; String(User)=String(SetJoin)
;

[SetJoins]

; [RenX.SetJoin]
; Renenegade-X game join messages are stored here.
; Note: Usage of the "setjoin" command syncs the memory-stored
; file to the drive, which will destroy all comments in the process.
;
; String(User)=String(SetJoin)
;

[RenX.SetJoin]

;EOF