src/hcode/btech/map.weather.c

Go to the documentation of this file.

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

}

---