← Back to branch summary

~widelands-dev/widelands-website/trunk

« back to all changes in this revision

Viewing changes to widelandslib/tribe.py

  • Committer: Holger Rapp
  • Date: 2019-06-21 18:34:42 UTC
  • mfrom: (540.1.3 update_ops_script)
  • Revision ID: sirver@gmx.de-20190621183442-y2ulybzr0rdvfefd
Adapt the update script for the new server.

Show diffs side-by-side

added added

removed removed

Lines of Context:
widelandslib/tribe.py
1
1
#!/usr/bin/env python
2
2
# encoding: utf-8
3
3
 
4
 
from conf import WidelandsConfigParser
5
 
from ConfigParser import NoSectionError, NoOptionError
6
 
import conf
7
 
from itertools import chain
8
4
import os.path as p
9
 
from glob import glob
10
 
import re
 
5
import json
11
6
try:
12
 
    from settings import WIDELANDS_SVN_DIR
13
 
    basedir = WIDELANDS_SVN_DIR
 
7
    from django.conf import settings
 
8
    basedir = settings.WIDELANDS_SVN_DIR
14
9
except:
15
10
    basedir = p.join(p.dirname(__file__), p.pardir, p.pardir)
16
11
 
 
12
 
17
13
class BaseDescr(object):
18
 
    def __init__(self, tribe, name, descname, tdir):
 
14
 
 
15
    def __init__(self, tribe, name, descname, json):
19
16
        self.tribe = tribe
20
 
        self._tdir = tdir
21
 
        self._conf_file = p.join(tdir, name, "conf")
22
 
        self._conf = WidelandsConfigParser(p.join(tdir,name,"conf"))
23
 
 
 
17
        self._json = json
24
18
        self.name = name
25
19
        self.descname = descname
26
20
 
27
21
    @property
28
22
    def image(self):
29
 
        return p.abspath(p.join(self._tdir,self.name,"menu.png"))
 
23
        return p.abspath(p.join(settings.WIDELANDS_SVN_DIR, 'data', self._json['icon']))
 
24
 
30
25
 
31
26
class Ware(BaseDescr):
 
27
 
32
28
    def __str__(self):
33
 
        return "Ware(%s)" % self.name
 
29
        return 'Ware(%s)' % self.name
 
30
 
34
31
 
35
32
class Worker(BaseDescr):
36
 
    @property
37
 
    def outputs(self):
38
 
        rv = set(sorted(
39
 
            i.strip() for i in re.findall(r'\d+=\s*createitem\s*(\w+)',
40
 
                open(self._conf_file).read())
41
 
        ))
42
 
        return rv
43
33
 
44
34
    @property
45
35
    def becomes(self):
46
 
        try:
47
 
            return self._conf.get("global", "becomes")
48
 
        except NoOptionError:
 
36
        if 'becomes' in self._json:
 
37
            return self._json['becomes']['name']
 
38
        else:
49
39
            return None
50
40
 
51
41
    def __str__(self):
52
 
        return "Worker(%s)" % self.name
 
42
        return 'Worker(%s)' % self.name
 
43
 
53
44
 
54
45
class Building(BaseDescr):
 
46
 
55
47
    @property
56
48
    def enhanced_building(self):
57
 
        return self._conf.getboolean("global", "enhanced_building", False)
 
49
        if 'enhanced' in self._json:
 
50
            return True
 
51
        else:
 
52
            return False
58
53
 
59
54
    @property
60
55
    def base_building(self):
61
56
        if not self.enhanced_building:
62
57
            return None
63
 
        bases = [b for b in self.tribe.buildings.values() if b.enhancement == self.name]
 
58
        bases = [b for b in list(self.tribe.buildings.values())
 
59
                 if b.enhancement == self.name]
64
60
        if len(bases) == 0 and self.enhanced_building:
65
 
            raise Exception("Building %s has no bases in tribe %s" % (self.name, self.tribe.name))
 
61
            raise Exception('Building %s has no bases in tribe %s' %
 
62
                            (self.name, self.tribe.name))
66
63
        if len(bases) > 1:
