~proyvind/doonlunacy/od2

/* OD2 - Dune II Clone
 *  
 * Copyright (C) 2009 Robert Crossfield		<robert.crossfield@strobs.com>

 * This program 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, either version 3 of the License, or
 * (at your option) any later version.

 * This program 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.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *  
 * 
 * $Id$
 * 
 */

#include "stdafx.h"
#include "od2.h"
#include "gui.h"
#include "screenPlayfield.h"
#include "engine/objects/object.h"
#include "engine/objects/mapCell.h"
#include "engine/objects/unit.h"
#include "engine/objects/structure.h"

#include "engine/scenario.h"
#include "engine/screen.h"
#include "engine/house.h"

#include "engine/sidebar/sidebar.h"
#include "engine/sidebar/sidebarAction.h"
#include "engine/sidebar/sidebarStructurePlace.h"

#include "map.h"
#include "minimap.h"

#include "engine/mapCellAnimSingle.h"

cScreenPlayfield::cScreenPlayfield(cOD2 *pEngine, cInterface< cOD2 > *pParent) : cButton<cOD2>(pEngine, pParent, UPoint(240, 160)), _scale(engineGet()->resourcesGet()->getMapScale(engineGet()->scenarioGet()->mapScaleLevelGet())) {
    word Tactical = engineGet()->scenarioGet()->mapTacticalGet();

    _map = engineGet()->scenarioGet()->mapGet()->posFromIndex(Tactical);

    _mapCell = engineGet()->scenarioGet()->mapGet()->mapCellGet(engineGet()->scenarioGet()->mapCursorGet());

    _surfaceFog			= new cVideoSurface(_size);
    _surfaceLandscape	= new cVideoSurface(_size);
    _surfaceUnits		= new cVideoSurface(_size);
    _surfaceCellAnims	= new cVideoSurface(_size);
    _surfaceTileHighlight = 0;

    _landscapeRedraw = true;

    _surfaceUnits->colorKeySet(0xFF);
}

cScreenPlayfield::~cScreenPlayfield() {

    delete _surfaceFog;
    delete _surfaceLandscape;
    delete _surfaceUnits;
    delete _surfaceTileHighlight;
    delete _surfaceCellAnims;
}

void cScreenPlayfield::screenPrep() {
    // Select the structure
    if((*_mapCell)->hasStructure())
	engineGet()->screenGet()->sidebarGet()->selectStructure((cStructure*) (*_mapCell)->objectGet());
}

void cScreenPlayfield::drawLandscape() {
    UPoint	tilesMax = engineGet()->screenGet()->getScreenTilesMax();
    uint16_t	tilesY = engineGet()->screenGet()->getScreenTilesY();
    word		  mapIndex	= 0;
    cMapCell	**mapCell;

    // Update the drawn X/Y
    _landscape = _map;

    // Calculate the top-left index
    mapIndex = engineGet()->scenarioGet()->mapGet()->posToIndex(_map);

    // Loop for each tile of the visible playfield
    for(UPoint p(0,0); p.y < tilesMax.y; ++p.y, mapIndex += 0x40) {

	// Get pointer to tiles
	mapCell = engineGet()->scenarioGet()->mapGet()->mapCellGet(mapIndex);

	for(p.x = 0; p.x < tilesMax.x; ++p.x) {

	    // FIXME: Error out here?
	    if(!mapCell)
		break;

	    // Draw tile to playfield
	    SDL_Surface *tile = *engineGet()->resourcesGet()->mapTileGet((*mapCell)->tileGet());

	    // If there is an object at this tile, use the house palette to draw the tile
	    if((*mapCell)->objectGet())
		SDL_SetColors(tile, (*mapCell)->objectGet()->houseGet()->paletteGet()->colors, 0, (*mapCell)->objectGet()->houseGet()->paletteGet()->ncolors);

	    // Draw the tile
	    _surfaceLandscape->surfacePut(tile, p<<4);

	    // Draw any temp tile or overlay
	    if((*mapCell)->tileTmpGet() != 0xFFFFFFFF) {

		tile = *engineGet()->resourcesGet()->mapTileGet((*mapCell)->tileTmpGet());

		if((*mapCell)->tmpHouseGet())
		    SDL_SetColors(tile, (*mapCell)->tmpHouseGet()->paletteGet()->colors, 0, (*mapCell)->tmpHouseGet()->paletteGet()->ncolors);

		SDL_SetColorKey(tile, SDL_SRCCOLORKEY|SDL_RLEACCEL, SDL_MapRGB(tile->format, 0,0,0));
		_surfaceLandscape->surfacePut(tile, p<<4);

	    }

	    mapCell++;
	}
    }

}

void cScreenPlayfield::drawUnit(cUnit *pUnit) {
    UPoint p;
    pUnit->objectXYGet(p);

    p -= _map;

    p <<= 4;

    p += (pUnit->getMapTile() & 0xFF) >> 4;

    pUnit->draw();
    p -= 20;
    _surfaceUnits->surfacePut(pUnit->surfaceGet(), p);
}

