1 /* $Id$ */

     2 

     3 /** @file autoreplace.cpp Management of replacement lists. */

     4 

     5 #include "stdafx.h"

     6 #include "openttd.h"

     7 #include "debug.h"

     8 #include "command_func.h"

     9 #include "saveload.h"

    10 #include "group.h"

    11 #include "autoreplace_base.h"

    12 #include "oldpool_func.h"

    13 

    14 DEFINE_OLD_POOL_GENERIC(EngineRenew, EngineRenew)

    15 

    16 /**

    17  * Retrieves the EngineRenew that specifies the replacement of the given

    18  * engine type from the given renewlist */

    19 static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)

    20 {

    21 	EngineRenew *er = (EngineRenew *)erl;

    22 

    23 	while (er) {

    24 		if (er->from == engine && er->group_id == group) return er;

    25 		er = er->next;

    26 	}

    27 	return NULL;

    28 }

    29 

    30 void RemoveAllEngineReplacement(EngineRenewList *erl)

    31 {

    32 	EngineRenew *er = (EngineRenew *)(*erl);

    33 	EngineRenew *next;

    34 

    35 	while (er != NULL) {

    36 		next = er->next;

    37 		delete er;

    38 		er = next;

    39 	}

    40 	*erl = NULL; // Empty list

    41 }

    42 

    43 EngineID EngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)

    44 {

    45 	const EngineRenew *er = GetEngineReplacement(erl, engine, group);

    46 	if (er == NULL && (group == DEFAULT_GROUP || (IsValidGroupID(group) && !GetGroup(group)->replace_protection))) {

    47 		/* We didn't find anything useful in the vehicle's own group so we will try ALL_GROUP */

    48 		er = GetEngineReplacement(erl, engine, ALL_GROUP);

    49 	}

    50 	return er == NULL ? INVALID_ENGINE : er->to;

    51 }

    52 

    53 CommandCost AddEngineReplacement(EngineRenewList *erl, EngineID old_engine, EngineID new_engine, GroupID group, uint32 flags)

    54 {

    55 	EngineRenew *er;

    56 

    57 	/* Check if the old vehicle is already in the list */

    58 	er = GetEngineReplacement(*erl, old_engine, group);

    59 	if (er != NULL) {

    60 		if (flags & DC_EXEC) er->to = new_engine;

    61 		return CommandCost();

    62 	}

    63 

    64 	if (!EngineRenew::CanAllocateItem()) return CMD_ERROR;

    65 

    66 	if (flags & DC_EXEC) {

    67 		er = new EngineRenew(old_engine, new_engine);

    68 		er->group_id = group;

    69 

    70 		/* Insert before the first element */

    71 		er->next = (EngineRenew *)(*erl);

    72 		*erl = (EngineRenewList)er;

    73 	}

    74 

    75 	return CommandCost();

    76 }

    77 

    78 CommandCost RemoveEngineReplacement(EngineRenewList *erl, EngineID engine, GroupID group, uint32 flags)

    79 {

    80 	EngineRenew *er = (EngineRenew *)(*erl);

    81 	EngineRenew *prev = NULL;

    82 

    83 	while (er)

    84 	{

    85 		if (er->from == engine && er->group_id == group) {

    86 			if (flags & DC_EXEC) {

    87 				if (prev == NULL) { // First element

    88 					/* The second becomes the new first element */

    89 					*erl = (EngineRenewList)er->next;

    90 				} else {

    91 					/* Cut this element out */

    92 					prev->next = er->next;

    93 				}

    94 				delete er;

    95 			}

    96 			return CommandCost();

    97 		}

    98 		prev = er;

    99 		er = er->next;

   100 	}

   101 

   102 	return CMD_ERROR;

   103 }

   104 

   105 static const SaveLoad _engine_renew_desc[] = {

   106 	    SLE_VAR(EngineRenew, from,     SLE_UINT16),

   107 	    SLE_VAR(EngineRenew, to,       SLE_UINT16),

   108 

   109 	    SLE_REF(EngineRenew, next,     REF_ENGINE_RENEWS),

   110 	SLE_CONDVAR(EngineRenew, group_id, SLE_UINT16, 60, SL_MAX_VERSION),

   111 	SLE_END()

   112 };

   113 

   114 static void Save_ERNW()

   115 {

   116 	EngineRenew *er;

   117 

   118 	FOR_ALL_ENGINE_RENEWS(er) {

   119 		SlSetArrayIndex(er->index);

   120 		SlObject(er, _engine_renew_desc);

   121 	}

   122 }

   123 

   124 static void Load_ERNW()

   125 {

   126 	int index;

   127 

   128 	while ((index = SlIterateArray()) != -1) {

   129 		EngineRenew *er = new (index) EngineRenew();

   130 		SlObject(er, _engine_renew_desc);

   131 

   132 		/* Advanced vehicle lists, ungrouped vehicles got added */

   133 		if (CheckSavegameVersion(60)) {

   134 			er->group_id = ALL_GROUP;

   135 		} else if (CheckSavegameVersion(71)) {

   136 			if (er->group_id == DEFAULT_GROUP) er->group_id = ALL_GROUP;

   137 		}

   138 	}

   139 }

   140 

   141 extern const ChunkHandler _autoreplace_chunk_handlers[] = {

   142 	{ 'ERNW', Save_ERNW,     Load_ERNW,     CH_ARRAY | CH_LAST},

   143 };

   144 

   145 void InitializeEngineRenews()

   146 {

   147 	/* Clean the engine renew pool and create 1 block in it */

   148 	_EngineRenew_pool.CleanPool();

   149 	_EngineRenew_pool.AddBlockToPool();

   150 }