67
 
            raise Exception("Building %s seems to have more than one base in tribe %s." % (self.name, self.tribe.name))
 
64
            raise Exception('Building %s seems to have more than one base in tribe %s.' % (
 
65
                self.name, self.tribe.name))
68
66
        return bases[0]
69
67
 
70
68
    @property
71
69
    def enhancement(self):
72
 
        rv = self._conf.getstring("global", "enhancement", "none")
73
 
        return rv if rv != "none" else None
74
 
 
75
 
    @property
76
 
    def image(self):
77
 
        glob_pat = self._conf.getstring("idle", "pics")
78
 
        return p.abspath(glob(p.join(self._tdir,self.name,glob_pat))[0])
 
70
        if 'enhancement' in self._json:
 
71
            return self._json['enhancement']
 
72
        else:
 
73
            return None
79
74
 
80
75
    @property
81
76
    def buildcost(self):
82
 
        try:
83
 
            return dict(self._conf.items("buildcost"))
84
 
        except NoSectionError:
85
 
            return {}
 
77
        result = dict()
 
78
        if 'buildcost' in self._json:
 
79
            for buildcost in self._json['buildcost']:
 
80
                result[buildcost['name']] = buildcost['amount']
 
81
        return result
86
82
 
87
83
    @property
88
84
    def size(self):
89
 
        return self._conf.getstring("global", "size")
 
85
        return self._json['size']
 
86
 
90
87
 
91
88
class ProductionSite(Building):
92
 
    btype = "productionsite"
 
89
    btype = 'productionsite'
 
90
 
93
91
    @property
94
92
    def outputs(self):
95
 
        self_produced = set(sorted(
96
 
            i.strip() for i in re.findall(r'produce\s*=(\w+)',
97
 
                open(self._conf_file).read())
98
 
        ))
99
 
        if not len(self_produced):
100
 
            rv = reduce(lambda a,b: a | b, [ self.tribe.workers[w].outputs
101
 
                    for w in self.workers ], set())
102
 
            return rv
103
 
        return self_produced
 
93
        result = set()
 
94
        if 'produced_wares' in self._json:
 
95
            for warename in self._json['produced_wares']:
 
96
                result.add(warename)
 
97
        return result
104
98
 
105
99
    @property
106
100
    def inputs(self):
107
 
        try:
108
 
            return dict( (k, v) for k,v in self._conf.items("inputs") )
109
 
        except conf.NoSectionError:
110
 
            return dict()
 
101
        result = dict()
 
102
        if 'stored_wares' in self._json:
 
103
            for ware in self._json['stored_wares']:
 
104
                result[ware['name']] = ware['amount']
 
105
        return result
111
106
 
112
107
    @property
113
108
    def workers(self):
114
 
        return dict( (k, v) for k,v in self._conf.items("working positions") )
 
109
        result = dict()
 
110
        if 'workers' in self._json:
 
111
            for worker in self._json['workers']:
 
112
                result[worker['name']] = worker['amount']
 
113
        return result
115
114
 
116
115
    @property
117
116
    def recruits(self):
118
 
        recs = set([])
119
 
        for prog,_ in self._conf.items("programs"):
120
 
            recs |= set([name for type, name in self._conf.items(prog) if type == "recruit"])
121
 
        return recs
 
117
        result = set()
 
118
        if 'produced_workers' in self._json:
 
119
            for workername in self._json['produced_workers']:
 
120
                result.add(workername)
 
121
        return result
 
122
 
122
123
 
123
124
class Warehouse(Building):
124
 
    btype = "warehouse"
 
125
    btype = 'warehouse'
125
126
    pass
126
127
 
 
128
 
127
129
class TrainingSite(ProductionSite):
128
 
    btype = "trainings site"
 
130
    btype = 'trainingsite'
129
131
    pass
130
132
 
 
133
 
131
134
class MilitarySite(Building):
132
 
    btype = "military site"
 
135
    btype = 'militarysite'
 
136
 
133
137
    @property
134
138
    def conquers(self):
135
 
        return self._conf.get("global", "conquers")
 
139
        return self._json['conquers']