void cScreenPlayfield::drawObjects() {
    map< uint32_t, cUnit* >			 *units = engineGet()->unitsGet();
    map< uint32_t, cUnit* >::iterator  unitIT;

    _surfaceUnits->clear(0xFF);

    for(unitIT = units->begin(); unitIT != units->end(); ++unitIT) {
	if(unitIT->second->dataGet()->movementType == _UnitMovement_Flying)
	    continue;

	if(unitIT->second->isInPlayfield() && !unitIT->second->deleteGet())
	    drawUnit(unitIT->second);

    }

    for(unitIT = units->begin(); unitIT != units->end(); ++unitIT) {
	if(unitIT->second->dataGet()->movementType != _UnitMovement_Flying)
	    continue;

	if(unitIT->second->isInPlayfield() && !unitIT->second->deleteGet())
	    drawUnit(unitIT->second);

    }
}

void cScreenPlayfield::drawMapCellAnims() {
    UPoint	tilesMax = engineGet()->screenGet()->getScreenTilesMax();
    uint16_t	tilesY = engineGet()->screenGet()->getScreenTilesY();
    word		  mapIndex	= 0;
    cMapCellAnimSingle *anim = 0;

    // Calculate the top-left index
    mapIndex = engineGet()->scenarioGet()->mapGet()->posToIndex(_landscape);

    _surfaceCellAnims->clear(0xFF);
    _surfaceCellAnims->colorKeySet(0xFF);

    // Loop for each tile of the visible playfield
    for(UPoint p(0,0); p.y < tilesMax.y; ++p.y, mapIndex += 0x40) {

	for(p.x = 0; p.x < tilesMax.x; ++p.x) {

	    anim = engineGet()->mapCellAnimGet(mapIndex + p.x);
	    if(anim) {
		_surfaceCellAnims->surfacePut(*engineGet()->resourcesGet()->shpGet(anim->shpGet(), 0), p<<4);
	    }

	}

    }


}

void cScreenPlayfield::drawFog() {
    UPoint	tilesMax = engineGet()->screenGet()->getScreenTilesMax();
    uint16_t	tilesY = engineGet()->screenGet()->getScreenTilesY();
    word		  mapIndex	= 0;
    cMapCell	**mapCell;

    // Calculate the top-left index
    mapIndex = engineGet()->scenarioGet()->mapGet()->posToIndex(_landscape);

    _surfaceFog->clear(0xFF);
    _surfaceFog->colorKeySet(0xFF);

    // Loop for each tile of the visible playfield
    for(UPoint p(0,0); p.y < tilesMax.y; ++p.y, mapIndex += 0x40) {

	// Get pointer to tiles
	mapCell = engineGet()->scenarioGet()->mapGet()->mapCellGet(mapIndex);

	for(p.x = 0; p.x < tilesMax.x; ++p.x) {
	    SDL_Surface *tileOverlay = *engineGet()->resourcesGet()->mapTileGet((*mapCell)->fogWarGet());

	    if(((*mapCell++)->isRevealed()))
		continue;

	    SDL_SetColorKey(tileOverlay, SDL_RLEACCEL, SDL_MapRGB(tileOverlay->format, 255,0,255));

	    _surfaceFog->surfacePut(tileOverlay, p<<4);
	}
    }
}

void cScreenPlayfield::draw() {

    // Does the landscape surface need updating?
    if(_landscapeRedraw || _landscape != _map)
	drawLandscape();

    //
    drawMapCellAnims();
    drawObjects();
    drawFog();

    surfaceGet()->surfacePut(_surfaceLandscape);
    surfaceGet()->surfacePut(_surfaceUnits);

    surfaceGet()->surfacePut(_surfaceCellAnims);
    surfaceGet()->surfacePut(_surfaceFog);

    if(!(*_mapCell)->hasStructure())
	return;

    drawTileSquares((*_mapCell)->getMapIndex(), (cStructure*) (*_mapCell)->objectGet());
}

void cScreenPlayfield::drawTileSquares(word pMapIndex, cStructure *pStructure) {
    cStructure  *structure  = 0;
    UPoint	size(1,1);

    cMapCell **mapCell = engineGet()->scenarioGet()->mapGet()->mapCellGet(pMapIndex);

    // Get top-left
    if((*mapCell)->objectGet())
	mapCell = ((cStructure*) (*mapCell)->objectGet())->mapCellGet();

    if((*mapCell)->getMapIndex() != 0xFFFF) 
	pMapIndex = (*mapCell)->getMapIndex();

    // Get the number of tiles and the layout
    uint16_t   foundationTiles	= engineGet()->resourcesGet()->foundationSizeGet(pStructure->dataGet()->foundationSize);
    const std::vector<uint16_t> &layoutTile = engineGet()->resourcesGet()->getLayoutTiles(pStructure->dataGet()->foundationSize);

    for(std::vector<uint16_t>::const_iterator layout = layoutTile.begin(); foundationTiles--; ++layout) {
	if((*layout & 0xC0) && !(*layout & 0x03))
	    size.y++;

	// Across but not down
	if((!(*layout & 0xC0) && *layout & 0x03))
	    size.x++;
    }

    // Draw a rectangle
    drawTileSquare(size * 16);

    // Calcualte the screen X/Y of the top-left of the structure
    UPoint p = engineGet()->scenarioGet()->mapGet()->posFromIndex(pMapIndex) - _map;

    // Draw the rectangle to the surface
    surfaceGet()->surfacePut(_surfaceTileHighlight, p<<4);
}

