ToolStroke.java

Go to the documentation of this file.

// This file is part of MicropolisJ.
// Copyright (C) 2013 Jason Long
// Portions Copyright (C) 1989-2007 Electronic Arts Inc.
//
// MicropolisJ is free software; you can redistribute it and/or modify
// it under the terms of the GNU GPLv3, with additional terms.
// See the README file, included in this distribution, for details.

package micropolisj.engine;

import java.io.Serializable;

import javax.swing.JOptionPane;

import static micropolisj.engine.TileConstants.*;
import micropolisj.research.ResearchState;
import micropolisj.util.Utilities;

public class ToolStroke implements Serializable {
    transient Micropolis city;

    final MicropolisTool tool;
    int xpos;
    int ypos;
    int xdest;
    int ydest;
    boolean inPreview;
    int playerID;

    public ToolStroke(Micropolis city, MicropolisTool tool, int xpos, int ypos) {
        this.city = city;
        this.tool = tool;
        this.xpos = xpos;
        this.ypos = ypos;
        this.xdest = xpos;
        this.ydest = ypos;
        playerID = city.getPlayerID();
        // System.out.println(playerID);
    }

    public void setCity(Micropolis engine) {
        city = engine;
    }

    public final ToolPreview getPreview() {
        ToolEffect eff = new ToolEffect(city, playerID);
        inPreview = true;
        try {
            applyArea(eff);
        } finally {
            inPreview = false;
        }
        return eff.preview;
    }

    public final ToolResult apply() {
        ToolEffect eff = new ToolEffect(city, playerID);
        applyArea(eff);
        return eff.apply(playerID);
    }
    
    protected void applyArea(ToolEffectIfc eff) {
        CityRect r = getBounds();

        for (int i = 0; i < r.height; i += tool.getHeight()) {
            for (int j = 0; j < r.width; j += tool.getWidth()) {
                apply1(new TranslatedToolEffect(eff, r.x + j, r.y + i));
            }
        }
    }

    
    boolean apply1(ToolEffectIfc eff) {
        switch (tool) {
        case PARK:
            return applyParkTool(eff);

        case RESIDENTIAL:
            return applyZone(eff, RESCLR);

        case COMMERCIAL:
            return applyZone(eff, COMCLR);

        case INDUSTRIAL:
            return applyZone(eff, INDCLR);

        case FIRE:
            return applyZone(eff, FIRESTATION);

        case POLICE:
            return applyZone(eff, POLICESTATION);

        case POWERPLANT:
            return applyZone(eff, POWERPLANT);

        case STADIUM:
            return applyZone(eff, STADIUM);

        case SEAPORT:
            return applyZone(eff, PORT);

        case NUCLEAR:
            return applyZone(eff, NUCLEAR);

        case AIRPORT:
            return applyZone(eff, AIRPORT);

            // CUSTOM TOOLS
        case UNIVERSITY:
            return applyZone(eff, UNIVERSITY);
            
        case TEMPEL:
            return applyZone(eff, TEMPEL);

        case ROCKET:
            //TODO: fireMessage insufficient funds
            if (city.getPlayerInfo(playerID).researchData.isRocketPossible()) {
                // shoot rocket (aka monster) to location
                if(city.getPlayerInfo(playerID).budget.totalFunds < MicropolisTool.ROCKET.getToolCost()) {
                    eff.toolResult(ToolResult.INSUFFICIENT_FUNDS);
                    city.sendMessage(MicropolisMessage.INSUFFICIENT_FUNDS);
                } else {
                    city.generateRocket(0, 0, xpos, ypos, playerID);
                    city.spend(MicropolisTool.ROCKET.getToolCost(), city.getPlayerInfo(playerID));
                    eff.toolResult(ToolResult.SUCCESS);
                    return true;
                }
            } else {
                //JOptionPane.showMessageDialog(ResearchState.getInstance(), "You need some research before you can use rockets.");
                city.sendMessage(MicropolisMessage.INSUFFICIENT_RESEARCH);
            }
            return false;

        default:
            // not expected
            throw new Error("unexpected tool: " + tool);
        }
    }

    public void dragTo(int xdest, int ydest) {
        this.xdest = xdest;
        this.ydest = ydest;
    }

    public CityRect getBounds() {
        CityRect r = new CityRect();

        r.x = xpos;
        if (tool.getWidth() >= 3) {
            r.x--;
        }
        if (xdest >= xpos) {
            r.width = ((xdest - xpos) / tool.getWidth() + 1) * tool.getWidth();
        } else {
            r.width = ((xpos - xdest) / tool.getWidth() + 1) * tool.getHeight();
            r.x += tool.getWidth() - r.width;
        }

        r.y = ypos;
        if (tool.getHeight() >= 3) {
            r.y--;
        }
        if (ydest >= ypos) {
            r.height = ((ydest - ypos) / tool.getHeight() + 1) * tool.getHeight();
        } else {
            r.height = ((ypos - ydest) / tool.getHeight() + 1) * tool.getHeight();
            r.y += tool.getHeight() - r.height;
        }

        return r;
    }

