/*
 * $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);
		}
	}

}