text: 
  /*
   * $Id: map.weather.c,v 1.1.1.1 2005/01/11 21:18:10 kstevens Exp $
   *
   * Author: Cord Awtry <kipsta@bs-interactive.com>
   *
   *  Copyright (c) 2002 Cord Awtry
   *       All rights reserved
   */
  
  #include "mech.h"
  #include "p.mech.utils.h"
  #include "p.mech.ice.h"
  #include "p.map.build.functions.h"
  
  int validateWeatherConditions(int curConditions)
  {
  	int conditions = curConditions;
  
  	if(conditions & WEATHER_PRECIP) {
  		if(conditions & WEATHER_HEAVY_PRECIP)
  			conditions &= ~WEATHER_PRECIP;
  	}
  
  	return conditions;
  }
  
  int calcWeatherEffects(MAP * map)
  {
  	int effects = 0;
  	int weather = map->weather;
  	char temp = map->temp;
  	short windspeed = map->windspeed;
  
  	if(windspeed > 60)
  		effects = EFFECT_HIGH_WINDS;
  	else if(windspeed >= 30)
  		effects = EFFECT_WINDS;
  
  	if(weather & WEATHER_HEAVY_PRECIP) {
  		if(temp <= 0) {
  			if(effects & EFFECT_HIGH_WINDS) {
  				effects &= ~EFFECT_HIGH_WINDS;
  				effects |= EFFECT_BLIZZARD;
  			} else
  				effects |= EFFECT_HEAVY_SNOW;
  		} else
  			effects |= EFFECT_HEAVY_RAIN;
  	} else if(weather & WEATHER_PRECIP) {
  		if(temp <= 0)
  			effects |= EFFECT_SNOW;
  		else
  			effects |= EFFECT_RAIN;
  	}
  
  	if(weather & WEATHER_FOG)
  		effects |= EFFECT_FOG;
  
  	if(weather & WEATHER_BLOWING_SAND)
  		effects |= EFFECT_BLOWING_SAND;
  
  	return effects;
  }
  
  int calcWeatherGunEffects(MAP * map, int weapindx)
  {
  	int gunMods = 0;
  	int weapType = MechWeapons[weapindx].type;
  
  	if(MapEffectRain(map)) {
  		gunMods += 1;
  	} else if(MapEffectRain(map)) {
  		gunMods += 1;
  	}
  
  	if(MapEffectBlizzard(map)) {
  		gunMods += ((weapType == TAMMO) ? 2 : 1);
  	} else if(MapEffectHvySnow(map)) {
  		gunMods += 1;
  	}
  
  	if(MapEffectFog(map)) {
  		gunMods += ((weapType == TBEAM) ? 1 : 0);
  	}
  
  	if(MapEffectSand(map)) {
  		gunMods += ((weapType == TAMMO) ? 1 : 2);
  	}
  
  	if(MapEffectHighWinds(map) & !MapEffectBlizzard(map)) {
  		gunMods += ((weapType == TAMMO) ? 2 : 0);
  	}
  
  	if(MapEffectWinds(map)) {
  		gunMods += ((weapType == TAMMO) ? 1 : 0);
  	}
  
  	return gunMods;
  }
  
  int calcWeatherPilotEffects(MECH * mech)
  {
  	MAP *map = FindObjectsData(mech->mapindex);
  	int onTheGround = 1;
  	int mod = 0;
  
  	if(!map)
  		return 0;
  
  	onTheGround = (!Jumping(mech) &&
  				   (MechZ(mech) <= Elevation(map, MechX(mech), MechY(mech))));
  
  	if(onTheGround) {
  		if((MapEffectHvyRain(map) || MapEffectHvySnow(map) ||
  			MapEffectHighWinds(map) || MapEffectBlizzard(map)))
  			mod += 1;
  
  		if(MechMove(mech) != MOVE_HOVER) {
  			if(HexHasDeepSnow(map, MechX(mech), MechY(mech)))
  				mod += 1;
  
  			if(HexHasMud(map, MechX(mech), MechY(mech)))
  				mod += 1;
  
  			if(HexHasRapids(map, MechX(mech), MechY(mech)))
  				mod += 2;
  		}
  
  		return mod;
  	}
  
  	return 0;
  }
  
  void setWeatherHeatEffects(MAP * map, MECH * mech)
  {
  	if(MapEffectHvyRain(map))
  		MechMinusHeat(mech) -= 2.;
  	else if(MapEffectRain(map))
  		MechMinusHeat(mech) -= 1.;
  
  	if(MapEffectBlizzard(map))
  		MechMinusHeat(mech) -= 2.;
  	else if(MapEffectHvySnow(map))
  		MechMinusHeat(mech) -= 1.;
  
  	if(MapTemperature(map) < -30 || MapTemperature(map) > 50) {
  		if(MapTemperature(map) < -30)
  			MechMinusHeat(mech) += (-30 - MapTemperature(map) + 9) / 10;
  		else
  			MechMinusHeat(mech) -= (MapTemperature(map) - 50 + 9) / 10;
  	}
  
  	if(HexHasDeepSnow(map, MechX(mech), MechY(mech))) {
  		if(FindLegHeatSinks(mech) > 0)
  			MechMinusHeat(mech) -= 1.;
  	}
  }
  
  void meltSnowAndIce(MAP * map, int x, int y, int depth, int emit,
  					int makeSteam)
  {
  	int data = 0;
  	int layers = 0, oldLayers = 0;
  	int snowDone = 0;
  	int steamLength = 0;
  
  	if(!map)
  		return;
  
  	if(depth <= 0)
  		return;
  
  	oldLayers = GetHexLayers(map, x, y);
  	layers = oldLayers;
  	data = GetHexLayerData(map, x, y);
  
  	if((layers & HEXLAYER_SNOW) || (layers & HEXLAYER_DEEP_SNOW)) {
  		data = MAX(0, data - depth);
  		steamLength = abs(data - GetHexLayerData(map, x, y));
  
  		if(data == 0)
  			layers &= ~(HEXLAYER_SNOW | HEXLAYER_DEEP_SNOW);
  		else if(data <= 1000) {
  			layers |= HEXLAYER_SNOW;
  			layers &= ~HEXLAYER_DEEP_SNOW;
  		} else {
  			layers |= HEXLAYER_DEEP_SNOW;
  			layers &= ~HEXLAYER_SNOW;
  		}
  
  		SetHexLayers(map, x, y, layers);
  		SetHexLayerData(map, x, y, data);
  
  		if(emit) {
  			if(layers & HEXLAYER_DEEP_SNOW)
  				snowDone = 1;
  
  			if(!snowDone && !((layers & HEXLAYER_SNOW) ||
  							  (layers & HEXLAYER_DEEP_SNOW))) {
  				HexLOSBroadcast(map, x, y,
  								"%ch%cgThe snow in $h melts to nothingness!%cn");
  				snowDone = 1;
  			}
  
  			if(!snowDone && ((oldLayers & HEXLAYER_DEEP_SNOW) &&
  							 (!(layers & HEXLAYER_DEEP_SNOW)))) {
  				HexLOSBroadcast(map, x, y,
  								"%ch%cgThe snow in $h visibly melts!%cn");
  				snowDone = 1;
  			}
  		}
  	}
  
  	if(IsIceHex(map, x, y)) {
  		if(depth >= (Elevation(map, x, y) * 200)) {
  			if(emit)
  				HexLOSBroadcast(map, x, y, "The ice at $h breaks apart!");
  
  			breakIceAndSplashUnits(map, NULL, x, y,
  								   "goes swimming as ice breaks!");
  			steamLength = (Elevation(map, x, y) * 200);
  		}
  	}
  
  	if((steamLength > 0) && makeSteam) {
  		if(steamLength > 90)
  			steamLength = 90 + Number(0, steamLength / 20);
  
  		add_decoration(map, x, y, TYPE_SMOKE, SMOKE, steamLength);
  	}
  }
  
  void growSnow(MAP * map, int lowDepth, int highDepth)
  {
  	int i, j;
  	char terrain;
  	int layer, layerData;
  	int depth = 0;
  	int sign = 1;
  	int low, high;
  
  	if((lowDepth == 0) && (highDepth == 0))
  		return;
  
  	low = MIN(abs(lowDepth), abs(highDepth));
  	high = MAX(abs(lowDepth), abs(highDepth));
  
  	if((lowDepth < 0) || (highDepth < 0))
  		sign = -1;
  
  	for(i = 0; i < map->map_width; i++) {
  		for(j = 0; j < map->map_height; j++) {
  			terrain = GetHexTerrain(map, i, j);
  
  			switch (terrain) {
  			case BRIDGE:
  			case FIRE:
  			case WATER:
  			case ICE:
  				continue;
  				break;
  			}
  
  			depth = Number(low, high) * sign;
  
  			if(depth == 0)
  				continue;
  
  			layerData = GetHexLayerData(map, i, j);
  
  			if(depth < 0) {
  				if(!(HexHasSnow(map, i, j) || HexHasDeepSnow(map, i, j)))
  					continue;
  			} else {
  				if(!(HexHasSnow(map, i, j) && HexHasDeepSnow(map, i, j)))
  					SetHexLayers(map, i, j, HEXLAYER_SNOW);
  			}
  
  			SetHexLayerData(map, i, j, (layerData + depth));
  			validateSnowDepth(map, i, j);
  		}
  	}
  
  }
  