    public CityLocation getLocation() {
        return new CityLocation(xpos, ypos);
    }

    
    boolean applyZone(ToolEffectIfc eff, int base) {
        assert isZoneCenter(base);

        TileSpec.BuildingInfo bi = Tiles.get(base).getBuildingInfo();
        if (bi == null) {
            throw new Error("Cannot applyZone to #" + base);
        }

        int cost = tool.getToolCost();
        boolean canBuild = true;
        for (int rowNum = 0; rowNum < bi.height; rowNum++) {
            for (int columnNum = 0; columnNum < bi.width; columnNum++) {
                int tileValue = eff.getTile(columnNum, rowNum);
                tileValue = tileValue & LOMASK;

                if (tileValue != DIRT) {
                    if (city.autoBulldoze && canAutoBulldozeZ((char) tileValue)) {
                        cost++;
                    } else {
                        canBuild = false;
                    }
                }
            }
        }
        if (!canBuild) {
            eff.toolResult(ToolResult.UH_OH);
            return false;
        }

        eff.spend(cost);

        int i = 0;
        for (int rowNum = 0; rowNum < bi.height; rowNum++) {
            for (int columnNum = 0; columnNum < bi.width; columnNum++) {
                eff.setTile(columnNum, rowNum, bi.members[i]);
                i++;
            }
        }

        fixBorder(eff, bi.width, bi.height);
        return true;
    }

    // compatible function
    void fixBorder(int left, int top, int right, int bottom) {
        ToolEffect eff = new ToolEffect(city, left, top, playerID);
        fixBorder(eff, right + 1 - left, bottom + 1 - top);
        eff.apply(playerID);
    }

    void fixBorder(ToolEffectIfc eff, int width, int height) {
        for (int x = 0; x < width; x++) {
            fixZone(new TranslatedToolEffect(eff, x, 0));
            fixZone(new TranslatedToolEffect(eff, x, height - 1));
        }
        for (int y = 1; y < height - 1; y++) {
            fixZone(new TranslatedToolEffect(eff, 0, y));
            fixZone(new TranslatedToolEffect(eff, width - 1, y));
        }
    }

    boolean applyParkTool(ToolEffectIfc eff) {
        int cost = tool.getToolCost();

        if (eff.getTile(0, 0) != DIRT) {
            // some sort of bulldozing is necessary
            if (!city.autoBulldoze) {
                eff.toolResult(ToolResult.UH_OH);
                return false;
            }

            // FIXME- use a canAutoBulldoze-style function here
            if (isRubble(eff.getTile(0, 0))) {
                // this tile can be auto-bulldozed
                cost++;
            } else {
                // cannot be auto-bulldozed
                eff.toolResult(ToolResult.UH_OH);
                return false;
            }
        }

        int z = inPreview ? 0 : city.PRNG.nextInt(5);
        int tile;
        if (z < 4) {
            tile = WOODS2 + z;
        } else {
            tile = FOUNTAIN;
        }

        eff.spend(cost);
        eff.setTile(0, 0, tile);

        return true;
    }

    protected void fixZone(int xpos, int ypos) {
        ToolEffect eff = new ToolEffect(city, xpos, ypos, playerID);
        fixZone(eff);
        eff.apply(playerID);
    }

    protected void fixZone(ToolEffectIfc eff) {
        fixSingle(eff);

        // "fix" the cells to the north, west, east, and south
        fixSingle(new TranslatedToolEffect(eff, 0, -1));
        fixSingle(new TranslatedToolEffect(eff, -1, 0));
        fixSingle(new TranslatedToolEffect(eff, 1, 0));
        fixSingle(new TranslatedToolEffect(eff, 0, 1));
    }

    private void fixSingle(ToolEffectIfc eff) {
        int tile = eff.getTile(0, 0);

        if (isRoadDynamic(tile)) {
            // cleanup road
            int adjTile = 0;

            // check road to north
            if (roadConnectsSouth(eff.getTile(0, -1))) {
                adjTile |= 1;
            }

            // check road to east
            if (roadConnectsWest(eff.getTile(1, 0))) {
                adjTile |= 2;
            }

            // check road to south
            if (roadConnectsNorth(eff.getTile(0, 1))) {
                adjTile |= 4;
            }

            // check road to west
            if (roadConnectsEast(eff.getTile(-1, 0))) {
                adjTile |= 8;
            }

            eff.setTile(0, 0, RoadTable[adjTile]);
        } // endif on a road tile

        else if (isRailDynamic(tile)) {
            // cleanup Rail
            int adjTile = 0;

            // check rail to north
            if (railConnectsSouth(eff.getTile(0, -1))) {
                adjTile |= 1;
            }

            // check rail to east
            if (railConnectsWest(eff.getTile(1, 0))) {
                adjTile |= 2;
            }

            // check rail to south
            if (railConnectsNorth(eff.getTile(0, 1))) {
                adjTile |= 4;
            }

            // check rail to west
            if (railConnectsEast(eff.getTile(-1, 0))) {
                adjTile |= 8;
            }

            eff.setTile(0, 0, RailTable[adjTile]);
        } // end if on a rail tile

        else if (isWireDynamic(tile)) {
            // Cleanup Wire
            int adjTile = 0;

            // check wire to north
            if (wireConnectsSouth(eff.getTile(0, -1))) {
                adjTile |= 1;
            }

            // check wire to east
            if (wireConnectsWest(eff.getTile(1, 0))) {
                adjTile |= 2;
            }

            // check wire to south
            if (wireConnectsNorth(eff.getTile(0, 1))) {
                adjTile |= 4;
            }

            // check wire to west
            if (wireConnectsEast(eff.getTile(-1, 0))) {
                adjTile |= 8;
            }

            eff.setTile(0, 0, WireTable[adjTile]);
        } // end if on a rail tile

        return;
    }

}