void cScreenPlayfield::drawTileSquare(UPoint pMap) {
    dword	White = SDL_MapRGB(static_cast<SDL_Surface*>(surfaceSDLGet())->format, 255, 255, 255);
    dword	Black = SDL_MapRGB(static_cast<SDL_Surface*>(surfaceSDLGet())->format, 0, 0, 0);

    //FIXME: destructor is fscked...
    //delete _surfaceTileHighlight;
    _surfaceTileHighlight = new cVideoSurface(pMap);

    _surfaceTileHighlight->colorKeySet(0);
    _surfaceTileHighlight->clear(0);

    SDL_Rect dstRect;
    dstRect.x = 0;
    dstRect.y = 0;
    dstRect.w = pMap.x;
    dstRect.h = pMap.y;
    SDL_FillRect(_surfaceTileHighlight->surfaceGet(), &dstRect, White);

    dstRect.x = 1;
    dstRect.y = 1;
    dstRect.w = pMap.x - 2;
    dstRect.h = pMap.y - 2;
    SDL_FillRect(_surfaceTileHighlight->surfaceGet(), &dstRect, Black);
}

void cScreenPlayfield::buttonClear() {

}

void cScreenPlayfield::buttonPressLeft(UPoint p) {
    cMapCell				**mapCell = 0;
    cSidebarAction			 *action = 0;

    // Convert screen X/Y into Tiles position
    p >>= 4;

    // Get the map cell for the position we have clicked
    mapCell = engineGet()->scenarioGet()->mapGet()->mapCellGet(_map + p);

    // Is the user executing a unit action?
    action = engineGet()->screenGet()->sidebarGet()->selectedActionGet();

    if(action) {
	action->actionExecute((*mapCell));
	return;
    }

    if(engineGet()->screenGet()->sidebarGet()->structurePlaceGet()) {
	engineGet()->screenGet()->sidebarGet()->structurePlaceGet()->placeStructure(mapCell);
	return;
    }

    if(engineGet()->screenGet()->sidebarGet()->selectedUnitGet())
	engineGet()->screenGet()->sidebarGet()->selectUnit(0);

    if(engineGet()->screenGet()->sidebarGet()->selectedStructGet()) 
	engineGet()->screenGet()->sidebarGet()->selectStructure(0);

    // Deactive the current map cell
    (*_mapCell)->objectDeActivate();

    //if((*mapCell)->isEmpty())
    _mapCell = mapCell;

    // Activate the map cell
    (*_mapCell)->objectActivate();	
}

void cScreenPlayfield::buttonPressRight(UPoint p) {

}
void cScreenPlayfield::buttonReleaseLeft(UPoint p) {

}

void cScreenPlayfield::buttonReleaseRight(UPoint p) {
    cSidebarStructurePlace *structPlace = engineGet()->screenGet()->sidebarGet()->structurePlaceGet();

    if(structPlace) {
	engineGet()->screenGet()->sidebarGet()->structurePlaceSet(0);
	delete structPlace;
    }

}

bool cScreenPlayfield::scrollCheck(UPoint p) {
    UPoint	tilesMax = engineGet()->screenGet()->getScreenTilesMax();

    // Get mouse column/row
    p /= 2;

    // Left of play field
    if(p.x < 1)
	if(_map.x > _scale.x) {
	    --_map.x;
	    redrawSet();
	}

    // Top of playfield
    if(p.y < 1)
	if(_map.y > _scale.y) {
	    --_map.y;
	    redrawSet();
	}

    // Right of playfield
    if(p.x > 118)
	if(_map.x < _scale.w + _scale.x - tilesMax.x) {
	    _map.x++;
	    redrawSet();
	}

    // Bottom of playfield
    if(p.y > 78)
	if(_map.y < _scale.h + _scale.y - tilesMax.y) {
	    _map.y++;
	    redrawSet();
	}

    // If we have to redraw the screen now, the minimaps frame position will need updating
    if(redrawGet())
	((cMinimap*) engineGet()->screenGet()->sidebarGet()->minimapGet())->positionUpdate();

    return true;
}

bool cScreenPlayfield::mouseMove(UPoint p) {

    scrollCheck(p);

    p /= 16;

    if(engineGet()->screenGet()->sidebarGet()->structurePlaceGet()) {

	word mapIndex = engineGet()->scenarioGet()->mapGet()->posToIndex(_map + p);

	draw();
	drawTileSquares(mapIndex, (cStructure*) engineGet()->screenGet()->sidebarGet()->structurePlaceGet()->structureGet()->objectHoldGet());
	redrawSet(false);
    }

    return true;
}