4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
10 /** @file newgrf_config.cpp Finding NewGRFs and configuring them. */
14 #include "3rdparty/md5/md5.h"
16 #include "network/network_func.h"
18 #include "newgrf_text.h"
19 #include "window_func.h"
21 #include "video/video_driver.hpp"
22 #include "strings_func.h"
25 #include "fileio_func.h"
30 * Create a new GRFConfig.
31 * @param filename Set the filename of this GRFConfig to filename. The argument
32 * is copied so the original string isn't needed after the constructor.
34 GRFConfig::GRFConfig(const char *filename
) :
38 num_valid_params(lengthof(param
))
40 if (filename
!= NULL
) this->filename
= xstrdup(filename
);
44 * Create a new GRFConfig that is a deep copy of an existing config.
45 * @param config The GRFConfig object to make a copy of.
47 GRFConfig::GRFConfig(const GRFConfig
&config
) :
48 ZeroedMemoryAllocator(),
53 version(config
.version
),
54 min_loadable_version(config
.min_loadable_version
),
55 flags(config
.flags
& ~(1 << GCF_COPY
)),
56 status(config
.status
),
57 grf_bugs(config
.grf_bugs
),
58 num_params(config
.num_params
),
59 num_valid_params(config
.num_valid_params
),
60 palette(config
.palette
),
61 has_param_defaults(config
.has_param_defaults
)
63 MemCpyT
<uint8
>(this->original_md5sum
, config
.original_md5sum
, lengthof(this->original_md5sum
));
64 MemCpyT
<uint32
>(this->param
, config
.param
, lengthof(this->param
));
65 if (config
.filename
!= NULL
) this->filename
= xstrdup(config
.filename
);
66 if (config
.error
!= NULL
) this->error
= new GRFError(*config
.error
);
67 for (uint i
= 0; i
< config
.param_info
.Length(); i
++) {
68 if (config
.param_info
[i
] == NULL
) {
69 *this->param_info
.Append() = NULL
;
71 *this->param_info
.Append() = new GRFParameterInfo(*config
.param_info
[i
]);
76 /** Cleanup a GRFConfig object. */
77 GRFConfig::~GRFConfig()
79 /* GCF_COPY as in NOT strdupped/alloced the filename */
80 if (!HasBit(this->flags
, GCF_COPY
)) {
85 for (uint i
= 0; i
< this->param_info
.Length(); i
++) delete this->param_info
[i
];
89 * Copy the parameter information from the \a src config.
90 * @param src Source config.
92 void GRFConfig::CopyParams(const GRFConfig
&src
)
94 this->num_params
= src
.num_params
;
95 this->num_valid_params
= src
.num_valid_params
;
96 MemCpyT
<uint32
>(this->param
, src
.param
, lengthof(this->param
));
100 * Get the name of this grf. In case the name isn't known
101 * the filename is returned.
102 * @return The name of filename of this grf.
104 const char *GRFConfig::GetName() const
106 const char *name
= this->name
->get_string();
107 return StrEmpty(name
) ? this->filename
: name
;
112 * @return A string with a description of this grf.
114 const char *GRFConfig::GetDescription() const
116 return this->info
->get_string();
121 * @return A string with an url of this grf.
123 const char *GRFConfig::GetURL() const
125 return this->url
->get_string();
128 /** Set the default value for all parameters as specified by action14. */
129 void GRFConfig::SetParameterDefaults()
131 this->num_params
= 0;
132 MemSetT
<uint32
>(this->param
, 0, lengthof(this->param
));
134 if (!this->has_param_defaults
) return;
136 for (uint i
= 0; i
< this->param_info
.Length(); i
++) {
137 if (this->param_info
[i
] == NULL
) continue;
138 this->param_info
[i
]->SetValue(this, this->param_info
[i
]->def_value
);
143 * Set the palette of this GRFConfig to something suitable.
144 * That is either the setting coming from the NewGRF or
145 * the globally used palette.
147 void GRFConfig::SetSuitablePalette()
150 switch (this->palette
& GRFP_GRF_MASK
) {
151 case GRFP_GRF_DOS
: pal
= PAL_DOS
; break;
152 case GRFP_GRF_WINDOWS
: pal
= PAL_WINDOWS
; break;
153 default: pal
= _settings_client
.gui
.newgrf_default_palette
== 1 ? PAL_WINDOWS
: PAL_DOS
; break;
155 SB(this->palette
, GRFP_USE_BIT
, 1, pal
== PAL_WINDOWS
? GRFP_USE_WINDOWS
: GRFP_USE_DOS
);
159 * Finalize Action 14 info after file scan is finished.
161 void GRFConfig::FinalizeParameterInfo()
163 for (GRFParameterInfo
**info
= this->param_info
.Begin(); info
!= this->param_info
.End(); ++info
) {
164 if (*info
== NULL
) continue;
169 GRFConfig
*_all_grfs
;
170 GRFConfig
*_grfconfig
;
171 GRFConfig
*_grfconfig_newgame
;
172 GRFConfig
*_grfconfig_static
;
173 uint _missing_extra_graphics
= 0;
176 * Construct a new GRFError.
177 * @param severity The severity of this error.
178 * @param message The actual error-string.
180 GRFError::GRFError(StringID severity
, StringID message
) :
187 * Create a new GRFError that is a deep copy of an existing error message.
188 * @param error The GRFError object to make a copy of.
190 GRFError::GRFError(const GRFError
&error
) :
191 ZeroedMemoryAllocator(),
192 custom_message(error
.custom_message
),
194 message(error
.message
),
195 severity(error
.severity
)
197 if (error
.custom_message
!= NULL
) this->custom_message
= xstrdup(error
.custom_message
);
198 if (error
.data
!= NULL
) this->data
= xstrdup(error
.data
);
199 memcpy(this->param_value
, error
.param_value
, sizeof(this->param_value
));
202 GRFError::~GRFError()
204 free(this->custom_message
);
209 * Create a new empty GRFParameterInfo object.
210 * @param nr The newgrf parameter that is changed.
212 GRFParameterInfo::GRFParameterInfo(uint nr
) :
215 type(PTYPE_UINT_ENUM
),
217 max_value(UINT32_MAX
),
222 complete_labels(false)
226 * Create a new GRFParameterInfo object that is a deep copy of an existing
227 * parameter info object.
228 * @param info The GRFParameterInfo object to make a copy of.
230 GRFParameterInfo::GRFParameterInfo(GRFParameterInfo
&info
) :
234 min_value(info
.min_value
),
235 max_value(info
.max_value
),
236 def_value(info
.def_value
),
237 param_nr(info
.param_nr
),
238 first_bit(info
.first_bit
),
239 num_bit(info
.num_bit
),
240 value_names(info
.value_names
),
241 complete_labels(info
.complete_labels
)
245 /** Cleanup all parameter info. */
246 GRFParameterInfo::~GRFParameterInfo()
251 * Get the value of this user-changeable parameter from the given config.
252 * @param config The GRFConfig to get the value from.
253 * @return The value of this parameter.
255 uint32
GRFParameterInfo::GetValue(struct GRFConfig
*config
) const
257 /* GB doesn't work correctly with nbits == 32, so handle that case here. */
258 if (this->num_bit
== 32) return config
->param
[this->param_nr
];
259 return GB(config
->param
[this->param_nr
], this->first_bit
, this->num_bit
);
263 * Set the value of this user-changeable parameter in the given config.
264 * @param config The GRFConfig to set the value in.
265 * @param value The new value.
267 void GRFParameterInfo::SetValue(struct GRFConfig
*config
, uint32 value
)
269 /* SB doesn't work correctly with nbits == 32, so handle that case here. */
270 if (this->num_bit
== 32) {
271 config
->param
[this->param_nr
] = value
;
273 SB(config
->param
[this->param_nr
], this->first_bit
, this->num_bit
, value
);
275 config
->num_params
= max
<uint
>(config
->num_params
, this->param_nr
+ 1);
276 SetWindowDirty(WC_GAME_OPTIONS
, WN_GAME_OPTIONS_NEWGRF_STATE
);
280 * Finalize Action 14 info after file scan is finished.
282 void GRFParameterInfo::Finalize()
284 this->complete_labels
= true;
285 for (uint32 value
= this->min_value
; value
<= this->max_value
; value
++) {
286 if (this->value_names
.count(value
) == 0) {
287 this->complete_labels
= false;
294 * Update the palettes of the graphics from the config file.
295 * Called when changing the default palette in advanced settings.
297 * @return Always true.
299 bool UpdateNewGRFConfigPalette(int32 p1
)
301 for (GRFConfig
*c
= _grfconfig_newgame
; c
!= NULL
; c
= c
->next
) c
->SetSuitablePalette();
302 for (GRFConfig
*c
= _grfconfig_static
; c
!= NULL
; c
= c
->next
) c
->SetSuitablePalette();
303 for (GRFConfig
*c
= _all_grfs
; c
!= NULL
; c
= c
->next
) c
->SetSuitablePalette();
308 * Get the data section size of a GRF.
310 * @return Size of the data section or SIZE_MAX if the file has no separate data section.
312 size_t GRFGetSizeOfDataSection(FILE *f
)
314 extern const byte _grf_cont_v2_sig
[];
315 static const uint header_len
= 14;
317 byte data
[header_len
];
318 if (fread(data
, 1, header_len
, f
) == header_len
) {
319 if (data
[0] == 0 && data
[1] == 0 && MemCmpT(data
+ 2, _grf_cont_v2_sig
, 8) == 0) {
320 /* Valid container version 2, get data section size. */
321 size_t offset
= ((size_t)data
[13] << 24) | ((size_t)data
[12] << 16) | ((size_t)data
[11] << 8) | (size_t)data
[10];
322 if (offset
>= 1 * 1024 * 1024 * 1024) {
323 DEBUG(grf
, 0, "Unexpectedly large offset for NewGRF");
324 /* Having more than 1 GiB of data is very implausible. Mostly because then
325 * all pools in OpenTTD are flooded already. Or it's just Action C all over.
326 * In any case, the offsets to graphics will likely not work either. */
329 return header_len
+ offset
;
337 * Calculate the MD5 sum for a GRF, and store it in the config.
338 * @param config GRF to compute.
339 * @param subdir The subdirectory to look in.
340 * @return MD5 sum was successfully computed
342 static bool CalcGRFMD5Sum(GRFConfig
*config
, Subdirectory subdir
)
350 f
= FioFOpenFile(config
->filename
, "rb", subdir
, &size
);
351 if (f
== NULL
) return false;
353 long start
= ftell(f
);
354 size
= min(size
, GRFGetSizeOfDataSection(f
));
356 if (start
< 0 || fseek(f
, start
, SEEK_SET
) < 0) {
361 /* calculate md5sum */
362 while ((len
= fread(buffer
, 1, (size
> sizeof(buffer
)) ? sizeof(buffer
) : size
, f
)) != 0 && size
!= 0) {
364 checksum
.Append(buffer
, len
);
366 checksum
.Finish(config
->ident
.md5sum
);
375 * Find the GRFID of a given grf, and calculate its md5sum.
376 * @param config grf to fill.
377 * @param is_static grf is static.
378 * @param subdir the subdirectory to search in.
379 * @return Operation was successfully completed.
381 bool FillGRFDetails(GRFConfig
*config
, bool is_static
, Subdirectory subdir
)
383 if (!FioCheckFileExists(config
->filename
, subdir
)) {
384 config
->status
= GCS_NOT_FOUND
;
388 /* Find and load the Action 8 information */
389 assert_compile (CONFIG_SLOT
< MAX_FILE_SLOTS
);
390 LoadNewGRFFile(config
, CONFIG_SLOT
, GLS_FILESCAN
, subdir
);
391 config
->SetSuitablePalette();
392 config
->FinalizeParameterInfo();
394 /* Skip if the grfid is 0 (not read) or if it is an internal GRF */
395 if (config
->ident
.grfid
== 0 || HasBit(config
->flags
, GCF_SYSTEM
)) return false;
398 /* Perform a 'safety scan' for static GRFs */
399 LoadNewGRFFile(config
, CONFIG_SLOT
, GLS_SAFETYSCAN
, subdir
);
401 /* GCF_UNSAFE is set if GLS_SAFETYSCAN finds unsafe actions */
402 if (HasBit(config
->flags
, GCF_UNSAFE
)) return false;
405 return CalcGRFMD5Sum(config
, subdir
);
410 * Clear a GRF Config list, freeing all nodes.
411 * @param config Start of the list.
412 * @post \a config is set to \c NULL.
414 void ClearGRFConfigList(GRFConfig
**config
)
417 for (c
= *config
; c
!= NULL
; c
= next
) {
426 * Copy a GRF Config list
427 * @param dst pointer to destination list
428 * @param src pointer to source list values
429 * @param init_only the copied GRF will be processed up to GLS_INIT
430 * @return pointer to the last value added to the destination list
432 GRFConfig
**CopyGRFConfigList(GRFConfig
**dst
, const GRFConfig
*src
, bool init_only
)
434 /* Clear destination as it will be overwritten */
435 ClearGRFConfigList(dst
);
436 for (; src
!= NULL
; src
= src
->next
) {
437 GRFConfig
*c
= new GRFConfig(*src
);
439 ClrBit(c
->flags
, GCF_INIT_ONLY
);
440 if (init_only
) SetBit(c
->flags
, GCF_INIT_ONLY
);
450 * Removes duplicates from lists of GRFConfigs. These duplicates
451 * are introduced when the _grfconfig_static GRFs are appended
452 * to the _grfconfig on a newgame or savegame. As the parameters
453 * of the static GRFs could be different that the parameters of
454 * the ones used non-statically. This can result in desyncs in
455 * multiplayers, so the duplicate static GRFs have to be removed.
457 * This function _assumes_ that all static GRFs are placed after
458 * the non-static GRFs.
460 * @param list the list to remove the duplicates from
462 static void RemoveDuplicatesFromGRFConfigList(GRFConfig
*list
)
467 if (list
== NULL
) return;
469 for (prev
= list
, cur
= list
->next
; cur
!= NULL
; prev
= cur
, cur
= cur
->next
) {
470 if (cur
->ident
.grfid
!= list
->ident
.grfid
) continue;
472 prev
->next
= cur
->next
;
474 cur
= prev
; // Just go back one so it continues as normal later on
477 RemoveDuplicatesFromGRFConfigList(list
->next
);
481 * Appends the static GRFs to a list of GRFs
482 * @param dst the head of the list to add to
484 void AppendStaticGRFConfigs(GRFConfig
**dst
)
486 GRFConfig
**tail
= dst
;
487 while (*tail
!= NULL
) tail
= &(*tail
)->next
;
489 CopyGRFConfigList(tail
, _grfconfig_static
, false);
490 RemoveDuplicatesFromGRFConfigList(*dst
);
494 * Appends an element to a list of GRFs
495 * @param dst the head of the list to add to
496 * @param el the new tail to be
498 void AppendToGRFConfigList(GRFConfig
**dst
, GRFConfig
*el
)
500 GRFConfig
**tail
= dst
;
501 while (*tail
!= NULL
) tail
= &(*tail
)->next
;
504 RemoveDuplicatesFromGRFConfigList(*dst
);
508 /** Reset the current GRF Config to either blank or newgame settings. */
509 void ResetGRFConfig(bool defaults
)
511 CopyGRFConfigList(&_grfconfig
, _grfconfig_newgame
, !defaults
);
512 AppendStaticGRFConfigs(&_grfconfig
);
517 * Check if all GRFs in the GRF config from a savegame can be loaded.
518 * @param grfconfig GrfConfig to check
519 * @return will return any of the following 3 values:<br>
521 * <li> GLC_ALL_GOOD: No problems occurred, all GRF files were found and loaded
522 * <li> GLC_COMPATIBLE: For one or more GRF's no exact match was found, but a
523 * compatible GRF with the same grfid was found and used instead
524 * <li> GLC_NOT_FOUND: For one or more GRF's no match was found at all
527 GRFListCompatibility
IsGoodGRFConfigList(GRFConfig
*grfconfig
)
529 GRFListCompatibility res
= GLC_ALL_GOOD
;
531 for (GRFConfig
*c
= grfconfig
; c
!= NULL
; c
= c
->next
) {
532 const GRFConfig
*f
= FindGRFConfig(c
->ident
.grfid
, FGCM_EXACT
, c
->ident
.md5sum
);
533 if (f
== NULL
|| HasBit(f
->flags
, GCF_INVALID
)) {
535 md5sumToString (buf
, c
->ident
.md5sum
);
537 /* If we have not found the exactly matching GRF try to find one with the
538 * same grfid, as it most likely is compatible */
539 f
= FindGRFConfig(c
->ident
.grfid
, FGCM_COMPATIBLE
, NULL
, c
->version
);
541 /* No compatible grf was found, mark it as disabled */
542 DEBUG(grf
, 0, "NewGRF %08X (%s) not found; checksum %s", BSWAP32(c
->ident
.grfid
), c
->filename
, buf
);
544 c
->status
= GCS_NOT_FOUND
;
549 DEBUG(grf
, 1, "NewGRF %08X (%s) not found; checksum %s. Compatibility mode on", BSWAP32(c
->ident
.grfid
), c
->filename
, buf
);
550 if (!HasBit(c
->flags
, GCF_COMPATIBLE
)) {
551 /* Preserve original_md5sum after it has been assigned */
552 SetBit(c
->flags
, GCF_COMPATIBLE
);
553 memcpy(c
->original_md5sum
, c
->ident
.md5sum
, sizeof(c
->original_md5sum
));
556 /* Non-found has precedence over compatibility load */
557 if (res
!= GLC_NOT_FOUND
) res
= GLC_COMPATIBLE
;
560 DEBUG(grf
, 1, "Loading GRF %08X from %s", BSWAP32(f
->ident
.grfid
), f
->filename
);
561 /* The filename could be the filename as in the savegame. As we need
562 * to load the GRF here, we need the correct filename, so overwrite that
563 * in any case and set the name and info when it is not set already.
564 * When the GCF_COPY flag is set, it is certain that the filename is
565 * already a local one, so there is no need to replace it. */
566 if (!HasBit(c
->flags
, GCF_COPY
)) {
568 c
->filename
= xstrdup(f
->filename
);
569 memcpy(c
->ident
.md5sum
, f
->ident
.md5sum
, sizeof(c
->ident
.md5sum
));
573 c
->version
= f
->version
;
574 c
->min_loadable_version
= f
->min_loadable_version
;
575 c
->num_valid_params
= f
->num_valid_params
;
576 c
->has_param_defaults
= f
->has_param_defaults
;
577 for (uint i
= 0; i
< f
->param_info
.Length(); i
++) {
578 if (f
->param_info
[i
] == NULL
) {
579 *c
->param_info
.Append() = NULL
;
581 *c
->param_info
.Append() = new GRFParameterInfo(*f
->param_info
[i
]);
590 /** Helper for scanning for files with GRF as extension */
591 class GRFFileScanner
: FileScanner
{
592 uint next_update
; ///< The next (realtime tick) we do update the screen.
593 uint num_scanned
; ///< The number of GRFs we have scanned.
596 GRFFileScanner() : next_update(_realtime_tick
), num_scanned(0)
600 /* virtual */ bool AddFile(const char *filename
, size_t basepath_length
, const char *tar_filename
);
602 /** Do the scan for GRFs. */
606 int ret
= fs
.Scan(".grf", NEWGRF_DIR
);
607 /* The number scanned and the number returned may not be the same;
608 * duplicate NewGRFs and base sets are ignored in the return value. */
609 _settings_client
.gui
.last_newgrf_count
= fs
.num_scanned
;
614 bool GRFFileScanner::AddFile(const char *filename
, size_t basepath_length
, const char *tar_filename
)
616 GRFConfig
*c
= new GRFConfig(filename
+ basepath_length
);
619 if (FillGRFDetails(c
, false)) {
620 if (_all_grfs
== NULL
) {
623 /* Insert file into list at a position determined by its
624 * name, so the list is sorted as we go along */
627 for (pd
= &_all_grfs
; (d
= *pd
) != NULL
; pd
= &d
->next
) {
628 if (c
->ident
.matches (d
->ident
)) added
= false;
629 /* Because there can be multiple grfs with the same name, make sure we checked all grfs with the same name,
630 * before inserting the entry. So insert a new grf at the end of all grfs with the same name, instead of
631 * just after the first with the same name. Avoids doubles in the list. */
632 if (strcasecmp(c
->GetName(), d
->GetName()) <= 0) {
648 if (this->next_update
<= _realtime_tick
) {
649 _modal_progress_work_mutex
->EndCritical();
650 _modal_progress_paint_mutex
->BeginCritical();
652 const char *name
= c
->name
->get_string();
653 if (name
== NULL
) name
= c
->filename
;
654 UpdateNewGRFScanStatus(this->num_scanned
, name
);
656 _modal_progress_work_mutex
->BeginCritical();
657 _modal_progress_paint_mutex
->EndCritical();
659 this->next_update
= _realtime_tick
+ 200;
663 /* File couldn't be opened, or is either not a NewGRF or is a
664 * 'system' NewGRF or it's already known, so forget about it. */
672 * Simple sorter for GRFS
673 * @param p1 the first GRFConfig *
674 * @param p2 the second GRFConfig *
675 * @return the same strcmp would return for the name of the NewGRF.
677 static int CDECL
GRFSorter(GRFConfig
* const *p1
, GRFConfig
* const *p2
)
679 const GRFConfig
*c1
= *p1
;
680 const GRFConfig
*c2
= *p2
;
682 return strnatcmp(c1
->GetName(), c2
->GetName());
686 * Really perform the scan for all NewGRFs.
687 * @param callback The callback to call after the scanning is complete.
689 void DoScanNewGRFFiles(void *callback
)
691 _modal_progress_work_mutex
->BeginCritical();
693 ClearGRFConfigList(&_all_grfs
);
694 TarScanner::DoScan(TarScanner::NEWGRF
);
696 DEBUG(grf
, 1, "Scanning for NewGRFs");
697 uint num
= GRFFileScanner::DoScan();
699 DEBUG(grf
, 1, "Scan complete, found %d files", num
);
700 if (num
!= 0 && _all_grfs
!= NULL
) {
701 /* Sort the linked list using quicksort.
702 * For that we first have to make an array, then sort and
703 * then remake the linked list. */
704 GRFConfig
**to_sort
= xmalloct
<GRFConfig
*>(num
);
707 for (GRFConfig
*p
= _all_grfs
; p
!= NULL
; p
= p
->next
, i
++) {
710 /* Number of files is not necessarily right */
713 QSortT(to_sort
, num
, &GRFSorter
);
715 for (i
= 1; i
< num
; i
++) {
716 to_sort
[i
- 1]->next
= to_sort
[i
];
718 to_sort
[num
- 1]->next
= NULL
;
719 _all_grfs
= to_sort
[0];
723 #ifdef ENABLE_NETWORK
724 NetworkAfterNewGRFScan();
728 _modal_progress_work_mutex
->EndCritical();
729 _modal_progress_paint_mutex
->BeginCritical();
731 /* Yes... these are the NewGRF windows */
732 InvalidateWindowClassesData(WC_SAVELOAD
, 0, true);
733 InvalidateWindowData(WC_GAME_OPTIONS
, WN_GAME_OPTIONS_NEWGRF_STATE
, GOID_NEWGRF_RESCANNED
, true);
734 if (callback
!= NULL
) ((NewGRFScanCallback
*)callback
)->OnNewGRFsScanned();
736 DeleteWindowByClass(WC_MODAL_PROGRESS
);
737 SetModalProgress(false);
738 MarkWholeScreenDirty();
739 _modal_progress_paint_mutex
->EndCritical();
743 * Scan for all NewGRFs.
744 * @param callback The callback to call after the scanning is complete.
746 void ScanNewGRFFiles(NewGRFScanCallback
*callback
)
748 /* First set the modal progress. This ensures that it will eventually let go of the paint mutex. */
749 SetModalProgress(true);
750 /* Only then can we really start, especially by marking the whole screen dirty. Get those other windows hidden!. */
751 MarkWholeScreenDirty();
753 if (!VideoDriver::GetActiveDriver()->HasGUI() || !ThreadObject::New(&DoScanNewGRFFiles
, callback
, NULL
, "ottd:newgrf-scan")) {
754 _modal_progress_work_mutex
->EndCritical();
755 _modal_progress_paint_mutex
->EndCritical();
756 DoScanNewGRFFiles(callback
);
757 _modal_progress_paint_mutex
->BeginCritical();
758 _modal_progress_work_mutex
->BeginCritical();
760 UpdateNewGRFScanStatus(0, NULL
);
765 * Find a NewGRF in the scanned list.
766 * @param grfid GRFID to look for,
767 * @param mode Restrictions for matching grfs
768 * @param md5sum Expected MD5 sum
769 * @param desired_version Requested version
770 * @return The matching grf, if it exists in #_all_grfs, else \c NULL.
772 const GRFConfig
*FindGRFConfig(uint32 grfid
, FindGRFConfigMode mode
, const uint8
*md5sum
, uint32 desired_version
)
774 assert((mode
== FGCM_EXACT
) != (md5sum
== NULL
));
775 const GRFConfig
*best
= NULL
;
776 for (const GRFConfig
*c
= _all_grfs
; c
!= NULL
; c
= c
->next
) {
777 /* if md5sum is set, we look for an exact match and continue if not found */
778 if (!c
->ident
.matches (grfid
, md5sum
)) continue;
779 /* return it, if the exact same newgrf is found, or if we do not care about finding "the best" */
780 if (md5sum
!= NULL
|| mode
== FGCM_ANY
) return c
;
781 /* Skip incompatible stuff, unless explicitly allowed */
782 if (mode
!= FGCM_NEWEST
&& HasBit(c
->flags
, GCF_INVALID
)) continue;
783 /* check version compatibility */
784 if (mode
== FGCM_COMPATIBLE
&& (c
->version
< desired_version
|| c
->min_loadable_version
> desired_version
)) continue;
785 /* remember the newest one as "the best" */
786 if (best
== NULL
|| c
->version
> best
->version
) best
= c
;
792 #ifdef ENABLE_NETWORK
794 /** Structure for UnknownGRFs; this is a lightweight variant of GRFConfig */
795 struct UnknownGRF
: public GRFIdentifier
{
796 UnknownGRF
*next
; ///< The next unknown GRF.
797 ttd_shared_ptr
<GRFTextMap
> name
; ///< Name of the GRF.
801 * Finds the name of a NewGRF in the list of names for unknown GRFs. An
802 * unknown GRF is a GRF where the .grf is not found during scanning.
804 * The names are resolved via UDP calls to servers that should know the name,
805 * though the replies may not come. This leaves "<Unknown>" as name, though
806 * that shouldn't matter _very_ much as they need GRF crawler or so to look
807 * up the GRF anyway and that works better with the GRF ID.
809 * @param ident the GRF identifier
810 * @param create whether to create a new GRFConfig if the GRFConfig did not
811 * exist in the fake list of GRFConfigs.
812 * If true, a GRFConfig will be returned unconditionally, and
813 * it will be created if it does not exist yet.
814 * If false, a GRFConfig will be returned only if it already
815 * existed and is still unknown; otherwise, NULL will be returned.
816 * @return The shared GRFTextMap of the name of the GRFConfig with the given GRF ID
817 * and MD5 checksum or NULL when it does not exist and create is false.
818 * This value must NEVER be freed by the caller.
820 ttd_shared_ptr
<GRFTextMap
> *FindUnknownGRFName (const GRFIdentifier
&ident
, bool create
)
823 static UnknownGRF
*unknown_grfs
= NULL
;
825 for (grf
= unknown_grfs
; grf
!= NULL
; grf
= grf
->next
) {
826 if (grf
->matches (ident
)) {
827 return (create
|| strcmp (grf
->name
->get_string(), UNKNOWN_GRF_NAME_PLACEHOLDER
) == 0) ? &grf
->name
: NULL
;
831 if (!create
) return NULL
;
833 grf
= new UnknownGRF
;
834 grf
->grfid
= ident
.grfid
;
835 memcpy (grf
->md5sum
, ident
.md5sum
, sizeof(grf
->md5sum
));
836 grf
->next
= unknown_grfs
;
838 GRFTextMap
*map
= new GRFTextMap
;
839 map
->add_default (UNKNOWN_GRF_NAME_PLACEHOLDER
);
840 grf
->name
.reset (map
);
846 #endif /* ENABLE_NETWORK */
850 * Retrieve a NewGRF from the current config by its grfid.
851 * @param grfid grf to look for.
852 * @param mask GRFID mask to allow for partial matching.
853 * @return The grf config, if it exists, else \c NULL.
855 GRFConfig
*GetGRFConfig(uint32 grfid
, uint32 mask
)
859 for (c
= _grfconfig
; c
!= NULL
; c
= c
->next
) {
860 if ((c
->ident
.grfid
& mask
) == (grfid
& mask
)) return c
;
867 /** Build a string containing space separated parameter values, and terminate */
868 void GRFBuildParamList (stringb
*dst
, const GRFConfig
*c
)
870 /* Return an empty string if there are no parameters */
871 if (c
->num_params
== 0) {
876 dst
->fmt ("%d", c
->param
[0]);
878 for (uint i
= 1; i
< c
->num_params
; i
++) {
879 dst
->append_fmt (" %d", c
->param
[i
]);
883 /** Base GRF ID for OpenTTD's base graphics GRFs. */
884 static const uint32 OPENTTD_GRAPHICS_BASE_GRF_ID
= BSWAP32(0xFF4F5400);
887 * Search a textfile file next to this NewGRF.
888 * @param type The type of the textfile to search for.
889 * @return A description for the textfile.
891 TextfileDesc
GRFConfig::GetTextfile (TextfileType type
) const
893 return TextfileDesc (type
, NEWGRF_DIR
, this->filename
);