ModEnc is currently in Maintenance Mode: Changes could occur at any given moment, without advance warning.

Rules.ini

From ModEnc
(Redirected from Rules)
Jump to: navigation, search

The rules.ini (naming variations for expansions) is the core file of C&C modding. As indicated by the name, it contains the "rules" of the game – the properties of every object, weapon, warhead, etc. in the game. For any C&C game from Red Alert to Yuri's Revenge, this is the main modification file. For Generals and everything else based on the SAGE engine, the INI-system is more complex and wide-spread.

Disregarding the side functions of the other various INI files (like ai.ini or art.ini), there is no way to make any changes to the game other than what the rules.ini allows for1. Not everything in the game is customizable. Features that cannot be modified are called "hardcoded" features.


File Locations

Game Location Notes
Red Alert redalert.mixlocal.mix
Tiberian Sun tibsun.mixlocal.mix The patches add a new rules.ini to patch.mix
Firestorm expand01.mix rules-equivalent is called firestrm.ini, the mix also contains a new rules.ini for regular TS.
Red Alert 2 ra2.mixlocal.mix
Yuri's Revenge expandmd01.mix Called rulesmd.ini, for mission disk.
Mental Omega expandmo99.mix Called rulesmo.ini, for Mental Omega.

Script to Read UnitsIdCode in Rules.ini

Python 3

ReadRulesCode.py

This script will read the rules.ini and list the UnitType, SequenceNum, UnitIdCode, UnitUIName, UnitInternalName and Armor, and store these informations into a txt file.

To get the CSF.ini that required in this script, please go to page CSF File Format.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# set the directory of rules.ini here
# need to modify the rules.ini if there are any error reports during reading it by module configparser
rules_dir=r"C:\Users\August\Documents\rulesmo_mod.ini"
# rules_dir=r"/storage/emulated/0/1/rulesmo_mod.ini"
# set the output file directory
ofdir=r"C:\Users\August\Documents\UnitCodes.txt"
# ofdir=r"/storage/emulated/0/1/UnitCodes.txt"
# set the directory of CSF.ini that decoded by ReadCsf.py
csf_ini_dir=r"C:\Users\August\Documents\CSF.ini"
# csf_ini_dir=r"/storage/emulated/0/1/CSF/CSF.ini"
from configparser import ConfigParser import os # read rules.ini rules=ConfigParser(delimiters="=") rules.read(rules_dir) # read CSF.ini if it exists csf_exist=False if os.path.isfile(csf_ini_dir): csf=ConfigParser(delimiters="=") csf.read(csf_ini_dir, "UTF-8") csf_exist=True # sections of unit types type_list=["InfantryTypes", "VehicleTypes", "AircraftTypes", "BuildingTypes", "SuperWeaponTypes"] # the attributes of the unit we need as the ini options attr_list=["UIName", "Name", "Armor"] def clear_file(file_path: str): """clear the file especially the file for output""" with open(file_path, "w", encoding="UTF-8"): pass def add_to_file(file_path: str, content: str): """write a string into the file in addition mode""" with open(file_path, "a", encoding="UTF-8") as f: f.write(content) def cut_ref(content: str) -> str: """cut the reference in ini file""" if ";" in content: content=content.replace(content[content.find(";"):], "") return content.lstrip().rstrip()
# clear the output file clear_file(ofdir) for unitype in type_list: # store the header of UnitType txt="== "+unitype+" ==\n" for seqnum in rules[unitype]: idcode=cut_ref(rules[unitype][seqnum]) # record the infomations in "line" line=seqnum+"\t"+idcode+"\t" for attr in attr_list: # SuperWeapons/SupportPowers does not have Armor if unitype=="SuperWeaponTypes" and attr=="Armor": pass # if the unit has the general attributes listed above elif rules.has_option(idcode, attr): # try to translate UIName by CSF if the CSF exists if attr=="UIName" and csf_exist: # browse the CSF for UIName by order UIName="N/A" for section in csf: if csf.has_option(section, rules[idcode][attr]): UIName=csf[section][rules[idcode][attr]] line+=UIName+"\t" else: line+=rules[idcode][attr]+"\t" else: line+="N/A\t" line=line[:-1]+"\n" # add the line into the "txt" txt+=line # write the "txt" into the output file add_to_file(ofdir, txt+"\n") # try to open the output file, may fail if the OS does not support try: os.startfile(ofdir) except: pass
CorrectRulesCode.py

This script will correct the rules.ini with a large amount of duplicate definition and invalid codes, cut out the useless references line without "=", and write a new rules.ini to store the result, so that the module configparser in Python can read it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# set the directories of input and output files
ifdir=r"C:\Users\August\Documents\rulesmo_mod0.ini"
# ifdir=r"/storage/emulated/0/1/rulesmo_mod0.ini"
ofdir=r"C:\Users\August\Documents\rulesmo_mod.ini"
# ofdir=r"/storage/emulated/0/1/rulesmo_mod.ini"
# read the input rules.ini
with open(ifdir, "r", encoding="UTF-8") as f:
    content=f.read()
# use str.replace() method to remove useless codes
dic={"\t": "", " \n": "\n", "\n\n": "\n", " ;": ";",
" =": "=", "= ": "="}
for key in dic:
    while content.find(key)!=-1:
        content=content.replace(key, dic[key])
# split the content as a list by section header
li=content.split("\n[")
# remove not-section item in list
if "]" not in li[0]:
    li=li[1:]
# creat a dictionary to store the information
dic=dict()
# read content by sections
for i in li:
    # split the section name and the option-value pairs
    sec, opt_s=i.split("]")[0], i.split("]")[1]
    # creat a dictionary to store the option-value pairs in this section
    dic[sec]=dict()
    # split the option-value pairs by line break between each of them
    opt_li_orig=opt_s.split("\n")
    # separate the useful line with "=" to cut out the lines only contain references
    opt_li=list()
    for opt_i in opt_li_orig:
        if "=" in opt_i:
            opt_li.append(opt_i)
    # seperate the option and value of the pairs
    for opt_i in opt_li:
        opt, val=opt_i.split("=")[0], opt_i.split("=")[1]
        # cut out the references behind the value
        if ";" in val:
            val=val[:val.find(";")]
        # store the option-value pairs
        dic[sec][opt]=val
# write the output file as the ini format
with open(ofdir, "w", encoding="UTF-8") as f:
    for sec in dic:
        f.write("["+sec+"]\n")
        for opt in dic[sec]:
            f.write(opt+"="+dic[sec][opt]+"\n")
        f.write("\n")

Footnotes

1 An exception to this would be pd's RockPatch.

See Also