136
140
 
137
141
    @property
138
142
    def max_soldiers(self):
139
 
        return self._conf.get("global", "max_soldiers")
 
143
        return self._json['max_soldiers']
140
144
 
141
145
    @property
142
146
    def heal_per_second(self):
143
 
        return self._conf.getint("global", "heal_per_second")
 
147
        return self._json['heal_per_second']
144
148
 
145
149
 
146
150
class Tribe(object):
147
 
    def __init__(self, name, bdir = basedir):
148
 
        self.name = name
149
 
 
150
 
        tdir = p.join(bdir, "tribes", name)
151
 
 
152
 
        self._conf = WidelandsConfigParser(p.join(tdir, "conf"))
153
 
 
154
 
        self.wares = dict( (k,Ware(self, k, v, tdir)) for k,v in
155
 
            self._conf.items("ware types"))
156
 
        self.workers = dict(chain(
157
 
            ((k,Worker(self, k, v, tdir)) for k,v in
158
 
                self._conf.items("worker types")),
159
 
            ((k,Worker(self, k, v, tdir)) for k,v in
160
 
                self._conf.items("carrier types")),
161
 
        ))
162
 
 
163
 
 
164
 
        self.buildings = dict(chain(
165
 
            ((k,ProductionSite(self, k, v, tdir)) for k,v in \
166
 
                self._conf.items("productionsite types")),
167
 
            ((k,MilitarySite(self, k, v, tdir)) for k,v in \
168
 
                self._conf.items("militarysite types")),
169
 
            ((k,Warehouse(self, k, v, tdir)) for k,v in \
170
 
                self._conf.items("warehouse types")),
171
 
            ((k,TrainingSite(self, k, v, tdir)) for k,v in \
172
 
                self._conf.items("trainingsite types")),
173
 
        ))
 
151
 
 
152
    def __init__(self, tribeinfo, json_directory):
 
153
        self.name = tribeinfo['name']
 
154
 
 
155
        with open(p.normpath(json_directory + '/' +
 
156
                             self.name + '_wares.json'), 'r') as wares_file:
 
157
            waresinfo = json.load(wares_file)
 
158
        self.wares = dict()
 
159
        for ware in waresinfo['wares']:
 
160
            descname = ware['descname']
 
161
            self.wares[ware['name']] = Ware(self, ware['name'], descname, ware)
 
162
 
 
163
        with open(p.normpath(
 
164
                json_directory + '/' + self.name + '_workers.json'), 'r') as workers_file:
 
165
            workersinfo = json.load(workers_file)
 
166
        self.workers = dict()
 
167
        for worker in workersinfo['workers']:
 
168
            descname = worker['descname']
 
169
            self.workers[worker['name']] = Worker(
 
170
                self, worker['name'], descname, worker)
 
171
 
 
172
        with open(p.normpath(
 
173
                json_directory + '/' + self.name + '_buildings.json'), 'r') as buildings_file:
 
174
            buildingsinfo = json.load(buildings_file)
 
175
        self.buildings = dict()
 
176
        for building in buildingsinfo['buildings']:
 
177
            descname = building['descname']
 
178
            if building['type'] == 'productionsite':
 
179
                self.buildings[building['name']] = ProductionSite(
 
180
                    self, building['name'], descname, building)
 
181
            elif building['type'] == 'warehouse':
 
182
                self.buildings[building['name']] = Warehouse(
 
183
                    self, building['name'], descname, building)
 
184
            elif building['type'] == 'trainingsite':
 
185
                self.buildings[building['name']] = TrainingSite(
 
186
                    self, building['name'], descname, building)
 
187
            elif building['type'] == 'militarysite':
 
188
                self.buildings[building['name']] = MilitarySite(
 
189
                    self, building['name'], descname, building)
 
190
            else:
 
191
                self.buildings[building['name']] = Building(
 
192
                    self, building['name'], descname, building)
174
193
 
175
194
    def __str__(self):
176
 
        return "Tribe(%s)" % self.name
177
 
 
178
 
 
 
195
        return 'Tribe(%s)' % self.name