marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/landscape/C4Landscape.cpp

3970 lines
114 KiB
C++
Raw Normal View History

Fix build
2013-03-26 09:57:46 +00:00
/*
Import source
2009-05-08 13:28:41 +00:00
* OpenClonk, http://www.openclonk.org
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* Copyright (c) 1998-2000, Matthes Bender
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2009-2013, The OpenClonk Team and contributors
Import source
2009-05-08 13:28:41 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
Import source
2009-05-08 13:28:41 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
Import source
2009-05-08 13:28:41 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* To redistribute this file separately, substitute the full license texts
* for the above references.
Import source
2009-05-08 13:28:41 +00:00
*/
/* Handles landscape and sky */
#include <C4Include.h>
#include <C4Landscape.h>
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
Replace some usages of C4ID with C4Def* In particular those that made the c4script shell depend on C4Id.cpp.
2013-03-03 18:25:18 +00:00
#include <C4DefList.h>
Import source
2009-05-08 13:28:41 +00:00
#include <C4SolidMask.h>
Remove C4Wrappers and put most functions in relevant headers This also removes the TickXXX #defines and moves the lookup of predefined materials to C4Material.
2009-06-12 18:52:21 +00:00
#include <C4Game.h>
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
#include <C4Group.h>
Import source
2009-05-08 13:28:41 +00:00
#include <C4Map.h>
#include <C4MapCreatorS2.h>
#include <C4SolidMask.h>
#include <C4Object.h>
#include <C4Physics.h>
#include <C4Random.h>
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
#include <C4Surface.h>
Import source
2009-05-08 13:28:41 +00:00
#include <C4ToolsDlg.h>
#include <C4Record.h>
#include <C4Material.h>
Move Game.Messages to ::Messages
2009-06-05 18:12:43 +00:00
#include <C4GameMessage.h>
Import source
2009-05-08 13:28:41 +00:00
#include <C4Application.h>
Remove C4Wrappers and put most functions in relevant headers This also removes the TickXXX #defines and moves the lookup of predefined materials to C4Material.
2009-06-12 18:52:21 +00:00
#include <C4Log.h>
Import source
2009-05-08 13:28:41 +00:00
#include <C4Stat.h>
Header reorganisation Lots of #includes are moved from C4Game.h to the files that actually need them
2009-06-05 18:00:23 +00:00
#include <C4MassMover.h>
#include <C4PXS.h>
Move Game.Weather to ::Weather
2009-06-11 19:59:35 +00:00
#include <C4Weather.h>
Remove C4Wrappers and put most functions in relevant headers This also removes the TickXXX #defines and moves the lookup of predefined materials to C4Material.
2009-06-12 18:52:21 +00:00
#include <C4GraphicsResource.h>
#include <C4GraphicsSystem.h>
#include <C4Texture.h>
Move Game.Control to ::Control
2009-06-15 22:06:37 +00:00
#include <C4Record.h>
Reorder engine source file organization a bit This mostly consists of flattening the hierarchy, splitting the graphics stuff out of platform, and a few smaller cleanups.
2012-04-27 17:04:43 +00:00
#include <CSurface8.h>
Import source
2009-05-08 13:28:41 +00:00
#include <StdPNG.h>
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
#include <C4MaterialList.h>
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
#include <C4LandscapeRender.h>
#include <C4FoW.h>
Auto-collect fragile objects (i.e.: Firestones) when digging. See http://www.clonkspot.org/comic/1
2013-02-20 20:12:31 +00:00
#include <C4FindObject.h>
#include <C4GameObjects.h>
Added support for scripted maps (Map.c) and documentation.
2013-03-18 23:35:00 +00:00
#include <C4MapScript.h>
Import source
2009-05-08 13:28:41 +00:00
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
namespace
{
bool ForLine(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
std::function<bool(int32_t, int32_t)> fnCallback,
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
int32_t *lastx = 0, int32_t *lasty = 0)
{
int d, dx, dy, aincr, bincr, xincr, yincr, x, y;
if (Abs(x2 - x1)<Abs(y2 - y1))
{
if (y1>y2) { Swap(x1, x2); Swap(y1, y2); }
xincr = (x2>x1) ? 1 : -1;
dy = y2 - y1; dx = Abs(x2 - x1);
d = 2 * dx - dy; aincr = 2 * (dx - dy); bincr = 2 * dx; x = x1; y = y1;
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
if (!fnCallback(x, y))
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
{
if (lastx) *lastx = x; if (lasty) *lasty = y;
return false;
}
for (y = y1 + 1; y <= y2; ++y)
{
if (d >= 0) { x += xincr; d += aincr; }
else d += bincr;
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
if (!fnCallback(x, y))
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
{
if (lastx) *lastx = x; if (lasty) *lasty = y;
return false;
}
}
}
else
{
if (x1>x2) { Swap(x1, x2); Swap(y1, y2); }
yincr = (y2>y1) ? 1 : -1;
dx = x2 - x1; dy = Abs(y2 - y1);
d = 2 * dy - dx; aincr = 2 * (dy - dx); bincr = 2 * dy; x = x1; y = y1;
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
if (!fnCallback(x, y))
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
{
if (lastx) *lastx = x; if (lasty) *lasty = y;
return false;
}
for (x = x1 + 1; x <= x2; ++x)
{
if (d >= 0) { y += yincr; d += aincr; }
else d += bincr;
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
if (!fnCallback(x, y))
Move ForLine function into C4Landscape.cpp C4Landscape is the sole consumer of this function, so there's no reason to make it available outside.
2015-02-23 11:33:53 +00:00
{
if (lastx) *lastx = x; if (lasty) *lasty = y;
return false;
}
}
}
return true;
}
}
Import source
2009-05-08 13:28:41 +00:00
C4Landscape::C4Landscape()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
Default();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
C4Landscape::~C4Landscape()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
Clear();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++ Execute and display +++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::Execute()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Landscape scan
Import source
2009-05-08 13:28:41 +00:00
if (!NoScan)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
ExecuteScan();
Import source
2009-05-08 13:28:41 +00:00
// move sky
Sky.Execute();
Remove a lot of disabled legacy code, round 2 Maybe at some point we'll be rid of all the commented-out code that nobody has looked at in years.
2015-03-25 18:04:04 +00:00
Explain the one-second relights in a comment Should make it a bit quicker for the next person to figure out what is going on there...
2014-11-18 19:40:44 +00:00
// Queued Relights -- note that normally we process them before drawing every frame;
// this just makes sure relights don't accumulate over a long period of time if no
// viewport is open (developer mode).
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!::Game.iTick35)
Import source
2009-05-08 13:28:41 +00:00
DoRelights();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::ExecuteScan()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t cy,mat;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check: Scan needed?
Move Game.Weather to ::Weather
2009-06-11 19:59:35 +00:00
const int32_t iTemperature = ::Weather.GetTemperature();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (mat = 0; mat < ::MaterialMap.Num; mat++)
if (MatCount[mat])
{
if (::MaterialMap.Map[mat].BelowTempConvertTo &&
iTemperature < ::MaterialMap.Map[mat].BelowTempConvert)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
break;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
else if (::MaterialMap.Map[mat].AboveTempConvertTo &&
iTemperature > ::MaterialMap.Map[mat].AboveTempConvert)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
break;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
if (mat >= ::MaterialMap.Num)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return;
Import source
2009-05-08 13:28:41 +00:00
#ifdef DEBUGREC_MATSCAN
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
if (Config.General.DebugRec)
AddDbgRec(RCT_MatScan, &ScanX, sizeof(ScanX));
Import source
2009-05-08 13:28:41 +00:00
#endif
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
for (int32_t cnt=0; cnt<ScanSpeed; cnt++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Scan landscape column: sectors down
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
int32_t last_mat = -1;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
for (cy=0; cy<Height; cy++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
mat=_GetMat(ScanX, cy);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
// material change?
if (last_mat != mat)
{
// upwards
if (last_mat != -1)
DoScan(ScanX, cy-1, last_mat, 1);
// downwards
if (mat != -1)
cy += DoScan(ScanX, cy, mat, 0);
}
last_mat = mat;
}
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Scan advance & rewind
ScanX++;
if (ScanX>=Width)
ScanX=0;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
#define PRETTY_TEMP_CONV
int32_t C4Landscape::DoScan(int32_t cx, int32_t cy, int32_t mat, int32_t dir)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t conv_to_tex = 0;
Move Game.Weather to ::Weather
2009-06-11 19:59:35 +00:00
int32_t iTemperature = ::Weather.GetTemperature();
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check below conv
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (::MaterialMap.Map[mat].BelowTempConvertDir == dir)
Move Game.Material to ::MaterialMap
2009-06-05 18:46:03 +00:00
if (::MaterialMap.Map[mat].BelowTempConvertTo)
if (iTemperature< ::MaterialMap.Map[mat].BelowTempConvert)
conv_to_tex=::MaterialMap.Map[mat].BelowTempConvertTo;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check above conv
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (::MaterialMap.Map[mat].AboveTempConvertDir == dir)
Move Game.Material to ::MaterialMap
2009-06-05 18:46:03 +00:00
if (::MaterialMap.Map[mat].AboveTempConvertTo)
if (iTemperature>::MaterialMap.Map[mat].AboveTempConvert)
conv_to_tex=::MaterialMap.Map[mat].AboveTempConvertTo;
Import source
2009-05-08 13:28:41 +00:00
// nothing to do?
if (!conv_to_tex) return 0;
// find material
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
int32_t conv_to = ::TextureMap.GetEntry(conv_to_tex)->GetMaterialIndex();
Import source
2009-05-08 13:28:41 +00:00
// find mat top
Move Game.Material to ::MaterialMap
2009-06-05 18:46:03 +00:00
int32_t mconv = ::MaterialMap.Map[mat].TempConvStrength,
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
mconvs = mconv;
Import source
2009-05-08 13:28:41 +00:00
#ifdef DEBUGREC_MATSCAN
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
if (Config.General.DebugRec)
{
C4RCMatScan rc = { cx, cy, mat, conv_to, dir, mconvs };
AddDbgRec(RCT_MatScanDo, &rc, sizeof(C4RCMatScan));
}
Import source
2009-05-08 13:28:41 +00:00
#endif
int32_t ydir = (dir == 0 ? +1 : -1), cy2;
#ifdef PRETTY_TEMP_CONV
// get left pixel
int32_t lmat = (cx > 0 ? _GetMat(cx-1, cy) : -1);
// left pixel not converted? do nothing
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (lmat == mat) return 0;
Import source
2009-05-08 13:28:41 +00:00
// left pixel converted? suppose it was done by a prior scan and skip check
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (lmat != conv_to)
Import source
2009-05-08 13:28:41 +00:00
{
int32_t iSearchRange = Max<int32_t>(5, mconvs);
// search upper/lower bound
int32_t cys = cy, cxs = cx;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
while (cxs < GBackWdt-1)
Import source
2009-05-08 13:28:41 +00:00
{
// one step right
cxs++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (_GetMat(cxs, cys) == mat)
Import source
2009-05-08 13:28:41 +00:00
{
// search surface
cys -= ydir;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
while (Inside<int32_t>(cys, 0, GBackHgt-1) && _GetMat(cxs, cys) == mat)
Import source
2009-05-08 13:28:41 +00:00
{
cys -= ydir;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if ((mconvs = Min(mconv - Abs(cys - cy), mconvs)) < 0)
Import source
2009-05-08 13:28:41 +00:00
return 0;
}
// out of bounds?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (!Inside<int32_t>(cys, 0, GBackHgt-1)) break;
Import source
2009-05-08 13:28:41 +00:00
// back one step
cys += ydir;
}
else
{
// search surface
cys += ydir;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
while (Inside<int32_t>(cys, 0, GBackHgt-1) && _GetMat(cxs, cys) != mat)
Import source
2009-05-08 13:28:41 +00:00
{
cys += ydir;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (Abs(cys - cy) > iSearchRange)
Import source
2009-05-08 13:28:41 +00:00
break;
}
// out of bounds?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (!Inside<int32_t>(cys, 0, GBackHgt-1)) break;
if (Abs(cys - cy) > iSearchRange) break;
Import source
2009-05-08 13:28:41 +00:00
}
}
}
#endif
// Conversion
Do not check instability when converting material to solid. This fixes ice of frozen lakes immediately crumbling down due to our cool, new anti-single-pixel-code.
2013-03-02 21:25:36 +00:00
bool conv_to_is_solid = (conv_to>-1) && DensitySolid(::MaterialMap.Map[conv_to].Density);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (cy2 = cy; mconvs >= 0 && Inside<int32_t>(cy2, 0, GBackHgt-1); cy2 += ydir, mconvs--)
{
Import source
2009-05-08 13:28:41 +00:00
// material changed?
int32_t pix = _GetPix(cx, cy2);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (PixCol2Mat(pix) != mat) break;
Import source
2009-05-08 13:28:41 +00:00
#ifdef PRETTY_TEMP_CONV
// get left pixel
int32_t lmat = (cx > 0 ? _GetMat(cx-1, cy2) : -1);
// left pixel not converted? break
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (lmat == mat) break;
Import source
2009-05-08 13:28:41 +00:00
#endif
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
// set mat (and keep background material)
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
SetPix2(cx, cy2, MatTex2PixCol(conv_to_tex), Transparent);
Do not check instability when converting material to solid. This fixes ice of frozen lakes immediately crumbling down due to our cool, new anti-single-pixel-code.
2013-03-02 21:25:36 +00:00
if (!conv_to_is_solid) CheckInstabilityRange(cx,cy2);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// return pixel converted
return Abs(cy2 - cy);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::ScanSideOpen()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t cy;
for (cy=0; (cy<Height) && !GetPix(0,cy); cy++) {}
LeftOpen=cy;
for (cy=0; (cy<Height) && !GetPix(Width-1,cy); cy++) {}
RightOpen=cy;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Import source
2009-05-08 13:28:41 +00:00
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
void C4Landscape::Draw(C4TargetFacet &cgo, C4FoWRegion *pLight)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Rename lpDDraw to pDraw
2011-10-03 14:30:18 +00:00
if (Modulation) pDraw->ActivateBlitModulation(Modulation);
Import source
2009-05-08 13:28:41 +00:00
// blit landscape
Add a draw mode which shows the background 8-bit surface
2015-07-15 00:44:11 +00:00
if (::GraphicsSystem.Show8BitSurface == 1)
Rename lpDDraw to pDraw
2011-10-03 14:30:18 +00:00
pDraw->Blit8Fast(Surface8, cgo.TargetX, cgo.TargetY, cgo.Surface, cgo.X,cgo.Y,cgo.Wdt,cgo.Hgt);
Add a draw mode which shows the background 8-bit surface
2015-07-15 00:44:11 +00:00
else if (::GraphicsSystem.Show8BitSurface == 2)
pDraw->Blit8Fast(Surface8Bkg, cgo.TargetX, cgo.TargetY, cgo.Surface, cgo.X,cgo.Y,cgo.Wdt,cgo.Hgt);
Shader landscape rendering, first simple version (scaler, shading)
2011-05-23 23:12:19 +00:00
else if(pLandscapeRender)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Apply landscape re-lighting again in every frame This was accidentally removed in commit 56bdeec5850d396522d7f4d47154eaf945e8c90d. It fixes the landscape being only updated once every second when digging.
2014-11-18 20:03:10 +00:00
DoRelights();
Use full ambient lighting in global viewports This allows to see the whole landscape without any areas covered by FoW in the global viewport. Basically the ambient lighting is set to 1.0 independent of the ambient light map. In the course of this, a second shader for the landscape has been introduced.
2014-12-28 14:07:42 +00:00
pLandscapeRender->Draw(cgo, pLight);
Import source
2009-05-08 13:28:41 +00:00
}
Rename lpDDraw to pDraw
2011-10-03 14:30:18 +00:00
if (Modulation) pDraw->DeactivateBlitModulation();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::DoRelights()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!pLandscapeRender) return true;
for (int32_t i = 0; i < C4LS_MaxRelights; i++)
Import source
2009-05-08 13:28:41 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!Relights[i].Wdt)
break;
// Remove all solid masks in the (twice!) extended region around the change
Fix FoW deinitialization in C4Landscape
2014-11-18 19:41:58 +00:00
// TODO: Isn't Relights[i] already an "affected" rect? Might save a bit here...
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4Rect SolidMaskRect = pLandscapeRender->GetAffectedRect(Relights[i]);
C4SolidMask * pSolid;
for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
pSolid->RemoveTemporary(SolidMaskRect);
// Perform the update
pLandscapeRender->Update(Relights[i], this);
Update ambient map on landscape changes
2014-11-18 20:42:00 +00:00
if (pFoW) pFoW->Ambient.UpdateFromLandscape(*this, Relights[i]);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Restore Solidmasks
for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
pSolid->PutTemporary(SolidMaskRect);
C4SolidMask::CheckConsistency();
// Clear slot
Relights[i].Default();
Import source
2009-05-08 13:28:41 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++ Add and destroy landscape++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
std::vector<int32_t> C4Landscape::GetRoundPolygon(int32_t x, int32_t y, int32_t size, int32_t smoothness) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/*
So what is this? It's basically a circle with the radius 'size'. The radius
is adjusted by two sin/cos waves. The random lies in the phase of the sin/cos
and in the factor the wave is added to the normal circle shape. smoothness from
0 to 100. 0 gives an exagerated 'explosion' shape while 100 is almost a circle
*/
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(smoothness > 100) smoothness = 100;
if(smoothness < 0) smoothness = 0;
if(size <= 0) size = 1;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// vertex count of the polygon
int32_t count = 2*size/3 + 6;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
std::vector<int32_t> vertices;
vertices.reserve(count*2);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// varying phase of the sin/cos waves
C4Real begin = itofix(360)*Random(100)/100;
C4Real begin2 = itofix(360)*Random(100)/100;
// parameters:
// the bigger the factor, the smaller the divergence from a circle
C4Real anticircle = itofix(3)+smoothness/16*smoothness/16;
// the bigger the factor the more random is the divergence from the circle
int random = 80*(200-smoothness);
for(int i=0; i < count; ++i)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4Real angle = itofix(360)*i/count;
C4Real currsize = itofix(size);
currsize += Sin(angle*3 + begin + itofix(Random(random))/100) * size/anticircle; // +sin
currsize += Cos(angle*5 + begin2 + itofix(Random(random))/100) * size/anticircle/2; // +cos
vertices.push_back(x+fixtoi(Sin(angle)*currsize));
vertices.push_back(y-fixtoi(Cos(angle)*currsize));
Import source
2009-05-08 13:28:41 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return vertices;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
std::vector<int32_t> C4Landscape::GetRectangle(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
std::vector<int32_t> vertices;
vertices.resize(8);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
vertices[0] = tx; vertices[1] = ty;
vertices[2] = tx; vertices[3] = ty+hgt;
vertices[4] = tx+wdt; vertices[5] = ty+hgt;
vertices[6] = tx+wdt; vertices[7] = ty;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return vertices;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::ClearFreeRect(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
std::vector<int32_t> vertices(GetRectangle(tx,ty,wdt,hgt));
ForPolygon(&vertices[0],vertices.size()/2,&C4Landscape::ClearPix);
}
Import source
2009-05-08 13:28:41 +00:00
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
int32_t C4Landscape::DigFreeRect(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, C4Object *by_object, bool no_dig2objects, bool no_instability_check)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
std::vector<int32_t> vertices(GetRectangle(tx,ty,wdt,hgt));
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
return DigFreeShape(&vertices[0],vertices.size(),by_object, no_dig2objects, no_instability_check);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
int32_t C4Landscape::DigFree(int32_t tx, int32_t ty, int32_t rad, C4Object *by_object, bool no_dig2objects, bool no_instability_check)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
std::vector<int32_t> vertices(GetRoundPolygon(tx,ty,rad,80));
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
return DigFreeShape(&vertices[0],vertices.size(),by_object, no_dig2objects, no_instability_check);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
void C4Landscape::BlastFree(int32_t tx, int32_t ty, int32_t rad, int32_t caused_by, C4Object *by_object, int32_t iMaxDensity)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
std::vector<int32_t> vertices(GetRoundPolygon(tx,ty,rad,30));
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
BlastFreeShape(&vertices[0],vertices.size(),by_object,caused_by,iMaxDensity);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::ShakeFree(int32_t tx, int32_t ty, int32_t rad)
{
std::vector<int32_t> vertices(GetRoundPolygon(tx,ty,rad,50));
ForPolygon(&vertices[0],vertices.size()/2,&C4Landscape::ShakeFreePix);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
C4ValueArray *C4Landscape::PrepareFreeShape(C4Rect &BoundingBox, C4Object *by_object)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Auto-collect fragile objects (i.e.: Firestones) when digging. See http://www.clonkspot.org/comic/1
2013-02-20 20:12:31 +00:00
// Remember any collectible objects in area
C4FindObjectInRect fo_inrect(BoundingBox);
C4FindObjectOCF fo_collectible(OCF_Carryable);
C4FindObjectOCF fo_insolid(OCF_InSolid);
C4FindObjectLayer fo_layer(by_object ? by_object->Layer : NULL);
C4FindObject *fo_list[] = {&fo_inrect, &fo_collectible, &fo_insolid, &fo_layer};
C4FindObjectAndStatic fo_srch(4, fo_list);
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
return fo_srch.FindMany(::Objects, ::Objects.Sectors);
}
void C4Landscape::PostFreeShape(C4ValueArray *dig_objects, C4Object *by_object)
{
// Do callbacks to digger for objects that are now dug free
if (by_object)
{
for (int32_t i=0; i<dig_objects->GetSize(); ++i)
{
C4Object *dig_object = dig_objects->GetItem(i).getObj();
if (dig_object && !GBackSolid(dig_object->GetX(), dig_object->GetY()))
if (!dig_object->Contained && dig_object->Status)
{
C4AulParSet pars(C4VObj(dig_object));
by_object->Call(PSF_DigOutObject, &pars);
}
}
}
}
int32_t C4Landscape::DigFreeShape(int *vtcs, int length, C4Object *by_object, bool no_dig2objects, bool no_instability_check)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4Rect BoundingBox = getBoundingBox(vtcs,length);
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
int32_t amount;
Import source
2009-05-08 13:28:41 +00:00
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
// Remember any collectible objects in area
std::unique_ptr<C4ValueArray> dig_objects(PrepareFreeShape(BoundingBox, by_object));
Auto-collect fragile objects (i.e.: Firestones) when digging. See http://www.clonkspot.org/comic/1
2013-02-20 20:12:31 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(by_object)
{
if(!by_object->MaterialContents)
by_object->MaterialContents = new C4MaterialList;
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
if (no_instability_check)
amount = ForPolygon(vtcs,length/2,&C4Landscape::DigFreePixNoInstability,by_object->MaterialContents);
else
amount = ForPolygon(vtcs,length/2,&C4Landscape::DigFreePix,by_object->MaterialContents);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
else
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
if (no_instability_check)
amount = ForPolygon(vtcs,length/2,&C4Landscape::DigFreePixNoInstability,NULL);
else
amount = ForPolygon(vtcs,length/2,&C4Landscape::DigFreePix,NULL);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// create objects from the material
if(!::Game.iTick5)
{
no_dig2objects parameter for DigFree / DigFreeRect
2012-04-05 15:49:47 +00:00
if(!no_dig2objects)
if(by_object)
if(by_object->MaterialContents)
{
int32_t tx = BoundingBox.GetMiddleX(), ty = BoundingBox.GetBottom();
DigMaterial2Objects(tx,ty,by_object->MaterialContents, by_object);
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Auto-collect fragile objects (i.e.: Firestones) when digging. See http://www.clonkspot.org/comic/1
2013-02-20 20:12:31 +00:00
// Do callbacks to digger for objects that are now dug free
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
PostFreeShape(dig_objects.get(), by_object);
Auto-collect fragile objects (i.e.: Firestones) when digging. See http://www.clonkspot.org/comic/1
2013-02-20 20:12:31 +00:00
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
return amount;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
void C4Landscape::BlastFreeShape(int *vtcs, int length, C4Object *by_object, int32_t by_player, int32_t iMaxDensity)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4MaterialList *MaterialContents = NULL;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4Rect BoundingBox = getBoundingBox(vtcs,length);
Import source
2009-05-08 13:28:41 +00:00
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
// Remember any collectible objects in area
std::unique_ptr<C4ValueArray> dig_objects(PrepareFreeShape(BoundingBox, by_object));
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t *pblast_tbl = NULL, blast_tbl[C4M_MaxTexIndex];
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
if (iMaxDensity < C4M_Vehicle)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (int32_t i=0; i < C4M_MaxTexIndex; ++i) blast_tbl[i] = (GetPixDensity(i)<=iMaxDensity);
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
pblast_tbl = blast_tbl;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(by_object)
{
if(!by_object->MaterialContents)
by_object->MaterialContents = new C4MaterialList;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
ForPolygon(vtcs,length/2,&C4Landscape::BlastFreePix,by_object->MaterialContents, 0, 0, pblast_tbl);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
else
{
MaterialContents = new C4MaterialList;
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
ForPolygon(vtcs,length/2,&C4Landscape::BlastFreePix,MaterialContents,iMaxDensity);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// create objects from the material
C4MaterialList *mat_list = NULL;
if(by_object)
mat_list = by_object->MaterialContents;
else
mat_list = MaterialContents;
int32_t tx = BoundingBox.GetMiddleX(), ty = BoundingBox.GetMiddleY();
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
BlastMaterial2Objects(tx,ty,mat_list,by_player,(BoundingBox.Wdt+BoundingBox.Hgt)/4, dig_objects.get());
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(MaterialContents) delete MaterialContents;
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
// Do callbacks to digger for objects that are now dug free
PostFreeShape(dig_objects.get(), by_object);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
void C4Landscape::BlastMaterial2Objects(int32_t tx, int32_t ty, C4MaterialList *mat_list, int32_t caused_by, int32_t str, C4ValueArray *out_objects)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
for (int32_t mat=0; mat< ::MaterialMap.Num; mat++)
{
if (mat_list->Amount[mat])
{
int32_t cast_strength = str;
int32_t pxsamount = 0, blastamount = 0;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (::MaterialMap.Map[mat].Blast2PXSRatio != 0)
{
pxsamount = mat_list->Amount[mat]/::MaterialMap.Map[mat].Blast2PXSRatio;
::PXS.Cast(mat,pxsamount,tx,ty,cast_strength*2);
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (::MaterialMap.Map[mat].Blast2Object != C4ID::None)
{
if (::MaterialMap.Map[mat].Blast2ObjectRatio != 0)
{
blastamount = mat_list->Amount[mat]/::MaterialMap.Map[mat].Blast2ObjectRatio;
Auto-collect firestones if picked free and there's free space in inventory (same as for shoveling).
2014-01-22 20:46:50 +00:00
Game.CastObjects(::MaterialMap.Map[mat].Blast2Object, NULL, blastamount, cast_strength, tx, ty, NO_OWNER, caused_by, out_objects);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
mat_list->Amount[mat] -= Max(blastamount * ::MaterialMap.Map[mat].Blast2ObjectRatio,
pxsamount * ::MaterialMap.Map[mat].Blast2PXSRatio);
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Material objects dug free can be forced to be collected The idea is that for some materials (e.g. earth chunks) it really doesn't make sense to not immediately collect them - they would just collide with something and recreate the material you just dug out. So instead, this allows materials to specify that they want their dug out objects to be collected immediately - if not, they simply don't get created. Note that this doesn't mean that material is lost, as it will simply acumulate in the digger's material list instead. We might want to cap that at some point though.
2011-08-20 14:43:58 +00:00
void C4Landscape::DigMaterial2Objects(int32_t tx, int32_t ty, C4MaterialList *mat_list, C4Object *pCollect)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Added new callback: DugOut(object object_by). Called in a new object that is created from digging out material.
2014-04-30 23:04:41 +00:00
C4AulParSet pars(C4VObj(pCollect));
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
for (int32_t mat=0; mat< ::MaterialMap.Num; mat++)
{
if (mat_list->Amount[mat])
{
if (::MaterialMap.Map[mat].Dig2Object != C4ID::None)
if (::MaterialMap.Map[mat].Dig2ObjectRatio != 0)
Material objects dug free can be forced to be collected The idea is that for some materials (e.g. earth chunks) it really doesn't make sense to not immediately collect them - they would just collide with something and recreate the material you just dug out. So instead, this allows materials to specify that they want their dug out objects to be collected immediately - if not, they simply don't get created. Note that this doesn't mean that material is lost, as it will simply acumulate in the digger's material list instead. We might want to cap that at some point though.
2011-08-20 14:43:58 +00:00
while (mat_list->Amount[mat] >= ::MaterialMap.Map[mat].Dig2ObjectRatio)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Do DigOutObject callback when digging out new objects from material. It was already done when blasting free and when digging out existing objects, but the case of digging out new materials was still missing. This helps collect firestones when digging in firestone material.
2015-01-25 13:19:39 +00:00
mat_list->Amount[mat] -= ::MaterialMap.Map[mat].Dig2ObjectRatio;
Material objects dug free can be forced to be collected The idea is that for some materials (e.g. earth chunks) it really doesn't make sense to not immediately collect them - they would just collide with something and recreate the material you just dug out. So instead, this allows materials to specify that they want their dug out objects to be collected immediately - if not, they simply don't get created. Note that this doesn't mean that material is lost, as it will simply acumulate in the digger's material list instead. We might want to cap that at some point though.
2011-08-20 14:43:58 +00:00
C4Object *pObj = Game.CreateObject(::MaterialMap.Map[mat].Dig2Object, NULL, NO_OWNER, tx, ty);
Do DigOutObject callback when digging out new objects from material. It was already done when blasting free and when digging out existing objects, but the case of digging out new materials was still missing. This helps collect firestones when digging in firestone material.
2015-01-25 13:19:39 +00:00
if (!pObj || !pObj->Status) continue;
// Do callbacks to dug object and digger
pObj->Call(PSF_OnDugOut, &pars);
if (!pObj->Status || !pCollect || !pCollect->Status || pObj->Contained) continue;
C4AulParSet pars(C4VObj(pObj));
pCollect->Call(PSF_DigOutObject, &pars);
if (!pObj->Status || !pCollect->Status || pObj->Contained) continue;
Material objects dug free can be forced to be collected The idea is that for some materials (e.g. earth chunks) it really doesn't make sense to not immediately collect them - they would just collide with something and recreate the material you just dug out. So instead, this allows materials to specify that they want their dug out objects to be collected immediately - if not, they simply don't get created. Note that this doesn't mean that material is lost, as it will simply acumulate in the digger's material list instead. We might want to cap that at some point though.
2011-08-20 14:43:58 +00:00
// Try to collect object
Fixed potential crash in certain doomsday scenarios.
2014-05-11 20:04:51 +00:00
if(::MaterialMap.Map[mat].Dig2ObjectCollect)
if(pCollect && pCollect->Status && pObj && pObj->Status)
if(!pCollect->Collect(pObj))
// Collection forced? Don't generate objects
if(::MaterialMap.Map[mat].Dig2ObjectCollect == 2)
{
pObj->AssignRemoval();
Do DigOutObject callback when digging out new objects from material. It was already done when blasting free and when digging out existing objects, but the case of digging out new materials was still missing. This helps collect firestones when digging in firestone material.
2015-01-25 13:19:39 +00:00
// Cap so we never have more than one object worth of material in the store
Fixed potential crash in certain doomsday scenarios.
2014-05-11 20:04:51 +00:00
mat_list->Amount[mat] = ::MaterialMap.Map[mat].Dig2ObjectRatio;
break;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Added no_instability_check parameter to script functions DigFree and DigFreeRect (#932).
2013-03-31 13:39:29 +00:00
bool C4Landscape::DigFreePixNoInstability(int32_t tx, int32_t ty)
{
int32_t mat = GetMat(tx,ty);
if (MatValid(mat))
if (::MaterialMap.Map[mat].DigFree)
{
ClearPix(tx,ty);
return true;
}
return false;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::DigFreePix(int32_t tx, int32_t ty)
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t mat = GetMat(tx,ty);
if (MatValid(mat))
if (::MaterialMap.Map[mat].DigFree)
{
ClearPix(tx,ty);
// check for instable materials to start moving by the cleared space
CheckInstabilityRange(tx,ty);
return true;
}
return false;
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::BlastFreePix(int32_t tx, int32_t ty)
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t mat = GetMat(tx,ty);
if (MatValid(mat))
{
// for blast, either shift to different material or blast free
if (::MaterialMap.Map[mat].BlastFree)
{
ClearPix(tx,ty);
// check for instable materials to start moving by the cleared space
CheckInstabilityRange(tx,ty);
return true;
}
else
if (::MaterialMap.Map[mat].BlastShiftTo)
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
SetPix2(tx,ty,MatTex2PixCol(::MaterialMap.Map[mat].BlastShiftTo), Transparent);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
return false;
}
bool C4Landscape::ShakeFreePix(int32_t tx, int32_t ty)
{
int32_t mat=GetMat(tx,ty);
if (MatValid(mat))
{
if (::MaterialMap.Map[mat].DigFree)
{
ClearPix(tx,ty);
::PXS.Create(mat,itofix(tx),itofix(ty));
// check for instable materials to start moving by the cleared space
CheckInstabilityRange(tx,ty);
return true;
}
}
return false;
Move some BMP-loading helpers to C4Landscape.cpp
2011-01-19 22:52:46 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::ClearPix(int32_t tx, int32_t ty)
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
// Replace pixel with background pixel
BYTE bkgPix = Surface8Bkg->GetPix(tx, ty);
return SetPix2(tx, ty, bkgPix, bkgPix);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
bool C4Landscape::SetPix2(int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
{
Import source
2009-05-08 13:28:41 +00:00
// check bounds
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (x < 0 || y < 0 || x >= Width || y >= Height)
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Import source
2009-05-08 13:28:41 +00:00
// no change?
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
if ((fgPix == Transparent || fgPix == _GetPix(x, y)) && (bgPix == Transparent || bgPix == Surface8Bkg->_GetPix(x, y)))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
// note for relight (TODO: Why is this not in _SetPix2?)
Shader landscape rendering, first simple version (scaler, shading)
2011-05-23 23:12:19 +00:00
if(pLandscapeRender)
{
C4Rect CheckRect = pLandscapeRender->GetAffectedRect(C4Rect(x, y, 1, 1));
for (int32_t i = 0; i < C4LS_MaxRelights; i++)
if (!Relights[i].Wdt || Relights[i].Overlap(CheckRect) || i + 1 >= C4LS_MaxRelights)
{
Relights[i].Add(CheckRect);
break;
}
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
// Invalidate FoW
if (pFoW)
pFoW->Invalidate(CheckRect);
Shader landscape rendering, first simple version (scaler, shading)
2011-05-23 23:12:19 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// set pixel
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
return _SetPix2(x, y, fgPix, bgPix);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
bool C4Landscape::_SetPix2(int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
if (Config.General.DebugRec)
{
C4RCSetPix rc;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
rc.x=x; rc.y=y; rc.clr=fgPix; rc.bgClr=fgPix;
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
AddDbgRec(RCT_SetPix, &rc, sizeof(rc));
}
Import source
2009-05-08 13:28:41 +00:00
assert(x >= 0 && y >= 0 && x < Width && y < Height);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// get pixel and resolve transparency to already existing pixel
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
BYTE opix = _GetPix(x, y);
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
if (fgPix == Transparent) fgPix = opix;
if (bgPix == Transparent) bgPix = Surface8Bkg->_GetPix(x, y);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// check pixel
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (fgPix == opix && bgPix == Surface8Bkg->_GetPix(x, y)) return true;
Import source
2009-05-08 13:28:41 +00:00
// count pixels
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (Pix2Dens[fgPix])
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{ if (!Pix2Dens[opix]) PixCnt[(y / 15) + (x / 17) * PixCntPitch]++; }
Import source
2009-05-08 13:28:41 +00:00
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{ if (Pix2Dens[opix]) PixCnt[(y / 15) + (x / 17) * PixCntPitch]--; }
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// count material
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
assert(!fgPix || MatValid(Pix2Mat[fgPix]));
int32_t omat = Pix2Mat[opix], nmat = Pix2Mat[fgPix];
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (opix) MatCount[omat]--;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (fgPix) MatCount[nmat]++;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// count effective material
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (omat != nmat)
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (fgPix && ::MaterialMap.Map[nmat].MinHeightCount)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
{
// Check for material above & below
int iMinHeight = ::MaterialMap.Map[nmat].MinHeightCount,
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
iBelow = GetMatHeight(x, y+1, +1, nmat, iMinHeight),
iAbove = GetMatHeight(x, y-1, -1, nmat, iMinHeight);
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Will be above treshold?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iBelow + iAbove + 1 >= iMinHeight)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int iChange = 1;
// Check for heights below threshold
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iBelow < iMinHeight) iChange += iBelow;
if (iAbove < iMinHeight) iChange += iAbove;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Change
EffectiveMatCount[nmat] += iChange;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
if (opix && ::MaterialMap.Map[omat].MinHeightCount)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check for material above & below
int iMinHeight = ::MaterialMap.Map[omat].MinHeightCount,
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
iBelow = GetMatHeight(x, y+1, +1, omat, iMinHeight),
iAbove = GetMatHeight(x, y-1, -1, omat, iMinHeight);
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Not already below threshold?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iBelow + iAbove + 1 >= iMinHeight)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int iChange = 1;
// Check for heights that will get below threshold
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iBelow < iMinHeight) iChange += iBelow;
if (iAbove < iMinHeight) iChange += iAbove;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Change
EffectiveMatCount[omat] -= iChange;
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// set 8bpp-surface only!
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8->SetPix(x, y, fgPix);
Surface8Bkg->SetPix(x, y, bgPix);
Import source
2009-05-08 13:28:41 +00:00
// success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Shake free single pixels of diggable material
2013-02-10 17:28:48 +00:00
bool C4Landscape::CheckInstability(int32_t tx, int32_t ty, int32_t recursion_count)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t mat=GetMat(tx,ty);
Fix a load of warnings (two were actual errors, only in diagnostics though)
2014-04-17 17:16:24 +00:00
if (MatValid(mat)) {
Destroy single pixels of non-diggable material [ala]
2014-08-05 15:01:37 +00:00
const C4Material &material = MaterialMap.Map[mat];
if (material.Instable)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return ::MassMover.Create(tx,ty);
Shake free single pixels of diggable material
2013-02-10 17:28:48 +00:00
// Get rid of single pixels
Destroy single pixels of non-diggable material [ala]
2014-08-05 15:01:37 +00:00
else if (DensitySolid(material.Density) && !material.KeepSinglePixels && recursion_count<10)
Shake free single pixels of diggable material
2013-02-10 17:28:48 +00:00
if ((!::GBackSolid(tx,ty+1)) + (!::GBackSolid(tx,ty-1)) + (!::GBackSolid(tx+1,ty)) + (!::GBackSolid(tx-1,ty)) >= 3)
{
if (!ClearPix(tx,ty)) return false;
Destroy single pixels of non-diggable material [ala]
2014-08-05 15:01:37 +00:00
// Diggable material drops; other material just gets removed
if (material.DigFree) ::PXS.Create(mat,itofix(tx),itofix(ty));
Shake free single pixels of diggable material
2013-02-10 17:28:48 +00:00
// check other pixels around this
// Note this cannot lead to an endless recursion (unless you do funny stuff like e.g. set DigFree=1 in material Tunnel).
// Check recursion anyway, because very large strips of single pixel width might cause sufficient recursion to crash
CheckInstability(tx+1,ty,++recursion_count);
CheckInstability(tx-1,ty,recursion_count);
CheckInstability(tx,ty-1,recursion_count);
CheckInstability(tx,ty+1,recursion_count);
return true;
}
Fix a load of warnings (two were actual errors, only in diagnostics though)
2014-04-17 17:16:24 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::CheckInstabilityRange(int32_t tx, int32_t ty)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!CheckInstability(tx,ty))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
CheckInstability(tx,ty-1);
CheckInstability(tx,ty-2);
CheckInstability(tx-1,ty);
CheckInstability(tx+1,ty);
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::DrawMaterialRect(int32_t mat, int32_t tx, int32_t ty, int32_t wdt, int32_t hgt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t cx,cy;
for (cy=ty; cy<ty+hgt; cy++)
for (cx=tx; cx<tx+wdt; cx++)
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
if ( (MatDensity(mat)>=GetDensity(cx,cy)))
Remove GBackIFT in favor of a lookup in the background surface
2015-06-18 01:34:21 +00:00
SetPix2(cx,cy,Mat2PixColDefault(mat), Surface8Bkg->GetPix(cx, cy));
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::RaiseTerrain(int32_t tx, int32_t ty, int32_t wdt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t cx,cy;
BYTE cpix;
for (cx=tx; cx<tx+wdt; cx++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
for (cy=ty; (cy+1<GBackHgt) && !GBackSolid(cx,cy+1); cy++) {}
if (cy+1<GBackHgt) if (cy-ty<20)
{
Make solidmask not overwrite background material Also, remove Landscape.SetPix in favor of Landscape.SetPix2
2015-07-14 00:15:28 +00:00
cpix=GetPix(cx,cy+1);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!MatVehicle(PixCol2Mat(cpix)))
Make solidmask not overwrite background material Also, remove Landscape.SetPix in favor of Landscape.SetPix2
2015-07-14 00:15:28 +00:00
while (cy>=ty) { SetPix2(cx,cy,cpix,GetBackPix(cx,cy+1)); cy--; }
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
int32_t C4Landscape::ExtractMaterial(int32_t fx, int32_t fy, bool distant_first)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t mat=GetMat(fx,fy);
if (mat==MNone) return MNone;
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
FindMatTop(mat,fx,fy,distant_first);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
ClearPix(fx,fy);
CheckInstabilityRange(fx,fy);
return mat;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Added query_only parameter to script function InsertMaterial.
2013-04-28 11:54:29 +00:00
bool C4Landscape::InsertMaterial(int32_t mat, int32_t *tx, int32_t *ty, int32_t vx, int32_t vy, bool query_only)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
assert(tx); assert(ty);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t mdens;
if (!MatValid(mat)) return false;
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
mdens=Min(MatDensity(mat), C4M_Solid);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!mdens) return true;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Bounds
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if (!Inside<int32_t>(*tx,0,Width-1) || !Inside<int32_t>(*ty,0,Height)) return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (Game.C4S.Game.Realism.LandscapePushPull)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Same or higher density?
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if (GetDensity(*tx, *ty) >= mdens)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Push
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if (!FindMatPathPush(*tx, *ty, mdens, ::MaterialMap.Map[mat].MaxSlide, !! ::MaterialMap.Map[mat].Instable))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Or die
return false;
}
else
{
// Move up above same density
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
while (mdens==Min(GetDensity(*tx,*ty),C4M_Solid))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
(*ty)--; if (*ty<0) return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Primitive slide (1)
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if (GetDensity(*tx-1,*ty)<mdens) (*tx)--;
if (GetDensity(*tx+1,*ty)<mdens) (*tx)++;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
// Stuck in higher density
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if (GetDensity(*tx,*ty)>mdens) return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Try slide
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
while (FindMatSlide(*tx,*ty,+1,mdens,::MaterialMap.Map[mat].MaxSlide))
if (GetDensity(*tx,*ty+1)<mdens)
Added query_only parameter to script function InsertMaterial.
2013-04-28 11:54:29 +00:00
{ if (!query_only) ::PXS.Create(mat,itofix(*tx),itofix(*ty),C4REAL10(vx),C4REAL10(vy)); return true; }
Import source
2009-05-08 13:28:41 +00:00
fix querying InsertMaterial for bodies of water that stretch to the edge of the landscape
2013-06-02 15:58:20 +00:00
if (query_only)
{
// since tx and ty changed, we need to re-check the bounds here
// if we really inserted it, the check is made again in InsertDeadMaterial
if (!Inside<int32_t>(*tx,0,Width-1) || !Inside<int32_t>(*ty,0,Height)) return false;
return true;
}
Import source
2009-05-08 13:28:41 +00:00
fix material conversion on insertion into converting liquid
2012-12-16 17:52:32 +00:00
// Try reaction with material below and at insertion position
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4MaterialReaction *pReact; int32_t tmat;
fix material conversion on insertion into converting liquid
2012-12-16 17:52:32 +00:00
int32_t check_dir = 0;
for (int32_t i=0; i<2; ++i)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if ((pReact = ::MaterialMap.GetReactionUnsafe(mat, tmat=GetMat(*tx,*ty+check_dir))))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
fix material conversion on insertion into converting liquid
2012-12-16 17:52:32 +00:00
C4Real fvx=C4REAL10(vx), fvy=C4REAL10(vy);
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
if ((*pReact->pFunc)(pReact, *tx,*ty, *tx,*ty+check_dir, fvx,fvy, mat,tmat, meePXSPos,NULL))
fix material conversion on insertion into converting liquid
2012-12-16 17:52:32 +00:00
{
// the material to be inserted killed itself in some material reaction below
return true;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
fix material conversion on insertion into converting liquid
2012-12-16 17:52:32 +00:00
if (!(check_dir = Sign(GravAccel))) break;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
MassMover tries to use local textures for materials as well
2011-08-27 16:08:46 +00:00
// Insert as dead material
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
return InsertDeadMaterial(mat, *tx, *ty);
MassMover tries to use local textures for materials as well
2011-08-27 16:08:46 +00:00
}
bool C4Landscape::InsertDeadMaterial(int32_t mat, int32_t tx, int32_t ty)
{
Engine: Fix possible crash in C4Landscape::InsertDeadMaterial (#666)
2011-10-01 17:32:16 +00:00
// Check bounds
if (tx < 0 || ty < 0 || tx >= Width || ty >= Height)
return false;
MassMover tries to use local textures for materials as well
2011-08-27 16:08:46 +00:00
// Save back original material so we can insert it later
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int omat = 0;
if (Game.C4S.Game.Realism.LandscapeInsertThrust)
omat = GetMat(tx, ty);
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Check surroundings for inspiration for texture to use
int n = 0; int pix = -1;
if(tx > 0 && _GetMat(tx-1, ty) == mat)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if(!Random(++n)) pix = _GetPix(tx-1, ty);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(ty > 0 && _GetMat(tx, ty-1) == mat)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if(!Random(++n)) pix = _GetPix(tx, ty-1);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(tx+1 < Width && _GetMat(tx+1, ty) == mat)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if(!Random(++n)) pix = _GetPix(tx+1, ty);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(ty+1 < Height && _GetMat(tx, ty+1) == mat)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if(!Random(++n)) pix = _GetPix(tx, ty+1);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if(pix < 0)
pix = Mat2PixColDefault(mat);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Insert dead material
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
SetPix2(tx,ty,pix, Transparent);
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Search a position for the old material pixel
if (Game.C4S.Game.Realism.LandscapeInsertThrust && MatValid(omat))
Added parameter to InsertMaterial() to return actual insertion position. The insertion position might be pushed upwards if e.g. water is inserted to the bottom of a lake. However, we need the actual insertion position if we ever want to modify the pump to require/produce energy depending on the vertical distance of material pumped.
2013-02-17 17:29:44 +00:00
{
int32_t tyo = ty-1;
C4Landscape::InsertMaterial use ptr instead of ref for insertion pos
2013-02-17 23:48:25 +00:00
InsertMaterial(omat, &tx, &tyo);
Added parameter to InsertMaterial() to return actual insertion position. The insertion position might be pushed upwards if e.g. water is inserted to the bottom of a lake. However, we need the actual insertion position if we ever want to modify the pump to require/produce energy depending on the vertical distance of material pumped.
2013-02-17 17:29:44 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return true;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::Incinerate(int32_t x, int32_t y)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t mat=GetMat(x,y);
if (MatValid(mat))
if (::MaterialMap.Map[mat].Inflammable)
// Not too much FLAMs
Replace some usages of C4ID with C4Def* In particular those that made the c4script shell depend on C4Id.cpp.
2013-03-03 18:25:18 +00:00
if (!Game.FindObject (C4Id2Def(C4ID::Flame), x - 4, y - 1, 8, 20))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (Game.CreateObject(C4ID::Flame,NULL,NO_OWNER,x,y))
return true;
return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
BYTE C4Landscape::DefaultBkgMat(BYTE fg) const
{
Make MapScript create a background map This removes the last occurence of the IFT flag
2015-07-08 01:17:40 +00:00
return ::TextureMap.DefaultBkgMatTex(fg);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
}
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
CSurface8* C4Landscape::CreateDefaultBkgSurface(CSurface8& sfcFg, bool msbAsIft) const
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
{
CSurface8* sfcBg = new CSurface8();
if (!sfcBg->Create(sfcFg.Wdt, sfcFg.Hgt))
{ delete sfcBg; return NULL; }
for (int32_t y=0; y<sfcFg.Hgt; ++y)
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (int32_t x=0; x<sfcFg.Wdt; ++x)
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
{
BYTE fgPix = sfcFg._GetPix(x, y);
BYTE bgPix;
// If we treat the most significant bit as the IFT flag
// (compatibility option for pre-7.0 maps), then set
// the background pixel to 0 if the foreground does not
// have IFT set, and remove the IFT flag from the
// foreground pixel.
if (msbAsIft)
{
if (fgPix & 0x80)
{
fgPix &= ~0x80;
sfcFg._SetPix(x, y, fgPix);
bgPix = DefaultBkgMat(fgPix);
}
else
{
bgPix = 0;
}
}
else
{
bgPix = DefaultBkgMat(fgPix);
}
sfcBg->_SetPix(x, y, bgPix);
}
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return sfcBg;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* ++++ Polygon drawing code extracted from ALLEGRO by Shawn Hargreaves ++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
struct CPolyEdge // An edge for the polygon drawer
{
int y; // Current (starting at the top) y position
int bottom; // bottom y position of this edge
int x; // Fixed point x position
int dx; // Fixed point x gradient
int w; // Width of line segment
struct CPolyEdge *prev; // Doubly linked list
struct CPolyEdge *next;
};
#define POLYGON_FIX_SHIFT 16
static void fill_edge_structure(CPolyEdge *edge, int *i1, int *i2)
{
if (i2[1] < i1[1]) // Swap
{ int *t=i1; i1=i2; i2=t; }
edge->y = i1[1];
edge->bottom = i2[1] - 1;
edge->dx = ((i2[0] - i1[0]) << POLYGON_FIX_SHIFT) / (i2[1] - i1[1]);
edge->x = (i1[0] << POLYGON_FIX_SHIFT) + (1<<(POLYGON_FIX_SHIFT-1)) - 1;
edge->prev = NULL;
edge->next = NULL;
if (edge->dx < 0)
edge->x += Min<int>(edge->dx+(1<<POLYGON_FIX_SHIFT), 0);
edge->w = Max<int>(Abs(edge->dx)-(1<<POLYGON_FIX_SHIFT), 0);
}
static CPolyEdge *add_edge(CPolyEdge *list, CPolyEdge *edge, int sort_by_x)
{
CPolyEdge *pos = list;
CPolyEdge *prev = NULL;
if (sort_by_x)
{
while ((pos) && (pos->x+pos->w/2 < edge->x+edge->w/2))
{ prev = pos; pos = pos->next; }
}
else
{
while ((pos) && (pos->y < edge->y))
{ prev = pos; pos = pos->next; }
}
edge->next = pos;
edge->prev = prev;
if (pos) pos->prev = edge;
if (prev) { prev->next = edge; return list; }
else return edge;
}
static CPolyEdge *remove_edge(CPolyEdge *list, CPolyEdge *edge)
{
if (edge->next) edge->next->prev = edge->prev;
if (edge->prev) { edge->prev->next = edge->next; return list; }
else return edge->next;
}
// Global polygon quick buffer
const int QuickPolyBufSize = 20;
CPolyEdge QuickPolyBuf[QuickPolyBufSize];
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
int32_t C4Landscape::ForPolygon(int *vtcs, int length, bool (C4Landscape::*fnCallback)(int32_t, int32_t),
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
C4MaterialList *mats_count, uint8_t col, uint8_t colBkg, uint8_t *conversion_table)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
// Variables for polygon drawer
int c,x1,x2,y;
int top = INT_MAX;
int bottom = INT_MIN;
int *i1, *i2;
CPolyEdge *edge, *next_edge, *edgebuf;
CPolyEdge *active_edges = NULL;
CPolyEdge *inactive_edges = NULL;
bool use_qpb=false;
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
// Return value
int32_t amount = 0;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Poly Buf
if (length<=QuickPolyBufSize)
{ edgebuf=QuickPolyBuf; use_qpb=true; }
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
else if (!(edgebuf = new CPolyEdge [length])) { return 0; }
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Fill the edge table
edge = edgebuf;
i1 = vtcs;
i2 = vtcs + (length-1) * 2;
for (c=0; c<length; c++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
if (i1[1] != i2[1])
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
fill_edge_structure(edge, i1, i2);
if (edge->bottom >= edge->y)
{
if (edge->y < top) top = edge->y;
if (edge->bottom > bottom) bottom = edge->bottom;
inactive_edges = add_edge(inactive_edges, edge, false);
edge++;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
i2 = i1; i1 += 2;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// For each scanline in the polygon...
for (c=top; c<=bottom; c++)
{
// Check for newly active edges
edge = inactive_edges;
while ((edge) && (edge->y == c))
{
next_edge = edge->next;
inactive_edges = remove_edge(inactive_edges, edge);
active_edges = add_edge(active_edges, edge, true);
edge = next_edge;
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Draw horizontal line segments
edge = active_edges;
while ((edge) && (edge->next))
{
x1=edge->x>>POLYGON_FIX_SHIFT;
x2=(edge->next->x+edge->next->w)>>POLYGON_FIX_SHIFT;
y=c;
// Fix coordinates
if (x1>x2) Swap(x1,x2);
// Set line
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
if (fnCallback)
{
Fix ForPolygon scanlining to exclude pixels on right bound
2012-01-30 19:54:17 +00:00
for (int xcnt=x2-x1-1; xcnt>=0; xcnt--)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
uint8_t pix = GetPix(x1+xcnt, y);
if (!conversion_table || conversion_table[pix])
{
int32_t mat = GetPixMat(pix);
if((this->*fnCallback)(x1+xcnt,y))
if(mats_count)
{
mats_count->Add(mat,1);
amount++;
}
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
}
else if (conversion_table)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
for (int xcnt=x2-x1-1; xcnt>=0; xcnt--)
{
const uint8_t pix = conversion_table[uint8_t(GetPix(x1+xcnt, y))];
Surface8->SetPix(x1+xcnt, y, pix);
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
if (colBkg != Transparent) Surface8Bkg->SetPix(x1+xcnt, y, colBkg);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
}
FnBlastFree: Added max_density parameter. Also updated material densities and added attribute MaxPickDensity to pickaxe, so it's now possible to define a pickaxe that cannot go through granite.
2013-03-25 23:45:44 +00:00
else
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
for (int xcnt=x2-x1-1; xcnt>=0; xcnt--)
{
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
if (col != Transparent) Surface8->SetPix(x1+xcnt, y, col);
if (colBkg != Transparent) Surface8Bkg->SetPix(x1+xcnt, y, colBkg);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
edge = edge->next->next;
}
// Update edges, sorting and removing dead ones
edge = active_edges;
while (edge)
{
next_edge = edge->next;
if (c >= edge->bottom)
{
active_edges = remove_edge(active_edges, edge);
}
else
{
edge->x += edge->dx;
while ((edge->prev) && (edge->x+edge->w/2 < edge->prev->x+edge->prev->w/2))
{
if (edge->next) edge->next->prev = edge->prev;
edge->prev->next = edge->next;
edge->next = edge->prev;
edge->prev = edge->prev->prev;
edge->next->prev = edge;
if (edge->prev) edge->prev->next = edge;
else active_edges = edge;
}
}
edge = next_edge;
}
}
// Clear scratch memory
if (!use_qpb) delete [] edgebuf;
DigFree & DigFreeRect return amount of pixels dug free
2012-04-05 01:59:45 +00:00
return amount;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++ Save, Init and load +++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::ScenarioInit()
{
// Gravity
Use a constant for the default gravity instead of triplicating it
2012-07-25 15:02:10 +00:00
Gravity = C4REAL100(Game.C4S.Landscape.Gravity.Evaluate()) * DefaultGravAccel;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Opens
LeftOpen=Game.C4S.Landscape.LeftOpen;
RightOpen=Game.C4S.Landscape.RightOpen;
TopOpen=Game.C4S.Landscape.TopOpen;
BottomOpen=Game.C4S.Landscape.BottomOpen;
// Side open scan
if (Game.C4S.Landscape.AutoScanSideOpen) ScanSideOpen();
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Fix LandscapeRender ReInit when loading scenario sections. The LandscapeRender Init() proc loads graphics from the main graphics group, which is already closed when a section is loaded. So just keep the renderer around on landscape recreation now.
2013-07-03 20:21:14 +00:00
void C4Landscape::Clear(bool fClearMapCreator, bool fClearSky, bool fClearRenderer)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
if (pMapCreator && fClearMapCreator) { delete pMapCreator; pMapCreator=NULL; }
// clear sky
if (fClearSky) Sky.Clear();
// clear surfaces, if assigned
Fix LandscapeRender ReInit when loading scenario sections. The LandscapeRender Init() proc loads graphics from the main graphics group, which is already closed when a section is loaded. So just keep the renderer around on landscape recreation now.
2013-07-03 20:21:14 +00:00
if (fClearRenderer) { delete pLandscapeRender; pLandscapeRender=NULL; }
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
delete [] TopRowPix; TopRowPix=NULL;
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
delete [] BottomRowPix; BottomRowPix=NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
delete Surface8; Surface8=NULL;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
delete Surface8Bkg; Surface8Bkg=NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
delete Map; Map=NULL;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
delete MapBkg; MapBkg=NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// clear initial landscape
delete [] pInitial; pInitial = NULL;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
delete [] pInitialBkg; pInitialBkg = NULL;
Fix FoW deinitialization in C4Landscape
2014-11-18 19:41:58 +00:00
delete pFoW; pFoW = NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// clear scan
ScanX=0;
Mode=C4LSC_Undefined;
// clear pixel count
delete [] PixCnt; PixCnt = NULL;
PixCntPitch = 0;
// clear bridge material conversion temp buffers
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (int32_t i = 0; i < C4M_MaxTexIndex; ++i)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
delete [] BridgeMatConversion[i];
BridgeMatConversion[i] = NULL;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::CompileFunc(StdCompiler *pComp)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
pComp->Value(mkNamingAdapt(MapSeed, "MapSeed", 0));
pComp->Value(mkNamingAdapt(LeftOpen, "LeftOpen", 0));
pComp->Value(mkNamingAdapt(RightOpen, "RightOpen", 0));
pComp->Value(mkNamingAdapt(TopOpen, "TopOpen", 0));
pComp->Value(mkNamingAdapt(BottomOpen, "BottomOpen", 0));
Use a constant for the default gravity instead of triplicating it
2012-07-25 15:02:10 +00:00
pComp->Value(mkNamingAdapt(mkCastIntAdapt(Gravity), "Gravity", DefaultGravAccel));
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
pComp->Value(mkNamingAdapt(Modulation, "MatModulation", 0U));
pComp->Value(mkNamingAdapt(Mode, "Mode", C4LSC_Undefined));
Save ambient brightness value in savegames
2015-04-07 00:48:59 +00:00
if(pComp->isCompiler())
{
int32_t ambient_brightness;
Fix landscape renderer and ambience level on savegame resume (#1400).
2015-09-17 02:10:40 +00:00
pComp->Value(mkNamingAdapt(ambient_brightness, "AmbientBrightness", 255));
Save ambient brightness value in savegames
2015-04-07 00:48:59 +00:00
if(pFoW) pFoW->Ambient.SetBrightness(ambient_brightness / static_cast<double>(255));
}
else
{
if(pFoW)
{
int32_t ambient_brightness = static_cast<int32_t>(pFoW->Ambient.GetBrightness() * 255 + 0.5);
pComp->Value(mkNamingAdapt(ambient_brightness, "AmbientBrightness", 255));
}
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
GroupReadSurface needs a C4Group to call AccessEntry on
2012-06-23 13:40:01 +00:00
static CSurface8 *GroupReadSurface8(C4Group &hGroup, const char *szWildCard)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if (!hGroup.AccessEntry(szWildCard))
return NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// create surface
CSurface8 *pSfc=new CSurface8();
if (!pSfc->Read(hGroup))
{ delete pSfc; return NULL; }
return pSfc;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::Init(C4Group &hGroup, bool fOverloadCurrent, bool fLoadSky, bool &rfLoaded, bool fSavegame)
{
// set map seed, if not pre-assigned
if (!MapSeed) MapSeed=Random(3133700);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// increase max map size, since developers might set a greater one here
Game.C4S.Landscape.MapWdt.Max=10000;
Game.C4S.Landscape.MapHgt.Max=10000;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// map and landscape must be initialized with fixed random, so runtime joining clients may recreate it
// with same seed
// after map/landscape creation, the seed must be fixed again, so there's no difference between clients creating
// and not creating the map
// this, however, would cause syncloss to DebugRecs
C4DebugRecOff DBGRECOFF(!!Game.C4S.Landscape.ExactLandscape);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Game.FixRandom(Game.RandomSeed);
// map is like it's loaded for regular gamestart
// but it's changed and would have to be saved if a new section is loaded
fMapChanged = fOverloadCurrent;
// don't change landscape mode in runtime joins
bool fLandscapeModeSet = (Mode != C4LSC_Undefined);
Fix pixel masks Solid/Liquid/Background in map scripts. Solid/Liquid/Background depend on PixMaps in C4Landscape being updated to currently loaded materials. PixMaps should really be functions of C4MaterialMap and C4TextureMap. It's probably still broken in mape.
2014-10-16 23:10:47 +00:00
// Make pixel maps
// Pixel maps only depend on loaded materials and textures
// They might be accessed in map scripts, so they should be ready before map creation
UpdatePixMaps();
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Game.SetInitProgress(60);
// create map if necessary
if (!Game.C4S.Landscape.ExactLandscape)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
CSurface8 * sfcMap=NULL;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
CSurface8 * sfcMapBkg=NULL;
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
// Static map from scenario: Old-style Map.bmp with highest bit IFT
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if ((sfcMap=GroupReadSurface8(hGroup, C4CFN_Map)))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
{
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if (!fLandscapeModeSet) Mode=C4LSC_Static;
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
sfcMapBkg = CreateDefaultBkgSurface(*sfcMap, true);
if (!sfcMapBkg) return false;
}
// Static map from scenaruo: New-style MapFg.bmp and MapBg.bmp with
// full 255 mat-tex combinations. Background map is optional, if not
// given default will be created with tunnel background for all
// semisolid pixels.
if (!sfcMap)
{
if ((sfcMap=GroupReadSurface8(hGroup, C4CFN_MapFg)))
{
if (!fLandscapeModeSet) Mode=C4LSC_Static;
sfcMapBkg = GroupReadSurface8(hGroup, C4CFN_MapBg);
if (!sfcMapBkg) sfcMapBkg = CreateDefaultBkgSurface(*sfcMap, false);
if (!sfcMapBkg) return false;
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Added support for scripted maps (Map.c) and documentation.
2013-03-18 23:35:00 +00:00
// dynamic map from Landscape.txt
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!sfcMap)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (CreateMapS2(hGroup, sfcMap, sfcMapBkg))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!fLandscapeModeSet) Mode=C4LSC_Dynamic;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Added support for scripted maps (Map.c) and documentation.
2013-03-18 23:35:00 +00:00
// script may create or edit map
Make MapScript create a background map This removes the last occurence of the IFT flag
2015-07-08 01:17:40 +00:00
if (MapScript.InitializeMap(&Game.C4S.Landscape, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount, &sfcMap, &sfcMapBkg))
Added support for scripted maps (Map.c) and documentation.
2013-03-18 23:35:00 +00:00
if (!fLandscapeModeSet) Mode=C4LSC_Dynamic;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Dynamic map by scenario
if (!sfcMap && !fOverloadCurrent)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if ((!CreateMap(sfcMap, sfcMapBkg)))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!fLandscapeModeSet) Mode=C4LSC_Dynamic;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// No map failure
if (!sfcMap)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// no problem if only overloading
if (!fOverloadCurrent) return false;
if (fLoadSky) if (!Sky.Init(fSavegame)) return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Make MapScript create a background map This removes the last occurence of the IFT flag
2015-07-08 01:17:40 +00:00
assert(sfcMapBkg != NULL);
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
if (Config.General.DebugRec)
{
AddDbgRec(RCT_Block, "|---MAP---|", 12);
AddDbgRec(RCT_Map, sfcMap->Bits, sfcMap->Pitch*sfcMap->Hgt);
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Store map size and calculate map zoom
int iWdt, iHgt;
sfcMap->GetSurfaceSize(iWdt,iHgt);
MapWidth = iWdt; MapHeight = iHgt;
MapZoom = Game.C4S.Landscape.MapZoom.Evaluate();
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Calculate landscape size
Width = MapZoom * MapWidth;
Height = MapZoom * MapHeight;
Width = Max<int32_t>(Width,100);
Height = Max<int32_t>(Height,100);
// Width = (Width/8)*8;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// if overloading, clear current landscape (and sections, etc.)
// must clear, of course, before new sky is eventually read
Fix LandscapeRender ReInit when loading scenario sections. The LandscapeRender Init() proc loads graphics from the main graphics group, which is already closed when a section is loaded. So just keep the renderer around on landscape recreation now.
2013-07-03 20:21:14 +00:00
if (fOverloadCurrent) Clear(!Game.C4S.Landscape.KeepMapCreator, fLoadSky, false);
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// assign new map
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
assert(Map == NULL);
assert(MapBkg == NULL);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Map = sfcMap;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapBkg = sfcMapBkg;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Sky (might need to know landscape height)
if (fLoadSky)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Game.SetInitProgress(70);
if (!Sky.Init(fSavegame)) return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Exact landscape from scenario (no map or exact recreation)
else /* if (Game.C4S.Landscape.ExactLandscape) */
{
C4DebugRecOff DBGRECOFF;
// if overloading, clear current
Fix landscape reinitialization on saved section load (#1379).
2015-09-15 04:13:45 +00:00
if (fOverloadCurrent) Clear(!Game.C4S.Landscape.KeepMapCreator, fLoadSky, false);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// load it
if (!fLandscapeModeSet) Mode=C4LSC_Exact;
rfLoaded=true;
if (!Load(hGroup, fLoadSky, fSavegame)) return false;
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// progress
Add ambient lighting This introduces a new texture, an ambient light map, that is generated automatically at the beginning of the round by the sky portion of the landscape. This basically makes everything that is close to sky visible by default. The shaders have been adapted so that they deploy direction-independent lighting for the ambient component, and the current (diffuse) behaviour for the diffuse component. This makes the shaders use an additional texture unit that represents the ambient light. We can think about merging this information into the light texture, but the coordinate systems are different at the moment, so this could be performed at the stage of light texture generation. For meshes, the ambient material is not actually used, but instead a diffuse light from the front is used. This makes many meshes look more interesting, maybe also because the ambient material setting of most meshes are not set correctly at the moment.
2014-11-17 14:35:50 +00:00
Game.SetInitProgress(75);
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// copy noscan-var
NoScan=Game.C4S.Landscape.NoScan!=0;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Scan settings
Rename BoundBy to Clamp "BoundBy" sounds like a predicate. "Clamp" is a common function name for the operation in graphics processing, so it should be familiar to users.
2015-02-12 22:05:55 +00:00
ScanSpeed=Clamp(Width/500,2,15);
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// map to big surface and sectionize it
// (not for shaders though - they require continous textures)
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if (!Game.C4S.Landscape.ExactLandscape)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
assert(Surface8 == NULL);
assert(Surface8Bkg == NULL);
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
// Create landscape surface
Surface8 = new CSurface8();
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (!Surface8->Create(Width, Height))
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
delete Surface8; Surface8 = NULL;
return false;
}
Surface8Bkg = new CSurface8();
if (!Surface8Bkg->Create(Width, Height) || !Mat2Pal())
{
delete Surface8Bkg; Surface8Bkg = NULL;
delete Surface8; Surface8 = NULL;
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
return false;
}
Import source
2009-05-08 13:28:41 +00:00
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
// Map to landscape
Fix LandscapeRender ReInit when loading scenario sections. The LandscapeRender Init() proc loads graphics from the main graphics group, which is already closed when a section is loaded. So just keep the renderer around on landscape recreation now.
2013-07-03 20:21:14 +00:00
// Landscape render disabled during initial landscape zoom (will be updated later)
C4LandscapeRender *lsrender_backup = pLandscapeRender;
pLandscapeRender = NULL;
bool map2landscape_success = MapToLandscape();
pLandscapeRender = lsrender_backup;
if (!map2landscape_success) return false;
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
}
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
// Init out-of-landscape pixels for bottom
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
InitTopAndBottomRowPix();
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
Add ambient lighting This introduces a new texture, an ambient light map, that is generated automatically at the beginning of the round by the sky portion of the landscape. This basically makes everything that is close to sky visible by default. The shaders have been adapted so that they deploy direction-independent lighting for the ambient component, and the current (diffuse) behaviour for the diffuse component. This makes the shaders use an additional texture unit that represents the ambient light. We can think about merging this information into the light texture, but the coordinate systems are different at the moment, so this could be performed at the stage of light texture generation. For meshes, the ambient material is not actually used, but instead a diffuse light from the front is used. This makes many meshes look more interesting, maybe also because the ambient material setting of most meshes are not set correctly at the moment.
2014-11-17 14:35:50 +00:00
Game.SetInitProgress(80);
Import source
2009-05-08 13:28:41 +00:00
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
if (Config.General.DebugRec)
{
AddDbgRec(RCT_Block, "|---LANDSCAPE---|", 18);
AddDbgRec(RCT_Map, Surface8->Bits, Surface8->Pitch*Surface8->Hgt);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
AddDbgRec(RCT_Block, "|---LANDSCAPE BKG---|", 22);
AddDbgRec(RCT_Map, Surface8Bkg->Bits, Surface8Bkg->Pitch*Surface8Bkg->Hgt);
Make DEBUGREC define a commandline option
2013-05-25 20:38:08 +00:00
}
Debugrec: Dump landscape
2011-07-17 14:52:36 +00:00
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
// Create FoW
Add FoWEnabled entry in Scenario.txt [Game] section (#1178)
2014-12-29 11:29:43 +00:00
assert(pFoW == NULL);
if (Game.C4S.Game.FoWEnabled)
pFoW = new C4FoW();
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Create renderer
Remove remains of Direct3D support Direct3D hasn't worked for more than a year now, and there don't seem to be any efforts to revive it. Remove it and concentrate on better OpenGL support.
2013-10-29 13:27:18 +00:00
#ifndef USE_CONSOLE
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!pLandscapeRender && ::Config.Graphics.HighResLandscape)
pLandscapeRender = new C4LandscapeRenderGL();
#endif
#ifndef USE_CONSOLE
if (!pLandscapeRender)
pLandscapeRender = new C4LandscapeRenderClassic();
#endif
if(pLandscapeRender)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Initialize renderer
Fix LandscapeRender ReInit when loading scenario sections. The LandscapeRender Init() proc loads graphics from the main graphics group, which is already closed when a section is loaded. So just keep the renderer around on landscape recreation now.
2013-07-03 20:21:14 +00:00
if (fOverloadCurrent)
{
if(!pLandscapeRender->ReInit(Width, Height))
return false;
}
else
{
if(!pLandscapeRender->Init(Width, Height, &::TextureMap, &::GraphicsResource.Files))
return false;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Fix landscape renderer and ambience level on savegame resume (#1400).
2015-09-17 02:10:40 +00:00
// Save initial landscape
if (!SaveInitial())
return false;
// Load diff, if existant
ApplyDiff(hGroup);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Create pixel count array
// We will use 15x17 blocks so the pixel count can't get over 255.
int32_t PixCntWidth = (Width + 16) / 17;
PixCntPitch = (Height + 14) / 15;
Fix landscape renderer and ambience level on savegame resume (#1400).
2015-09-17 02:10:40 +00:00
PixCnt = new uint8_t[PixCntWidth * PixCntPitch];
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
UpdatePixCnt(C4Rect(0, 0, Width, Height));
ClearMatCount();
Fix landscape renderer and ambience level on savegame resume (#1400).
2015-09-17 02:10:40 +00:00
UpdateMatCnt(C4Rect(0, 0, Width, Height), true);
Choose texture for dead PXS by surroundings where possible
2011-05-27 00:51:07 +00:00
Fix landscape renderer and ambience level on savegame resume (#1400).
2015-09-17 02:10:40 +00:00
// Create initial landscape render data (after applying diff so landscape is complete)
if (pLandscapeRender) pLandscapeRender->Update(C4Rect(0, 0, Width, Height), this);
Game.SetInitProgress(87);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// after map/landscape creation, the seed must be fixed again, so there's no difference between clients creating
// and not creating the map
Game.FixRandom(Game.RandomSeed);
Import source
2009-05-08 13:28:41 +00:00
Add ambient lighting This introduces a new texture, an ambient light map, that is generated automatically at the beginning of the round by the sky portion of the landscape. This basically makes everything that is close to sky visible by default. The shaders have been adapted so that they deploy direction-independent lighting for the ambient component, and the current (diffuse) behaviour for the diffuse component. This makes the shaders use an additional texture unit that represents the ambient light. We can think about merging this information into the light texture, but the coordinate systems are different at the moment, so this could be performed at the stage of light texture generation. For meshes, the ambient material is not actually used, but instead a diffuse light from the front is used. This makes many meshes look more interesting, maybe also because the ambient material setting of most meshes are not set correctly at the moment.
2014-11-17 14:35:50 +00:00
// Create ambient light map after landscape creation
Add FoWEnabled entry in Scenario.txt [Game] section (#1178)
2014-12-29 11:29:43 +00:00
if (pFoW) pFoW->Ambient.CreateFromLandscape(*this, 10., 50., 0.25);
Add ambient lighting This introduces a new texture, an ambient light map, that is generated automatically at the beginning of the round by the sky portion of the landscape. This basically makes everything that is close to sky visible by default. The shaders have been adapted so that they deploy direction-independent lighting for the ambient component, and the current (diffuse) behaviour for the diffuse component. This makes the shaders use an additional texture unit that represents the ambient light. We can think about merging this information into the light texture, but the coordinate systems are different at the moment, so this could be performed at the stage of light texture generation. For meshes, the ambient material is not actually used, but instead a diffuse light from the front is used. This makes many meshes look more interesting, maybe also because the ambient material setting of most meshes are not set correctly at the moment.
2014-11-17 14:35:50 +00:00
Game.SetInitProgress(84);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Success
rfLoaded=true;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::Save(C4Group &hGroup) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
C4SolidMask::RemoveSolidMasks();
bool r = SaveInternal(hGroup);
C4SolidMask::PutSolidMasks();
return r;
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::SaveInternal(C4Group &hGroup) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save landscape surface
char szTempLandscape[_MAX_PATH+1];
SCopy(Config.AtTempPath(C4CFN_TempLandscape), szTempLandscape);
MakeTempFilename(szTempLandscape);
if (!Surface8->Save(szTempLandscape))
return false;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Move temp file to group
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!hGroup.Move( szTempLandscape, C4CFN_LandscapeFg ))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return false;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
// Same for background surface
SCopy(Config.AtTempPath(C4CFN_TempLandscapeBkg), szTempLandscape);
MakeTempFilename(szTempLandscape);
if (!Surface8Bkg->Save(szTempLandscape))
return false;
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!hGroup.Move(szTempLandscape, C4CFN_LandscapeBg))
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save map
if (fMapChanged && Map)
if (!SaveMap(hGroup))
return false;
// save textures (if changed)
if (!SaveTextures(hGroup))
return false;
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::SaveDiff(C4Group &hGroup, bool fSyncSave) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
C4SolidMask::RemoveSolidMasks();
bool r = SaveDiffInternal(hGroup, fSyncSave);
C4SolidMask::PutSolidMasks();
return r;
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::SaveDiffInternal(C4Group &hGroup, bool fSyncSave) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
assert(pInitial && pInitialBkg);
if (!pInitial || !pInitialBkg) return false;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// If it shouldn't be sync-save: Clear all bytes that have not changed, i.e.
// set them to C4M_MaxTexIndex
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
bool fChanged = false, fChangedBkg = false;;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!fSyncSave)
for (int y = 0; y < Height; y++)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
for (int x = 0; x < Width; x++)
{
if (pInitial[y * Width + x] == Surface8->_GetPix(x, y))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
Surface8->SetPix(x,y,C4M_MaxTexIndex);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
else
fChanged = true;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (pInitialBkg[y * Width + x] == Surface8Bkg->_GetPix(x, y))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
Surface8Bkg->SetPix(x,y,C4M_MaxTexIndex);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
else
fChangedBkg = true;
Fix a load of warnings (two were actual errors, only in diagnostics though)
2014-04-17 17:16:24 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (fSyncSave || fChanged)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save landscape surface
if (!Surface8->Save(Config.AtTempPath(C4CFN_TempLandscape)))
return false;
// Move temp file to group
if (!hGroup.Move( Config.AtTempPath(C4CFN_TempLandscape),
C4CFN_DiffLandscape ))
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (fSyncSave || fChangedBkg)
{
// Save landscape surface
if (!Surface8Bkg->Save(Config.AtTempPath(C4CFN_TempLandscapeBkg)))
return false;
// Move temp file to group
if (!hGroup.Move( Config.AtTempPath(C4CFN_TempLandscapeBkg),
C4CFN_DiffLandscapeBkg ))
return false;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Restore landscape pixels
if (!fSyncSave)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
for (int y = 0; y < Height; y++)
for (int x = 0; x < Width; x++)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (Surface8->_GetPix(x, y) == C4M_MaxTexIndex)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8->SetPix(x,y,pInitial[y * Width + x]);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (Surface8Bkg->_GetPix(x, y) == C4M_MaxTexIndex)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->SetPix(x,y,pInitialBkg[y * Width + x]);
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save changed map, too
if (fMapChanged && Map)
if (!SaveMap(hGroup)) return false;
// and textures (if changed)
if (!SaveTextures(hGroup)) return false;
return true;
}
bool C4Landscape::SaveInitial()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Create array
delete [] pInitial;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
delete [] pInitialBkg;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
pInitial = new BYTE [Width * Height];
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
pInitialBkg = new BYTE [Width * Height];
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save material data
for (int y = 0; y < Height; y++)
for (int x = 0; x < Width; x++)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
{
pInitial[y * Width + x] = Surface8->_GetPix(x, y);
pInitialBkg[y * Width + x] = Surface8Bkg->_GetPix(x, y);
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return true;
}
bool C4Landscape::Load(C4Group &hGroup, bool fLoadSky, bool fSavegame)
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
assert(!Surface8 && !Surface8Bkg);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Load exact landscape from group
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!(Surface8=GroupReadSurface8(hGroup, C4CFN_Landscape)))
{
if (!(Surface8=GroupReadSurface8(hGroup, C4CFN_LandscapeFg))) return false;
Surface8Bkg = GroupReadSurface8(hGroup, C4CFN_LandscapeBg);
if (Surface8Bkg)
{
if ( (Surface8->Wdt != Surface8Bkg->Wdt || Surface8->Hgt != Surface8Bkg->Hgt))
{
LogFatal(FormatString("Landscape has different dimensions than background landscape (%dx%d vs. %dx%d)", Surface8->Wdt, Surface8->Hgt, Surface8Bkg->Wdt, Surface8Bkg->Hgt).getData());
return false;
}
}
else
{
// LandscapeFg.bmp loaded: Assume full 8bit mat-tex values
// when creating background surface.
Surface8Bkg = CreateDefaultBkgSurface(*Surface8, false);
}
}
else
{
// Landscape.bmp loaded: Assume msb is IFT flag when creating
// background surface.
Surface8Bkg = CreateDefaultBkgSurface(*Surface8, true);
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int iWidth, iHeight;
Surface8->GetSurfaceSize(iWidth,iHeight);
Width = iWidth; Height = iHeight;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// adjust pal
if (!Mat2Pal()) return false;
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
// Landscape should be in correct format: Make sure it is!
for (int32_t y=0; y<Height; ++y)
for (int32_t x=0; x<Width; ++x)
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
BYTE byPix = Surface8->_GetPix(x, y);
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
int32_t iMat = PixCol2Mat(byPix);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if (byPix && !MatValid(iMat))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
LogFatal(FormatString("Landscape loading error at (%d/%d): Pixel value %d not a valid material!", (int) x, (int) y, (int) byPix).getData());
return false;
Import source
2009-05-08 13:28:41 +00:00
}
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
BYTE byPixBkg = Surface8Bkg->_GetPix(x, y);
int32_t iMatBkg = PixCol2Mat(byPixBkg);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (byPixBkg && !MatValid(iMatBkg))
{
LogFatal(FormatString("Background Landscape loading error at (%d/%d): Pixel value %d not a valid material!", (int) x, (int) y, (int) byPixBkg).getData());
return false;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
}
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
}
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Init sky
if (fLoadSky)
{
Game.SetInitProgress(70);
if (!Sky.Init(fSavegame)) return false;
}
// Success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::ApplyDiff(C4Group &hGroup)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
CSurface8 *pDiff;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
CSurface8 *pDiffBkg;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Load diff landscape from group
Drop Landscape.NewStyleLandscape from the Scenario.txt The format of the landscape in savegames has changed over time, but for OC only the newest one is relevant, so the code for the old variants can be removed.
2012-06-10 22:09:24 +00:00
if (!(pDiff=GroupReadSurface8(hGroup, C4CFN_DiffLandscape))) return false;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (!(pDiffBkg=GroupReadSurface8(hGroup, C4CFN_DiffLandscapeBkg))) { delete pDiff; return false; }
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// convert all pixels: keep if same material; re-set if different material
BYTE byPix;
for (int32_t y=0; y<Height; ++y) for (int32_t x=0; x<Width; ++x)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (pDiff->GetPix(x, y) != C4M_MaxTexIndex)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (Surface8->_GetPix(x,y) != (byPix=pDiff->_GetPix(x,y)))
// material has changed here: readjust with new texture
Make solidmask not overwrite background material Also, remove Landscape.SetPix in favor of Landscape.SetPix2
2015-07-14 00:15:28 +00:00
Surface8->SetPix(x,y, byPix);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (pDiffBkg->GetPix(x, y) != C4M_MaxTexIndex)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (Surface8Bkg->_GetPix(x, y) != (byPix=pDiffBkg->_GetPix(x, y)))
Surface8Bkg->_SetPix(x, y, byPix);
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// done; clear diff
delete pDiff;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
delete pDiffBkg;
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::Default()
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Mode=C4LSC_Undefined;
Surface8=NULL;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg=NULL;
pInitial=NULL;
pInitialBkg=NULL;
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
TopRowPix=NULL;
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
BottomRowPix=NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
pLandscapeRender=NULL;
Map=NULL;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapBkg=NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Width=Height=0;
MapWidth=MapHeight=MapZoom=0;
ClearMatCount();
ScanX=0;
ScanSpeed=2;
LeftOpen=RightOpen=TopOpen=BottomOpen=0;
Use a constant for the default gravity instead of triplicating it
2012-07-25 15:02:10 +00:00
Gravity=DefaultGravAccel;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
MapSeed=0; NoScan=false;
pMapCreator=NULL;
Modulation=0;
fMapChanged = false;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (int32_t i = 0; i < C4M_MaxTexIndex; ++i)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
BridgeMatConversion[i] = NULL;
Fix FoW deinitialization in C4Landscape
2014-11-18 19:41:58 +00:00
pFoW = NULL;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::ClearMatCount()
{
for (int32_t cnt=0; cnt<C4MaxMaterial; cnt++)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
MatCount[cnt]=0;
EffectiveMatCount[cnt]=0;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::Synchronize()
{
ScanX=0;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t PixCol2Mat(BYTE pixc)
{
// Get texture
int32_t iTex = PixCol2Tex(pixc);
if (!iTex) return MNone;
// Get material-texture mapping
const C4TexMapEntry *pTex = ::TextureMap.GetEntry(iTex);
// Return material
return pTex ? pTex->GetMaterialIndex() : MNone;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::SaveMap(C4Group &hGroup) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
// No map
if (!Map) return false;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
assert(MapBkg != NULL);
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Create map palette
Store all channels of a color together in CStdPalette This mostly simplifies things, since most other places use an 32 bit integer to store colors, but might even improve performance through better cache locality.
2012-08-15 22:45:27 +00:00
CStdPalette Palette;
::TextureMap.StoreMapPalette(&Palette,::MaterialMap);
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Save map surface
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!Map->Save(Config.AtTempPath(C4CFN_TempMapFg), &Palette))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Move temp file to group
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!hGroup.Move(Config.AtTempPath(C4CFN_TempMapFg),
C4CFN_MapFg ))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// Save background map surface
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!MapBkg->Save(Config.AtTempPath(C4CFN_TempMapBg), &Palette))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return false;
// Move temp file to group
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
if (!hGroup.Move(Config.AtTempPath(C4CFN_TempMapBg),
C4CFN_MapBg ))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return false;
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Success
return true;
}
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::SaveTextures(C4Group &hGroup) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// if material-texture-combinations have been added, write the texture map
if (::TextureMap.fEntriesAdded)
{
C4Group *pMatGroup = new C4Group();
bool fSuccess=false;
// create local material group
if (!hGroup.FindEntry(C4CFN_Material))
{
// delete previous item at temp path
EraseItem(Config.AtTempPath(C4CFN_Material));
// create at temp path
if (pMatGroup->Open(Config.AtTempPath(C4CFN_Material), true))
// write to it
if (::TextureMap.SaveMap(*pMatGroup, C4CFN_TexMap))
// close (flush)
if (pMatGroup->Close())
// add it
if (hGroup.Move(Config.AtTempPath(C4CFN_Material), C4CFN_Material))
fSuccess=true;
// temp group must remain for scenario file closure
// it will be deleted when the group is closed
}
else
// simply write it to the local material file
if (pMatGroup->OpenAsChild(&hGroup, C4CFN_Material))
fSuccess = ::TextureMap.SaveMap(*pMatGroup, C4CFN_TexMap);
// close material group again
if (pMatGroup->IsOpen()) pMatGroup->Close();
delete pMatGroup;
// fail if unsuccessful
if (!fSuccess) return false;
}
// done, success
return true;
Clean up SolidMask code The temporary removals for landscape saving purposes now use the temporary removal code of the solidmasks. SolidMasks remove themselves from the landscape when deleted. A now superfluous argument to Remove() is removed.
2010-04-20 20:38:18 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
bool C4Landscape::InitTopAndBottomRowPix()
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
{
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
// Init Top-/BottomRowPix array, which determines if out-of-landscape pixels on top/bottom side of the map are solid or not
// In case of Top-/BottomOpen=2, unit by map and not landscape to avoid runtime join sync losses
delete [] TopRowPix; delete [] BottomRowPix; // safety
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
if (!Width) return true;
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
TopRowPix = new uint8_t[Width];
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
BottomRowPix = new uint8_t[Width];
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
// must access Game.C4S here because Landscape.TopOpen / Landscape.BottomOpen may not be initialized yet
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
// why is there a local copy of that static variable anyway?
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
int32_t top_open_flag = Game.C4S.Landscape.TopOpen;
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
int32_t bottom_open_flag = Game.C4S.Landscape.BottomOpen;
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
if (top_open_flag == 2 && !Map) top_open_flag = 1;
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
if (bottom_open_flag == 2 && !Map) bottom_open_flag = 1;
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
// Init TopRowPix
switch (top_open_flag)
{
// TopOpen=0: Top is closed
case 0: for (int32_t x=0; x<Width; ++x) TopRowPix[x] = MCVehic; break;
// TopOpen=2: Top is open when pixel below has sky background
case 2:
for (int32_t x=0; x<Width; ++x)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t map_pix = MapBkg->GetPix(x/MapZoom,0);
TopRowPix[x] = ((map_pix != 0) ? MCVehic : 0);
Added mode TopOpen=2: Pixels above landscape are partly free and partly solid depending on corresponding top row map IFT. Analogous to BottomOpen=2.
2014-04-21 00:01:17 +00:00
}
break;
// TopOpen=1: Top is open
default: for (int32_t x=0; x<Width; ++x) TopRowPix[x] = 0; break;
}
// Init BottomRowPix
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
switch (bottom_open_flag)
{
// BottomOpen=0: Bottom is closed
case 0: for (int32_t x=0; x<Width; ++x) BottomRowPix[x] = MCVehic; break;
// BottomOpen=2: Bottom is open when pixel above has sky background
case 2:
for (int32_t x=0; x<Width; ++x)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t map_pix = MapBkg->GetPix(x/MapZoom,Map->Hgt-1);
BottomRowPix[x] = ((map_pix != 0) ? MCVehic : 0);
Implemented C4S.Landscape.BottomOpen=2: Bottom is closed iff corresponding map pixel in bottom row has tunnel background.
2013-03-30 13:54:51 +00:00
}
break;
// BottomOpen=1: Bottom is open
default: for (int32_t x=0; x<Width; ++x) BottomRowPix[x] = 0; break;
}
return true;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::MapToLandscape()
Clean up SolidMask code The temporary removals for landscape saving purposes now use the temporary removal code of the solidmasks. SolidMasks remove themselves from the landscape when deleted. A now superfluous argument to Remove() is removed.
2010-04-20 20:38:18 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// zoom map to landscape
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return MapToLandscape(Map,MapBkg,0,0,MapWidth,MapHeight);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
uint32_t C4Landscape::ChunkyRandom(uint32_t & iOffset, uint32_t iRange) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
if (!iRange) return 0;
Make C4Landscape::ChunkyRandom produce somewhat random numbers Also choose the "cro" seed better.
2011-09-02 23:22:12 +00:00
iOffset = (iOffset * 16807) % 2147483647;
return (iOffset ^ MapSeed) % iRange;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
void C4Landscape::DrawChunk(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, uint8_t mcol, uint8_t mcolBkg, C4MaterialCoreShape Shape, uint32_t cro)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
unsigned int top_rough = 0, side_rough = 0, bottom_rough = 0;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// what to do?
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
switch (Shape)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
case C4M_Flat: case C4M_Octagon:
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
if (mcol != Transparent) Surface8->Box(tx, ty, tx + wdt, ty + hgt, mcol);
if (mcolBkg != Transparent) Surface8Bkg->Box(tx, ty, tx + wdt, ty + hgt, mcolBkg);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return;
case C4M_TopFlat:
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
top_rough = 0; side_rough = 2; bottom_rough = 4;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
break;
case C4M_Smooth:
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
top_rough = 2; side_rough = 2; bottom_rough = 2;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
break;
case C4M_Rough:
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
top_rough = 4; side_rough = 4; bottom_rough = 4;
break;
case C4M_Smoother:
top_rough = 1; side_rough = 1; bottom_rough = 1;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
break;
}
int vtcs[16];
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
unsigned int rx = Max(wdt / 2, 1);
Import source
2009-05-08 13:28:41 +00:00
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
vtcs[0] = tx - ChunkyRandom(cro, rx * side_rough / 4); vtcs[1] = ty - ChunkyRandom(cro, rx * top_rough / 4);
vtcs[2] = tx - ChunkyRandom(cro, rx * side_rough / 2); vtcs[3] = ty + hgt / 2;
vtcs[4] = tx - ChunkyRandom(cro, rx * side_rough / 4); vtcs[5] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 4);
vtcs[6] = tx + wdt / 2; vtcs[7] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 2);
vtcs[8] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 4); vtcs[9] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 4);
vtcs[10] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 2); vtcs[11] = ty + hgt / 2;
vtcs[12] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 4); vtcs[13] = ty - ChunkyRandom(cro, rx * top_rough / 4);
vtcs[14] = tx + wdt / 2; vtcs[15] = ty - ChunkyRandom(cro, rx * top_rough / 2);
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
ForPolygon(vtcs, 8, NULL, NULL, mcol, mcolBkg);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
void C4Landscape::DrawSmoothOChunk(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, uint8_t mcol, uint8_t mcolBkg, int flip, uint32_t cro)
Clean up SolidMask code The temporary removals for landscape saving purposes now use the temporary removal code of the solidmasks. SolidMasks remove themselves from the landscape when deleted. A now superfluous argument to Remove() is removed.
2010-04-20 20:38:18 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int vtcs[8];
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
unsigned int rx = Max(wdt / 2, 1);
Clean up SolidMask code The temporary removals for landscape saving purposes now use the temporary removal code of the solidmasks. SolidMasks remove themselves from the landscape when deleted. A now superfluous argument to Remove() is removed.
2010-04-20 20:38:18 +00:00
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
vtcs[0] = tx; vtcs[1] = ty;
Make C4Landscape::ChunkyRandom produce somewhat random numbers Also choose the "cro" seed better.
2011-09-02 23:22:12 +00:00
vtcs[2] = tx; vtcs[3] = ty + hgt;
vtcs[4] = tx + wdt; vtcs[5] = ty + hgt;
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
vtcs[6] = tx + wdt; vtcs[7] = ty;
Import source
2009-05-08 13:28:41 +00:00
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
switch (flip)
{
case 0: vtcs[0] = tx + wdt / 2; vtcs[1] += hgt / 3; vtcs[7] -= ChunkyRandom(cro, rx / 2); break;
case 1: vtcs[2] = tx + wdt / 2; vtcs[3] -= hgt / 3; vtcs[5] += ChunkyRandom(cro, rx / 2); break;
case 2: vtcs[4] = tx + wdt / 2; vtcs[5] -= hgt / 3; vtcs[3] += ChunkyRandom(cro, rx / 2); break;
case 3: vtcs[6] = tx + wdt / 2; vtcs[7] += hgt / 3; vtcs[1] -= ChunkyRandom(cro, rx / 2); break;
case 4: vtcs[0] = tx + wdt / 2; vtcs[1] += hgt / 2; break;
case 5: vtcs[2] = tx + wdt / 2; vtcs[3] -= hgt / 2; break;
case 6: vtcs[4] = tx + wdt / 2; vtcs[5] -= hgt / 2; break;
case 7: vtcs[6] = tx + wdt / 2; vtcs[7] += hgt / 2; break;
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
ForPolygon(vtcs, 4, NULL, NULL, mcol, mcolBkg);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
void C4Landscape::DrawCustomShapePoly(const C4MaterialShape::Poly &poly, int32_t off_x, int32_t off_y, uint8_t mcol, uint8_t mcolBkg)
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
{
// put poly into plain int array format; add offset and send to polygon drawing proc
size_t n = poly.size(), i = 0;
int *vtcs = new int[n*2];
for (C4MaterialShape::Poly::const_iterator j=poly.begin(); j!=poly.end(); ++j)
{
vtcs[i++] = j->x + off_x;
vtcs[i++] = j->y + off_y;
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
ForPolygon(vtcs, n, NULL, NULL, mcol, mcolBkg);
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// done
delete [] vtcs;
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
void C4Landscape::DrawCustomShape(CSurface8 * sfcMap, CSurface8* sfcMapBkg, C4MaterialShape *shape, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, uint8_t iTexture, int32_t iOffX, int32_t iOffY)
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
{
// Prepare shape for map zoom
if (!shape->PrepareForZoom(MapZoom))
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DebugLogF("ERROR: Cannot apply texture index %d: Material shape size not a multiple of map zoom!", (int)iTexture);
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
return;
}
// Get affected range of shapes
// range in pixels
int32_t x0 = iMapX*MapZoom, y0 = iMapY*MapZoom;
int32_t x1 = x0 + iMapWdt*MapZoom, y1 = y0 + iMapHgt*MapZoom;
// range in shape blocks
x0 = (x0-shape->overlap_right +shape->wdt) / shape->wdt - 1;
y0 = (y0-shape->overlap_bottom+shape->hgt) / shape->hgt - 1;
x1 = (x1+shape->overlap_left +shape->wdt) / shape->wdt - 1;
y1 = (y1+shape->overlap_top +shape->hgt) / shape->hgt - 1;
// paint from all affected shape blocks
for (int32_t y=y0; y<=y1; ++y)
for (int32_t x=x0; x<=x1; ++x)
{
int32_t x_map = x*shape->wdt/MapZoom, y_map = y*shape->hgt/MapZoom;
for (C4MaterialShape::PolyVec::const_iterator i = shape->polys.begin(); i!=shape->polys.end(); ++i)
{
const C4MaterialShape::Poly &p = *i;
// does this shape block overlap any map pixels of our material
for (C4MaterialShape::PtVec::const_iterator j=p.overlaps.begin(); j!=p.overlaps.end(); ++j)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
const BYTE pix = sfcMap->GetPix(x_map + j->x, y_map + j->y);
if (pix == iTexture)
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// First pixel in overlap list defines IFT
const BYTE pixBkg = sfcMapBkg->GetPix(x_map + j->x, y_map + j->y);
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// draw this poly!
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawCustomShapePoly(p, x_map*MapZoom+iOffX, y_map*MapZoom+iOffY, pix, pixBkg);
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
break;
}
}
}
}
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
void C4Landscape::ChunkOZoom(CSurface8 * sfcMap, CSurface8 * sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, uint8_t iTexture, int32_t iOffX, int32_t iOffY)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
C4Material *pMaterial = ::TextureMap.GetEntry(iTexture)->GetMaterial();
if (!pMaterial) return;
Added Scenario [Landscape] FlatChunkShapes. If set to true, all chunks are drawn flat. Useful for scenario editing to fix little holes in your static landscape.
2013-01-20 11:51:33 +00:00
C4MaterialCoreShape iChunkType = ::Game.C4S.Landscape.FlatChunkShapes ? C4M_Flat : pMaterial->MapChunkType;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Get map & landscape size
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
int iMapWidth, iMapHeight;
sfcMap->GetSurfaceSize(iMapWidth, iMapHeight);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Clip desired map segment to map size
Rename BoundBy to Clamp "BoundBy" sounds like a predicate. "Clamp" is a common function name for the operation in graphics processing, so it should be familiar to users.
2015-02-12 22:05:55 +00:00
iMapX = Clamp<int32_t>(iMapX, 0, iMapWidth - 1);
iMapY = Clamp<int32_t>(iMapY, 0, iMapHeight - 1);
iMapWdt = Clamp<int32_t>(iMapWdt, 0, iMapWidth - iMapX);
iMapHgt = Clamp<int32_t>(iMapHgt, 0, iMapHeight - iMapY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// get chunk size
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
int iChunkWidth = MapZoom, iChunkHeight = MapZoom;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Scan map lines
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
for (int iY = iMapY; iY < iMapY + iMapHgt; iY++)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Landscape target coordinate vertical
int iToY = iY * iChunkHeight + iOffY;
// Scan map line
for (int iX = iMapX; iX < iMapX + iMapWdt; iX++)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Map scan line start
uint8_t MapPixel=sfcMap->_GetPix(iX, iY);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t MapPixelBkg=sfcMapBkg->_GetPix(iX, iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Landscape target coordinate horizontal
int iToX = iX * iChunkWidth + iOffX;
// Here's a chunk of the texture-material to zoom
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (MapPixel == iTexture)
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
{
// Draw chunk
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawChunk(iToX, iToY, iChunkWidth, iChunkHeight, MapPixel, MapPixelBkg, iChunkType, (iX<<16)+iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
}
// Other chunk, check for slope smoothers
else if (iChunkType == C4M_Smooth || iChunkType == C4M_Smoother || iChunkType == C4M_Octagon)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Map scan line pixel below
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t below = sfcMap->GetPix(iX, iY + 1);
uint8_t above = sfcMap->GetPix(iX, iY - 1);
uint8_t left = sfcMap->GetPix(iX - 1, iY);
uint8_t right = sfcMap->GetPix(iX + 1, iY);
/*uint8_t belowBkg = sfcMapBkg->GetPix(iX, iY + 1);
uint8_t aboveBkg = sfcMapBkg->GetPix(iX, iY - 1);*/
uint8_t leftBkg = sfcMapBkg->GetPix(iX - 1, iY);
uint8_t rightBkg = sfcMapBkg->GetPix(iX + 1, iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// do not fill a tiny hole
if (below == iTexture && above == iTexture && left == iTexture && right == iTexture)
continue;
int flat = iChunkType == C4M_Octagon ? 4 : 0;
// Smooth chunk & same texture-material below
if (iY < iMapHeight - 1 && below == iTexture)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Same texture-material on left
if (iX > 0 && left == iTexture)
{
// Draw smoother
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawSmoothOChunk(iToX, iToY, iChunkWidth, iChunkHeight, left, leftBkg, 3 + flat, (iX<<16) + iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
}
// Same texture-material on right
if (iX < iMapWidth - 1 && right == iTexture)
{
// Draw smoother
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawSmoothOChunk(iToX, iToY, iChunkWidth, iChunkHeight, right, rightBkg, 0 + flat, (iX<<16)+iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
}
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
}
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Smooth chunk & same texture-material above
if (iY > 0 && above == iTexture)
{
// Same texture-material on left
if (iX > 0 && left == iTexture)
{
// Draw smoother
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawSmoothOChunk(iToX, iToY, iChunkWidth, iChunkHeight, left, leftBkg, 2 + flat, (iX<<16)+iY);
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
}
// Same texture-material on right
if (iX < iMapWidth - 1 && right == iTexture)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
// Draw smoother
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawSmoothOChunk(iToX, iToY, iChunkWidth, iChunkHeight, right, rightBkg, 1 + flat, (iX<<16)+iY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Add two new Material Shapes Octagon and Smoother, more chunk antialias Previously, smooth materials would get extra triangles at the top to create slopes instead of steps. Now those also appear at the bottom. Smooth also gets generally smoother at the bottom, while Rough gets rougher at the top. The new Smoother material is somewhere between Flat and Smooth. Octagon is like Flat but also gets straight slope triangles.
2011-09-07 12:25:32 +00:00
}
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Draw custom shapes on top of regular materials
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (pMaterial->CustomShape) DrawCustomShape(sfcMap, sfcMapBkg, pMaterial->CustomShape, iMapX, iMapY, iMapWdt, iMapHgt, iTexture, iOffX, iOffY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::GetTexUsage(CSurface8 * sfcMap, CSurface8 * sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, DWORD *dwpTextureUsage) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
int iX,iY;
// No good parameters
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!sfcMap || !sfcMapBkg || !dwpTextureUsage) return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Clip desired map segment to map size
Rename BoundBy to Clamp "BoundBy" sounds like a predicate. "Clamp" is a common function name for the operation in graphics processing, so it should be familiar to users.
2015-02-12 22:05:55 +00:00
iMapX=Clamp<int32_t>(iMapX,0,sfcMap->Wdt-1); iMapY=Clamp<int32_t>(iMapY,0,sfcMap->Hgt-1);
iMapWdt=Clamp<int32_t>(iMapWdt,0,sfcMap->Wdt-iMapX); iMapHgt=Clamp<int32_t>(iMapHgt,0,sfcMap->Hgt-iMapY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Zero texture usage list
for (int32_t cnt=0; cnt<C4M_MaxTexIndex; cnt++) dwpTextureUsage[cnt]=0;
// Scan map pixels
for (iY = iMapY; iY < iMapY+iMapHgt; iY++)
for (iX = iMapX; iX < iMapX + iMapWdt; iX++)
Check and warn against invalid texture indices in map when creating landscape.
2013-02-11 20:00:41 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// Count texture map index
const int32_t tex = sfcMap->GetPix(iX, iY);
assert(tex < C4M_MaxTexIndex);
Check and warn against invalid texture indices in map when creating landscape.
2013-02-11 20:00:41 +00:00
if (!dwpTextureUsage[tex]++) if (tex)
{
// Check if texture actually exists
if (!::TextureMap.GetEntry(tex)->GetMaterial())
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
LogF("Map2Landscape error: Texture index %d at (%d/%d) in map not defined in texture map!", (int) tex, (int) iX, (int) iY);
Check and warn against invalid texture indices in map when creating landscape.
2013-02-11 20:00:41 +00:00
// No error. Landscape is usually fine but might contain some holes where material should be
}
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// Ignore background texture for now -- this is only used for ChunkOZoom,
// for which only the foreground texture is relevant.
/*
// Count texture map index
const int32_t texBkg = sfcMapBkg->GetPix(iX, iY);
if (!dwpTextureUsage[texBkg]++) if (texBkg)
{
// Check if texture actually exists
if (!::TextureMap.GetEntry(texBkg)->GetMaterial())
LogF("Map2Landscape error: Texture index %d at (%d/%d) in background map not defined in texture map!", (int) texBkg, (int) iX, (int) iY);
// No error. Landscape is usually fine but might contain some holes where material should be
}
*/
Check and warn against invalid texture indices in map when creating landscape.
2013-02-11 20:00:41 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Done
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::TexOZoom(CSurface8 * sfcMap, CSurface8 * sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, DWORD *dwpTextureUsage, int32_t iToX, int32_t iToY)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
int32_t iIndex;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// ChunkOZoom all used textures
Order mat-tex combinations by appearance in texture map instead of by palette index when zooming map to landscape. This should simplify insertion of new textures at arbitrary drawing orders without reassigning palette indices (the latter would invalidate all old maps).
2015-08-10 04:34:43 +00:00
for (auto i = ::TextureMap.Order.begin(); i != ::TextureMap.Order.end(); ++i)
{
iIndex = *i;
if (dwpTextureUsage[iIndex] > 0)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
// ChunkOZoom map to landscape
Order mat-tex combinations by appearance in texture map instead of by palette index when zooming map to landscape. This should simplify insertion of new textures at arbitrary drawing orders without reassigning palette indices (the latter would invalidate all old maps).
2015-08-10 04:34:43 +00:00
ChunkOZoom(sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, iIndex, iToX, iToY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Order mat-tex combinations by appearance in texture map instead of by palette index when zooming map to landscape. This should simplify insertion of new textures at arbitrary drawing orders without reassigning palette indices (the latter would invalidate all old maps).
2015-08-10 04:34:43 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Done
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::MapToSurface(CSurface8 * sfcMap, CSurface8 * sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, int32_t iToX, int32_t iToY, int32_t iToWdt, int32_t iToHgt, int32_t iOffX, int32_t iOffY)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// assign clipper
Surface8->Clip(iToX,iToY,iToX+iToWdt-1,iToY+iToHgt-1);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->Clip(iToX,iToY,iToX+iToWdt-1,iToY+iToHgt-1);
Rename lpDDraw to pDraw
2011-10-03 14:30:18 +00:00
pDraw->NoPrimaryClipper();
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Enlarge map segment for chunky rim
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
iMapX-=2+MaterialMap.max_shape_width/MapZoom;
iMapY-=2+MaterialMap.max_shape_height/MapZoom;
iMapWdt+=4+MaterialMap.max_shape_width/MapZoom*2;
iMapHgt+=4+MaterialMap.max_shape_height/MapZoom*2;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Determine texture usage in map segment
DWORD dwTexUsage[C4M_MaxTexIndex];
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!GetTexUsage(sfcMap,sfcMapBkg,iMapX,iMapY,iMapWdt,iMapHgt,dwTexUsage)) return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Texture zoom map to landscape
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!TexOZoom(sfcMap,sfcMapBkg,iMapX,iMapY,iMapWdt,iMapHgt,dwTexUsage,iOffX,iOffY)) return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// remove clipper
Surface8->NoClip();
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->NoClip();
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::MapToLandscape(CSurface8 * sfcMap, CSurface8 * sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, int32_t iOffsX, int32_t iOffsY, bool noClear)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
assert(Surface8 && Surface8Bkg);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Clip to map/landscape segment
int iMapWidth,iMapHeight,iLandscapeWidth,iLandscapeHeight;
// Get map & landscape size
sfcMap->GetSurfaceSize(iMapWidth,iMapHeight);
Surface8->GetSurfaceSize(iLandscapeWidth,iLandscapeHeight);
// Clip map segment to map size
Rename BoundBy to Clamp "BoundBy" sounds like a predicate. "Clamp" is a common function name for the operation in graphics processing, so it should be familiar to users.
2015-02-12 22:05:55 +00:00
iMapX = Clamp<int32_t>(iMapX, 0, iMapWidth - 1); iMapY = Clamp<int32_t>(iMapY, 0, iMapHeight - 1);
iMapWdt = Clamp<int32_t>(iMapWdt, 0, iMapWidth - iMapX); iMapHgt = Clamp<int32_t>(iMapHgt, 0, iMapHeight - iMapY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// No segment
if (!iMapWdt || !iMapHgt) return true;
// Get affected landscape rect
C4Rect To;
To.x = iMapX*MapZoom + iOffsX;
To.y = iMapY*MapZoom + iOffsY;
To.Wdt = iMapWdt*MapZoom;
To.Hgt = iMapHgt*MapZoom;
PrepareChange(To);
clearing of landscape is now done in C4Landscape::MapToLandscape instead of MapToSurface
2012-02-11 22:24:53 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// clear the old landscape if not supressed
clearing of landscape is now done in C4Landscape::MapToLandscape instead of MapToSurface
2012-02-11 22:24:53 +00:00
if(!noClear)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
{
clearing of landscape is now done in C4Landscape::MapToLandscape instead of MapToSurface
2012-02-11 22:24:53 +00:00
Surface8->ClearBox8Only(To.x, To.y, To.Wdt, To.Hgt);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->ClearBox8Only(To.x, To.y, To.Wdt, To.Hgt);
}
clearing of landscape is now done in C4Landscape::MapToLandscape instead of MapToSurface
2012-02-11 22:24:53 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapToSurface(sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, To.x, To.y, To.Wdt, To.Hgt, iOffsX, iOffsY);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
FinishChange(To);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::CreateMap(CSurface8*& sfcMap, CSurface8*& sfcMapBkg)
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t iWidth=0,iHeight=0;
// Create map surface
Game.C4S.Landscape.GetMapSize(iWidth,iHeight,Game.StartupPlayerCount);
if (!(sfcMap=new CSurface8(iWidth,iHeight)))
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Fill sfcMap
C4MapCreator MapCreator;
MapCreator.Create(sfcMap,
Game.C4S.Landscape, ::TextureMap,
true,Game.StartupPlayerCount);
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
sfcMapBkg = CreateDefaultBkgSurface(*sfcMap, false);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!sfcMapBkg) { delete sfcMap; sfcMap = NULL; return false; }
return true;
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::CreateMapS2(C4Group &ScenFile, CSurface8*& sfcMap, CSurface8*& sfcMapBkg)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// file present?
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!ScenFile.AccessEntry(C4CFN_DynLandscape)) return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// create map creator
if (!pMapCreator)
pMapCreator = new C4MapCreatorS2(&Game.C4S.Landscape, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount);
// read file
pMapCreator->ReadFile(C4CFN_DynLandscape, &ScenFile);
// render landscape
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
if(!pMapCreator->Render(NULL, sfcMap, sfcMapBkg))
return false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// keep map creator until script callbacks have been done
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool C4Landscape::PostInitMap()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// map creator present?
if (!pMapCreator) return true;
// call scripts
pMapCreator->ExecuteCallbacks(MapZoom);
// destroy map creator, if not needed later
if (!Game.C4S.Landscape.KeepMapCreator) { delete pMapCreator; pMapCreator=NULL; }
// done, success
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++ Searching for features in the landscape +++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::_PathFree(int32_t x, int32_t y, int32_t x2, int32_t y2) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
x /= 17; y /= 15; x2 /= 17; y2 /= 15;
while (x != x2 && y != y2)
{
if (PixCnt[x * PixCntPitch + y])
return false;
if (x > x2) x--; else x++;
if (y > y2) y--; else y++;
}
if (x != x2)
do
{
if (PixCnt[x * PixCntPitch + y])
return false;
if (x > x2) x--; else x++;
}
while (x != x2);
else
while (y != y2)
{
if (PixCnt[x * PixCntPitch + y])
return false;
if (y > y2) y--; else y++;
}
return !PixCnt[x * PixCntPitch + y];
}
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
int32_t C4Landscape::GetMatHeight(int32_t x, int32_t y, int32_t iYDir, int32_t iMat, int32_t iMax) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
if (iYDir > 0)
{
iMax = Min<int32_t>(iMax, Height - y);
for (int32_t i = 0; i < iMax; i++)
if (_GetMat(x, y + i) != iMat)
return i;
}
else
{
iMax = Min<int32_t>(iMax, y + 1);
for (int32_t i = 0; i < iMax; i++)
if (_GetMat(x, y - i) != iMat)
return i;
}
return iMax;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Nearest free above semi solid
added parameter for DrawMap and DrawDefMap to retain old material if sky is drawn
2012-02-10 20:48:48 +00:00
bool AboveSemiSolid(int32_t &rx, int32_t &ry)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t cy1=ry,cy2=ry;
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool UseUpwardsNextFree=false,UseDownwardsNextSolid=false;
Import source
2009-05-08 13:28:41 +00:00
while ((cy1>=0) || (cy2<GBackHgt))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Check upwards
if (cy1>=0)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (GBackSemiSolid(rx,cy1)) UseUpwardsNextFree=true;
else if (UseUpwardsNextFree) { ry=cy1; return true; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Check downwards
if (cy2<GBackHgt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!GBackSemiSolid(rx,cy2)) UseDownwardsNextSolid=true;
else if (UseDownwardsNextSolid) { ry=cy2; return true; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Advance
cy1--; cy2++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Nearest free directly above solid
added parameter for DrawMap and DrawDefMap to retain old material if sky is drawn
2012-02-10 20:48:48 +00:00
bool AboveSolid(int32_t &rx, int32_t &ry)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t cy1=ry,cy2=ry;
while ((cy1>=0) || (cy2<GBackHgt))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Check upwards
if (cy1>=0)
if (!GBackSemiSolid(rx,cy1))
if (GBackSolid(rx,cy1+1))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ ry=cy1; return true; }
Import source
2009-05-08 13:28:41 +00:00
// Check downwards
if (cy2+1<GBackHgt)
if (!GBackSemiSolid(rx,cy2))
if (GBackSolid(rx,cy2+1))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ ry=cy2; return true; }
Import source
2009-05-08 13:28:41 +00:00
// Advance
cy1--; cy2++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Nearest free/semi above solid
added parameter for DrawMap and DrawDefMap to retain old material if sky is drawn
2012-02-10 20:48:48 +00:00
bool SemiAboveSolid(int32_t &rx, int32_t &ry)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t cy1=ry,cy2=ry;
while ((cy1>=0) || (cy2<GBackHgt))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Check upwards
if (cy1>=0)
if (!GBackSolid(rx,cy1))
if (GBackSolid(rx,cy1+1))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ ry=cy1; return true; }
Import source
2009-05-08 13:28:41 +00:00
// Check downwards
if (cy2+1<GBackHgt)
if (!GBackSolid(rx,cy2))
if (GBackSolid(rx,cy2+1))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ ry=cy2; return true; }
Import source
2009-05-08 13:28:41 +00:00
// Advance
cy1--; cy2++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindLiquidHeight(int32_t cx, int32_t &ry, int32_t hgt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t cy1=ry,cy2=ry,rl1=0,rl2=0;
while ((cy1>=0) || (cy2<GBackHgt))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Check upwards
if (cy1>=0)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
if (GBackLiquid(cx,cy1))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ rl1++; if (rl1>=hgt) { ry=cy1+hgt/2; return true; } }
Import source
2009-05-08 13:28:41 +00:00
else rl1=0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Check downwards
if (cy2+1<GBackHgt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
if (GBackLiquid(cx,cy2))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ rl2++; if (rl2>=hgt) { ry=cy2-hgt/2; return true; } }
Import source
2009-05-08 13:28:41 +00:00
else rl2=0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Advance
cy1--; cy2++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
PlaceVegetation now accept C4D_Place_Subsurface for underground placement and C4D_Place_BothSurface for above- and underground placement.
2011-10-02 22:11:00 +00:00
bool FindTunnelHeight(int32_t cx, int32_t &ry, int32_t hgt)
{
int32_t cy1=ry,cy2=ry,rl1=0,rl2=0;
while ((cy1>=0) || (cy2<GBackHgt))
{
// Check upwards
if (cy1>=0)
{
Remove GBackIFT in favor of a lookup in the background surface
2015-06-18 01:34:21 +00:00
if (Landscape.GetBackPix(cx, cy1) != 0 && MatDensity(GBackMat(cx,cy1)) < C4M_Liquid)
PlaceVegetation now accept C4D_Place_Subsurface for underground placement and C4D_Place_BothSurface for above- and underground placement.
2011-10-02 22:11:00 +00:00
{ rl1++; if (rl1>=hgt) { ry=cy1+hgt/2; return true; } }
else rl1=0;
}
// Check downwards
if (cy2+1<GBackHgt)
{
Remove GBackIFT in favor of a lookup in the background surface
2015-06-18 01:34:21 +00:00
if (Landscape.GetBackPix(cx, cy2) != 0 && MatDensity(GBackMat(cx,cy2)) < C4M_Liquid)
PlaceVegetation now accept C4D_Place_Subsurface for underground placement and C4D_Place_BothSurface for above- and underground placement.
2011-10-02 22:11:00 +00:00
{ rl2++; if (rl2>=hgt) { ry=cy2-hgt/2; return true; } }
else rl2=0;
}
// Advance
cy1--; cy2++;
}
return false;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Starting from rx/ry, searches for a width of solid ground.
// Returns bottom center of surface space found.
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindSolidGround(int32_t &rx, int32_t &ry, int32_t width)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
bool fFound=false;
int32_t cx1,cx2,cy1,cy2,rl1=0,rl2=0;
for (cx1=cx2=rx,cy1=cy2=ry; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Left search
if (cx1>=0) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (AboveSolid(cx1,cy1)) rl1++; // Run okay
else rl1=0; // No run
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Right search
if (cx2<GBackWdt) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (AboveSolid(cx2,cy2)) rl2++; // Run okay
else rl2=0; // No run
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check runs
if (rl1>=width) { rx=cx1+rl1/2; ry=cy1; fFound=true; break; }
if (rl2>=width) { rx=cx2-rl2/2; ry=cy2; fFound=true; break; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (fFound) AboveSemiSolid(rx,ry);
return fFound;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindSurfaceLiquid(int32_t &rx, int32_t &ry, int32_t width, int32_t height)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
bool fFound=false;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t cx1,cx2,cy1,cy2,rl1=0,rl2=0,cnt;
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool lokay;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
for (cx1=cx2=rx,cy1=cy2=ry; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Left search
if (cx1>0) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx1,cy1)) cx1=-1; // Abort left
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
for (lokay=true,cnt=0; cnt<height; cnt++) if (!GBackLiquid(cx1,cy1+1+cnt)) lokay=false;
Import source
2009-05-08 13:28:41 +00:00
if (lokay) rl1++; // Run okay
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
else rl1=0; // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Right search
if (cx2<GBackWdt) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx2,cy2)) cx2=GBackWdt; // Abort right
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
for (lokay=true,cnt=0; cnt<height; cnt++) if (!GBackLiquid(cx2,cy2+1+cnt)) lokay=false;
Import source
2009-05-08 13:28:41 +00:00
if (lokay) rl2++; // Run okay
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
else rl2=0; // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check runs
if (rl1>=width) { rx=cx1+rl1/2; ry=cy1; fFound=true; break; }
if (rl2>=width) { rx=cx2-rl2/2; ry=cy2; fFound=true; break; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (fFound) AboveSemiSolid(rx,ry);
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return fFound;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindLiquid(int32_t &rx, int32_t &ry, int32_t width, int32_t height)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t cx1,cx2,cy1,cy2,rl1=0,rl2=0;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
for (cx1=cx2=rx,cy1=cy2=ry; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Left search
if (cx1>0)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
if (FindLiquidHeight(cx1,cy1,height)) rl1++;
else rl1=0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Right search
if (cx2<GBackWdt)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
if (FindLiquidHeight(cx2,cy2,height)) rl2++;
else rl2=0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check runs
if (rl1>=width) { rx=cx1+rl1/2; ry=cy1; return true; }
if (rl2>=width) { rx=cx2-rl2/2; ry=cy2; return true; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
PlaceVegetation now accept C4D_Place_Subsurface for underground placement and C4D_Place_BothSurface for above- and underground placement.
2011-10-02 22:11:00 +00:00
// Starting from rx/ry, searches for tunnel background
// Tunnel background == no sky && no semi/solid material (density < 25)
bool FindTunnel(int32_t &rx, int32_t &ry, int32_t width, int32_t height)
{
int32_t cx1,cx2,cy1,cy2,rl1=0,rl2=0;
for (cx1=cx2=rx,cy1=cy2=ry; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
{
// Left search
if (cx1>0)
{
if (FindTunnelHeight(cx1,cy1,height)) rl1++;
else rl1=0;
}
// Right search
if (cx2<GBackWdt)
{
if (FindTunnelHeight(cx2,cy2,height)) rl2++;
else rl2=0;
}
// Check runs
if (rl1>=width) { rx=cx1+rl1/2; ry=cy1; return true; }
if (rl2>=width) { rx=cx2-rl2/2; ry=cy2; return true; }
}
return false;
}
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Starting from rx/ry, searches for a width of solid ground. Extreme distances
// may not exceed hrange. Returns bottom center of surface found.
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindLevelGround(int32_t &rx, int32_t &ry, int32_t width, int32_t hrange)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
bool fFound=false;
int32_t cx1,cx2,cy1,cy2,rh1,rh2,rl1,rl2;
cx1=cx2=rx; cy1=cy2=ry;
rh1=cy1; rh2=cy2;
rl1=rl2=0;
for (cx1--,cx2++; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Left search
if (cx1>0) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx1,cy1)) cx1=-1; // Abort left
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (GBackSolid(cx1,cy1+1) && (Abs(cy1-rh1)<hrange))
rl1++; // Run okay
else
{ rl1=0; rh1=cy1; } // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Right search
if (cx2<GBackWdt) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx2,cy2)) cx2=GBackWdt; // Abort right
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (GBackSolid(cx2,cy2+1) && (Abs(cy2-rh2)<hrange))
rl2++; // Run okay
else
{ rl2=0; rh2=cy2; } // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check runs
if (rl1>=width) { rx=cx1+rl1/2; ry=cy1; fFound=true; break; }
if (rl2>=width) { rx=cx2-rl2/2; ry=cy2; fFound=true; break; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (fFound) AboveSemiSolid(rx,ry);
return fFound;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
// Starting from rx/ry, searches for a width of solid level ground with
// structure clearance (category). Returns bottom center of surface found.
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindConSiteSpot(int32_t &rx, int32_t &ry, int32_t wdt, int32_t hgt,
objects: Replace the sorting functionality of Categories with a Plane property This makes changing the drawing order a lot easier.
2010-12-27 19:15:55 +00:00
int32_t Plane, int32_t hrange)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
bool fFound=false;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// No hrange limit, use standard smooth surface limit
if (hrange==-1) hrange=Max(wdt/4,5);
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t cx1,cx2,cy1,cy2,rh1,rh2,rl1,rl2;
Import source
2009-05-08 13:28:41 +00:00
// Left offset starting position
cx1=Min(rx+wdt/2,GBackWdt-1); cy1=ry;
// No good: use centered starting position
if (!AboveSemiSolid(cx1,cy1)) { cx1=Min<int32_t>(rx,GBackWdt-1); cy1=ry; }
// Right offset starting position
cx2=Max(rx-wdt/2,0); cy2=ry;
// No good: use centered starting position
if (!AboveSemiSolid(cx2,cy2)) { cx2=Min<int32_t>(rx,GBackWdt-1); cy2=ry; }
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
rh1=cy1; rh2=cy2; rl1=rl2=0;
Import source
2009-05-08 13:28:41 +00:00
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
for (cx1--,cx2++; (cx1>0) || (cx2<GBackWdt); cx1--,cx2++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Left search
if (cx1>0) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx1,cy1))
Import source
2009-05-08 13:28:41 +00:00
cx1=-1; // Abort left
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (GBackSolid(cx1,cy1+1) && (Abs(cy1-rh1)<hrange))
rl1++; // Run okay
else
{ rl1=0; rh1=cy1; } // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Right search
if (cx2<GBackWdt) // Still going
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (!AboveSemiSolid(cx2,cy2))
Import source
2009-05-08 13:28:41 +00:00
cx2=GBackWdt; // Abort right
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (GBackSolid(cx2,cy2+1) && (Abs(cy2-rh2)<hrange))
rl2++; // Run okay
else
{ rl2=0; rh2=cy2; } // No run
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check runs & object overlap
if (rl1>=wdt) if (cx1>0)
objects: Replace the sorting functionality of Categories with a Plane property This makes changing the drawing order a lot easier.
2010-12-27 19:15:55 +00:00
if (!Game.OverlapObject(cx1,cy1-hgt-10,wdt,hgt+40,Plane))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{ rx=cx1+wdt/2; ry=cy1; fFound=true; break; }
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (rl2>=wdt) if (cx2<GBackWdt)
objects: Replace the sorting functionality of Categories with a Plane property This makes changing the drawing order a lot easier.
2010-12-27 19:15:55 +00:00
if (!Game.OverlapObject(cx2-wdt,cy2-hgt-10,wdt,hgt+40,Plane))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{ rx=cx2-wdt/2; ry=cy2; fFound=true; break; }
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
if (fFound) AboveSemiSolid(rx,ry);
return fFound;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
// Returns false on any solid pix in path.
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
bool PathFreePix(int32_t x, int32_t y)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
return !GBackSolid(x,y);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
adjusted PathFree2 to return the first point on the line from point1 to point2 before, when point1 was f.e. more to the right, PathFree2 would swap the points and return an unexpected point
2012-12-22 15:47:45 +00:00
bool PathFree(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
{
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
return ForLine(x1,y1,x2,y2,&PathFreePix);
adjusted PathFree2 to return the first point on the line from point1 to point2 before, when point1 was f.e. more to the right, PathFree2 would swap the points and return an unexpected point
2012-12-22 15:47:45 +00:00
}
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool PathFree(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t *ix, int32_t *iy)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
adjusted PathFree2 to return the first point on the line from point1 to point2 before, when point1 was f.e. more to the right, PathFree2 would swap the points and return an unexpected point
2012-12-22 15:47:45 +00:00
// use the standard Bresenham algorithm and just adjust it to behave correctly in the inversed case
bool reverse = false;
bool steep = Abs(y2 - y1) > Abs(x2 - x1);
if (steep)
{
Swap(x1, y1);
Swap(x2, y2);
}
if (x1 > x2)
{
Swap(x1, x2);
Swap(y1, y2);
reverse = true;
}
if (!reverse)
{
int32_t deltax = x2 - x1;
int32_t deltay = Abs(y2 - y1);
int32_t error = 0;
int32_t ystep = (y1 < y2) ? 1 : -1;
int32_t y = y1;
for (int32_t x = x1; x <= x2; x++)
{
if (steep)
{
if (GBackSolid(y, x))
{
if (ix) {*ix = y; *iy = x;}
return false;
}
}
else
{
if (GBackSolid(x, y))
{
if (ix) {*ix = x; *iy = y;}
return false;
}
}
error += deltay;
if (2 * error >= deltax)
{
y += ystep;
error -= deltax;
}
}
}
else // reverse
{
int32_t deltax = x2 - x1;
int32_t deltay = Abs(y2 - y1);
int32_t error = 0;
int32_t ystep = (y1 < y2) ? 1 : -1;
int32_t y = y2;
// normal (inverse) routine
for (int32_t x = x2; x >= x1; x--)
{
if (steep)
{
if (GBackSolid(y, x))
{
if (ix) {*ix = y; *iy = x;}
return false;
}
}
else
{
if (GBackSolid(x, y))
{
if (ix) {*ix = x; *iy = y;}
return false;
}
}
error -= deltay;
if (2 * error <= -deltax)
{
y -= ystep;
error += deltax;
}
}
}
// no solid material encountered: path free!
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
bool PathFreeIgnoreVehiclePix(int32_t x, int32_t y)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
BYTE byPix=GBackPix(x,y);
Move Game.Landscape to ::Landscape
2009-06-05 15:20:41 +00:00
return !byPix || !DensitySolid(::Landscape.GetPixMat(byPix)) || ::Landscape.GetPixMat(byPix) == MVehic;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool PathFreeIgnoreVehicle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t *ix, int32_t *iy)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
return ForLine(x1,y1,x2,y2,&PathFreeIgnoreVehiclePix,ix,iy);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Rename FIXED to C4Real There's already a typedef struct _FIXED FIXED; in wingdi.h, which conflicts with the definition of FIXED in OpenClonk.
2010-05-04 15:35:18 +00:00
int32_t TrajectoryDistance(int32_t iFx, int32_t iFy, C4Real iXDir, C4Real iYDir, int32_t iTx, int32_t iTy)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t iClosest = Distance(iFx,iFy,iTx,iTy);
// Follow free trajectory, take closest point distance
Rename FIXED to C4Real There's already a typedef struct _FIXED FIXED; in wingdi.h, which conflicts with the definition of FIXED in OpenClonk.
2010-05-04 15:35:18 +00:00
C4Real cx = itofix(iFx), cy = itofix(iFy);
Import source
2009-05-08 13:28:41 +00:00
int32_t cdis;
while (Inside(fixtoi(cx),0,GBackWdt-1) && Inside(fixtoi(cy),0,GBackHgt-1) && !GBackSolid(fixtoi(cx), fixtoi(cy)))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
cdis = Distance(fixtoi(cx),fixtoi(cy),iTx,iTy);
if (cdis<iClosest) iClosest=cdis;
cx+=iXDir; cy+=iYDir; iYDir+=GravAccel;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return iClosest;
}
Import source
2009-05-08 13:28:41 +00:00
const int32_t C4LSC_Throwing_MaxVertical = 50,
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
C4LSC_Throwing_MaxHorizontal = 60;
Import source
2009-05-08 13:28:41 +00:00
Rename FIXED to C4Real There's already a typedef struct _FIXED FIXED; in wingdi.h, which conflicts with the definition of FIXED in OpenClonk.
2010-05-04 15:35:18 +00:00
bool FindThrowingPosition(int32_t iTx, int32_t iTy, C4Real fXDir, C4Real fYDir, int32_t iHeight, int32_t &rX, int32_t &rY)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Start underneath throwing target
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
rX=iTx; rY=iTy; // improve: check from overhanging cliff
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!SemiAboveSolid(rX,rY)) return false;
Import source
2009-05-08 13:28:41 +00:00
// Target too far above surface
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!Inside(rY-iTy,-C4LSC_Throwing_MaxVertical,+C4LSC_Throwing_MaxVertical)) return false;
Import source
2009-05-08 13:28:41 +00:00
// Search in direction according to launch fXDir
int32_t iDir=+1; if (fXDir>0) iDir=-1;
// Move along surface
for (int32_t cnt=0; Inside<int32_t>(rX,0,GBackWdt-1) && (cnt<=C4LSC_Throwing_MaxHorizontal); rX+=iDir,cnt++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Adjust to surface
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!SemiAboveSolid(rX,rY)) return false;
Import source
2009-05-08 13:28:41 +00:00
// Check trajectory distance
int32_t itjd = TrajectoryDistance(rX,rY-iHeight,fXDir,fYDir,iTx,iTy);
// Hitting range: success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (itjd<=2) return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Failure
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Import source
2009-05-08 13:28:41 +00:00
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
const int32_t C4LSC_Closest_MaxRange = 200,
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
C4LSC_Closest_Step = 10;
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool FindClosestFree(int32_t &rX, int32_t &rY, int32_t iAngle1, int32_t iAngle2,
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
int32_t iExcludeAngle1, int32_t iExcludeAngle2)
{
Import source
2009-05-08 13:28:41 +00:00
int32_t iX,iY;
for (int32_t iR=C4LSC_Closest_Step; iR<C4LSC_Closest_MaxRange; iR+=C4LSC_Closest_Step)
for (int32_t iAngle=iAngle1; iAngle<iAngle2; iAngle+=C4LSC_Closest_Step)
if (!Inside(iAngle,iExcludeAngle1,iExcludeAngle2))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
iX = rX + fixtoi(Sin(itofix(iAngle))*iR);
iY = rY - fixtoi(Cos(itofix(iAngle))*iR);
if (Inside<int32_t>(iX,0,GBackWdt-1))
if (Inside<int32_t>(iY,0,GBackHgt-1))
if (!GBackSemiSolid(iX,iY))
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
{ rX=iX; rY=iY; return true; }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool ConstructionCheck(C4PropList * PropList, int32_t iX, int32_t iY, C4Object *pByObj)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
C4Value does not store C4IDs anymore Instead, C4IDs are converted from/to C4PropLists. This will have to change, of course. Objects can be created from prototypes which only inherit from C4Def
2009-04-12 12:04:28 +00:00
C4Def *ndef;
// Check def
if (!(ndef=PropList->GetDef()))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Remove a lot of old obsolete palette code Hardcode the few remaining palette references instead. We might want to include some method to customize some colors again, but not for debug display and such things.
2010-06-28 23:02:16 +00:00
if (pByObj) GameMsgObjectError(FormatString(LoadResStr("IDS_OBJ_UNDEF"), PropList->GetName()).getData(),pByObj);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
C4Value does not store C4IDs anymore Instead, C4IDs are converted from/to C4PropLists. This will have to change, of course. Objects can be created from prototypes which only inherit from C4Def
2009-04-12 12:04:28 +00:00
}
// Constructable?
if (!ndef->Constructable)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Remove a lot of old obsolete palette code Hardcode the few remaining palette references instead. We might want to include some method to customize some colors again, but not for debug display and such things.
2010-06-28 23:02:16 +00:00
if (pByObj) GameMsgObjectError(FormatString(LoadResStr("IDS_OBJ_NOCON"),ndef->GetName()).getData(),pByObj);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
C4Value does not store C4IDs anymore Instead, C4IDs are converted from/to C4PropLists. This will have to change, of course. Objects can be created from prototypes which only inherit from C4Def
2009-04-12 12:04:28 +00:00
// Check area
int32_t rtx,rty,wdt,hgt;
wdt=ndef->Shape.Wdt; hgt=ndef->Shape.Hgt-ndef->ConSizeOff;
rtx=iX-wdt/2; rty=iY-hgt;
Merge branch 'proplist'
2009-07-21 14:46:39 +00:00
if (::Landscape.AreaSolidCount(rtx,rty,wdt,hgt)>(wdt*hgt/20))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Remove a lot of old obsolete palette code Hardcode the few remaining palette references instead. We might want to include some method to customize some colors again, but not for debug display and such things.
2010-06-28 23:02:16 +00:00
if (pByObj) GameMsgObjectError(LoadResStr("IDS_OBJ_NOROOM"),pByObj);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Merge branch 'proplist'
2009-07-21 14:46:39 +00:00
if (::Landscape.AreaSolidCount(rtx,rty+hgt,wdt,5)<(wdt*2))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Remove a lot of old obsolete palette code Hardcode the few remaining palette references instead. We might want to include some method to customize some colors again, but not for debug display and such things.
2010-06-28 23:02:16 +00:00
if (pByObj) GameMsgObjectError(LoadResStr("IDS_OBJ_NOLEVEL"),pByObj);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
C4Value does not store C4IDs anymore Instead, C4IDs are converted from/to C4PropLists. This will have to change, of course. Objects can be created from prototypes which only inherit from C4Def
2009-04-12 12:04:28 +00:00
// Check other structures
C4Object *other;
objects: Replace the sorting functionality of Categories with a Plane property This makes changing the drawing order a lot easier.
2010-12-27 19:15:55 +00:00
if ((other=Game.OverlapObject(rtx,rty,wdt,hgt,ndef->GetPlane())))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Remove a lot of old obsolete palette code Hardcode the few remaining palette references instead. We might want to include some method to customize some colors again, but not for debug display and such things.
2010-06-28 23:02:16 +00:00
if (pByObj) GameMsgObjectError(FormatString(LoadResStr("IDS_OBJ_NOOTHER"),other->GetName ()).getData(),pByObj);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
C4Value does not store C4IDs anymore Instead, C4IDs are converted from/to C4PropLists. This will have to change, of course. Objects can be created from prototypes which only inherit from C4Def
2009-04-12 12:04:28 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Finds the next pixel position moving to desired slide.
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::FindMatPath(int32_t &fx, int32_t &fy, int32_t ydir, int32_t mdens, int32_t mslide) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
assert(mdens<=C4M_Solid); // mdens normalized in InsertMaterial
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t cslide;
bool fLeft=true,fRight=true;
// One downwards
if (GetDensity(fx,fy+ydir)<mdens) { fy+=ydir; return true; }
// Find downwards slide path
for (cslide=1; (cslide<=mslide) && (fLeft || fRight); cslide++)
{
// Check left
if (fLeft)
{
if (GetDensity(fx-cslide,fy)>=mdens) // Left clogged
fLeft=false;
else if (GetDensity(fx-cslide,fy+ydir)<mdens) // Left slide okay
{ fx--; return true; }
}
// Check right
if (fRight)
{
if (GetDensity(fx+cslide,fy)>=mdens) // Right clogged
fRight=false;
else if (GetDensity(fx+cslide,fy+ydir)<mdens) // Right slide okay
{ fx++; return true; }
}
}
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Remove C4Wrappers and put most functions in relevant headers This also removes the TickXXX #defines and moves the lookup of predefined materials to C4Material.
2009-06-12 18:52:21 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Finds the closest immediate slide position.
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::FindMatSlide(int32_t &fx, int32_t &fy, int32_t ydir, int32_t mdens, int32_t mslide) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
assert(mdens<=C4M_Solid); // mdens normalized in InsertMaterial and mrfInsertCheck
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t cslide;
bool fLeft=true,fRight=true;
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// One downwards
if (GetDensity(fx,fy+ydir)<mdens) { fy+=ydir; return true; }
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Find downwards slide path
for (cslide=1; (cslide<=mslide) && (fLeft || fRight); cslide++)
{
// Check left
if (fLeft)
{
if (GetDensity(fx-cslide,fy)>=mdens && GetDensity(fx-cslide,fy+ydir)>=mdens) // Left clogged
fLeft=false;
else if (GetDensity(fx-cslide,fy+ydir)<mdens) // Left slide okay
{ fx-=cslide; fy+=ydir; return true; }
}
// Check right
if (fRight)
{
if (GetDensity(fx+cslide,fy)>=mdens && GetDensity(fx+cslide,fy+ydir)>=mdens) // Right clogged
fRight=false;
else if (GetDensity(fx+cslide,fy+ydir)<mdens) // Right slide okay
{ fx+=cslide; fy+=ydir; return true; }
}
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
return false;
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Find closest point with density below mdens. Note this may return a point outside of the landscape,
// Assumption: There are no holes with smaller density inside of material with greater
// density.
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::FindMatPathPush(int32_t &fx, int32_t &fy, int32_t mdens, int32_t mslide, bool liquid) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
// Startpoint must be inside landscape
Rename BoundBy to Clamp "BoundBy" sounds like a predicate. "Clamp" is a common function name for the operation in graphics processing, so it should be familiar to users.
2015-02-12 22:05:55 +00:00
fx = Clamp<int32_t>(fx, 0, Width - 1);
fy = Clamp<int32_t>(fy, 0, Height - 1);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Range to search, calculate bounds
const int32_t iPushRange = 500;
int32_t left = Max<int32_t>(0, fx - iPushRange), right = Min<int32_t>(Width - 1, fx + iPushRange),
top = Max<int32_t>(0, fy - iPushRange), bottom = Min<int32_t>(Height - 1, fy + iPushRange);
// Direction constants
const int8_t R = 0, D = 1, L = 2, U = 3;
int8_t dir = 0;
int32_t x = fx, y = fy;
// Get startpoint density
int32_t dens = GetDensity(fx, fy);
// Smaller density? We're done.
if (dens < mdens)
return true;
// Right density?
else if (dens == mdens)
{
// Find start point for border search
for (int32_t i = 0; ; i++)
if (x - i - 1 < left || GetDensity(x - i - 1, y) != mdens)
{ x -= i; dir = L; break; }
else if (y - i - 1 < top || GetDensity(x, y - i - 1) != mdens)
{ y -= i; dir = U; break; }
else if (x + i + 1 > right || GetDensity(x + i + 1, y) != mdens)
{ x += i; dir = R; break; }
else if (y + i + 1 > bottom || GetDensity(x, y + i + 1) != mdens)
{ y += i; dir = D; break; }
}
// Greater density
else
{
// Try to find a way out
int i = 1;
for (; i < iPushRange; i++)
if (GetDensity(x - i, y) <= mdens)
{ x -= i; dir = R; break; }
else if (GetDensity(x, y - i) <= mdens)
{ y -= i; dir = D; break; }
else if (GetDensity(x + i, y) <= mdens)
{ x += i; dir = L; break; }
else if (GetDensity(x, y + i) <= mdens)
{ y += i; dir = U; break; }
// Not found?
if (i >= iPushRange) return false;
// Done?
if (GetDensity(x, y) < mdens)
{
fx = x; fy = y;
return true;
}
}
// Save startpoint of search
int32_t sx = x, sy = y, sdir = dir;
// Best point so far
bool fGotBest = false; int32_t bx = 0, by = 0, bdist = 0;
// Start searching
do
{
// We should always be in a material of same density
assert(x >= left && y >= top && x <= right && y <= bottom && GetDensity(x, y) == mdens);
// Calc new position
int nx = x, ny = y;
switch (dir)
{
case R: nx++; break;
case D: ny++; break;
case L: nx--; break;
case U: ny--; break;
default: assert(false);
}
// In bounds?
bool fInBounds = (nx >= left && ny >= top && nx <= right && ny <= bottom);
// Get density. Not this performs an SideOpen-check if outside landscape bounds.
int32_t dens = GetDensity(nx, ny);
// Flow possible?
if (dens < mdens)
{
// Calculate "distance".
int32_t dist = Abs(nx - fx) + mslide * (liquid ? fy - ny : Abs(fy - ny));
// New best point?
if (!fGotBest || dist < bdist)
{
// Save it
bx = nx; by = ny; bdist = dist; fGotBest = true;
// Adjust borders: We can obviously safely ignore anything at greater distance
top = Max<int32_t>(top, fy - dist / mslide - 1);
if (!liquid)
{
bottom = Min<int32_t>(bottom, fy + dist / mslide + 1);
left = Max<int32_t>(left, fx - dist - 1);
right = Min<int32_t>(right, fx + dist + 1);
}
// Set new startpoint
sx = x; sy = y; sdir = dir;
}
}
// Step?
if (fInBounds && dens == mdens)
{
// New point
x = nx; y = ny;
// Turn left
(dir += 3) %= 4;
}
// Otherwise: Turn right
else
Remove UB (++x %= y) A construct like ++x %= y assigns to x twice between sequence points. Introduce a sequence point here to make the behavior well-defined.
2014-04-15 12:58:54 +00:00
{
++dir;
dir %= 4;
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
while (x != sx || y != sy || dir != sdir);
// Nothing found?
if (!fGotBest) return false;
// Return it
fx = bx; fy = by;
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
int32_t C4Landscape::AreaSolidCount(int32_t x, int32_t y, int32_t wdt, int32_t hgt) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
int32_t cx,cy,ascnt=0;
for (cy=y; cy<y+hgt; cy++)
for (cx=x; cx<x+wdt; cx++)
if (GBackSolid(cx,cy))
ascnt++;
return ascnt;
}
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
void C4Landscape::FindMatTop(int32_t mat, int32_t &x, int32_t &y, bool distant_first) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
int32_t mslide,cslide,tslide,distant_x=0;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
bool fLeft,fRight;
if (!MatValid(mat)) return;
mslide=::MaterialMap.Map[mat].MaxSlide;
do
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
// Catch most common case: Walk upwards until material changes
while (GetMat(x,y-1)==mat) --y;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Find upwards slide
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
fLeft=true; fRight=true; tslide=0; distant_x=x;
for (cslide=1; (cslide<=mslide) && (fLeft || fRight); cslide++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Left
if (fLeft)
{
if (GetMat(x-cslide,y)!=mat) fLeft=false;
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
else
{
distant_x = x-cslide;
if (GetMat(distant_x,y-1)==mat) { tslide=-cslide; break; }
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
// Right
if (fRight)
{
if (GetMat(x+cslide,y)!=mat) fRight=false;
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
else
{
distant_x = x+cslide;
if (GetMat(distant_x,y-1)==mat) { tslide=+cslide; break; }
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// Slide
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
if (tslide) { x+=tslide; y--; }
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
while (tslide);
Fix pump to clear the last row of pixels (#1057) and allow pumping from pump without source pipe. ExtractMaterial has been changed to be able to slurp in from the most distant horizontal position rather than the closest to the extraction top center. Also speed up ExtractMaterial for the common case of no required horizontal shifts.
2015-05-01 16:04:42 +00:00
// return top pixel max slide away from center if desired
if (distant_first) x = distant_x;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* ++++++++++++++ Editor mode (draw landscape with brush)+++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool C4Landscape::SetMode(int32_t iMode)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Invalid mode
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!Inside<int32_t>(iMode,C4LSC_Dynamic,C4LSC_Exact)) return false;
Import source
2009-05-08 13:28:41 +00:00
// Set mode
Mode=iMode;
// Done
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::GetMapColorIndex(const char *szMaterial, const char *szTexture, BYTE & rbyCol) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Sky
if (SEqual(szMaterial,C4TLS_MatSky))
rbyCol=0;
// Material-Texture
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!(rbyCol=::TextureMap.GetIndex(szMaterial,szTexture))) return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// Found
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
bool C4Landscape::DrawBrush(int32_t iX, int32_t iY, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
BYTE byCol, byColBkg;
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get map color index by material-texture
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!GetMapColorIndex(szMaterial,szTexture,byCol)) return false;
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
if (!GetMapColorIndex(szBackMaterial,szBackTexture,byColBkg)) return false;
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get material shape size
int32_t mat = PixCol2Mat(byCol);
int32_t shape_wdt=0, shape_hgt=0;
if (mat>=0 && MaterialMap.Map[mat].CustomShape)
{
shape_wdt = MaterialMap.Map[mat].CustomShape->max_poly_width/MapZoom;
shape_hgt = MaterialMap.Map[mat].CustomShape->max_poly_height/MapZoom;
}
// Draw
Import source
2009-05-08 13:28:41 +00:00
switch (Mode)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Dynamic: ignore
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Dynamic:
break;
Import source
2009-05-08 13:28:41 +00:00
// Static: draw to map by material-texture-index, chunk-o-zoom to landscape
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Static:
// Draw to map
int32_t iRadius; iRadius=Max<int32_t>(2*iGrade/MapZoom,1);
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
if (iRadius==1) { Map->SetPix(iX/MapZoom,iY/MapZoom,byCol); MapBkg->SetPix(iX/MapZoom, iY/MapZoom, byColBkg); }
else { Map->Circle(iX/MapZoom,iY/MapZoom,iRadius,byCol); MapBkg->Circle(iX/MapZoom, iY/MapZoom, iRadius, byColBkg); }
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
// Update landscape
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapToLandscape(Map,MapBkg,iX/MapZoom-iRadius-1-shape_wdt,iY/MapZoom-iRadius-1-shape_hgt,2*iRadius+2+shape_wdt*2,2*iRadius+2+shape_hgt*2);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
SetMapChanged();
break;
Import source
2009-05-08 13:28:41 +00:00
// Exact: draw directly to landscape by color & pattern
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Exact:
C4Rect BoundingBox(iX-iGrade-1, iY-iGrade-1, iGrade*2+2, iGrade*2+2);
// Draw to landscape
PrepareChange(BoundingBox);
Surface8->Circle(iX,iY,iGrade, byCol);
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
Surface8Bkg->Circle(iX,iY,iGrade, byColBkg);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
FinishChange(BoundingBox);
break;
Import source
2009-05-08 13:28:41 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::DrawLineLandscape(int32_t iX, int32_t iY, int32_t iGrade, uint8_t line_color, uint8_t line_color_bkg)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
Surface8->Circle(iX, iY, iGrade, line_color);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
Surface8Bkg->Circle(iX, iY, iGrade, line_color_bkg);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool C4Landscape::DrawLineMap(int32_t iX, int32_t iY, int32_t iRadius, uint8_t line_color, uint8_t line_color_bkg)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
if (!Map) return false;
if (iRadius == 1)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
{ Map->SetPix(iX, iY, line_color); MapBkg->SetPix(iX, iY, line_color_bkg); }
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
else
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
{ Map->Circle(iX, iY, iRadius, line_color); MapBkg->Circle(iX, iY, iRadius, line_color_bkg); }
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
bool C4Landscape::DrawLine(int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get map color index by material-texture
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
uint8_t line_color, line_color_bkg;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!GetMapColorIndex(szMaterial,szTexture,line_color)) return false;
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
if (!GetMapColorIndex(szBackMaterial,szBackTexture,line_color_bkg)) return false;
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get material shape size
Make ForLine take a functor instead of a raw pointer This means we can drop the opaque parameter. Where additional data is required, a lambda is the way to go here. It also means we don't have to put half of the parameters into a global variable.
2015-02-23 11:43:13 +00:00
int32_t mat = PixCol2Mat(line_color);
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
int32_t shape_wdt=0, shape_hgt=0;
if (mat>=0 && MaterialMap.Map[mat].CustomShape)
{
shape_wdt = MaterialMap.Map[mat].CustomShape->max_poly_width/MapZoom;
shape_hgt = MaterialMap.Map[mat].CustomShape->max_poly_height/MapZoom;
}
// Draw
Import source
2009-05-08 13:28:41 +00:00
switch (Mode)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Dynamic: ignore
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Dynamic:
break;
Import source
2009-05-08 13:28:41 +00:00
// Static: draw to map by material-texture-index, chunk-o-zoom to landscape
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Static:
// Draw to map
int32_t iRadius; iRadius=Max<int32_t>(2*iGrade/MapZoom,1);
iX1/=MapZoom; iY1/=MapZoom; iX2/=MapZoom; iY2/=MapZoom;
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
ForLine(iX1, iY1, iX2, iY2, [this, line_color, line_color_bkg, iRadius](int32_t x, int32_t y) { return DrawLineMap(x, y, iRadius, line_color, line_color_bkg); });
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
// Update landscape
int32_t iUpX,iUpY,iUpWdt,iUpHgt;
iUpX=Min(iX1,iX2)-iRadius-1; iUpY=Min(iY1,iY2)-iRadius-1;
iUpWdt=Abs(iX2-iX1)+2*iRadius+2; iUpHgt=Abs(iY2-iY1)+2*iRadius+2;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapToLandscape(Map,MapBkg,iUpX-shape_wdt,iUpY-shape_hgt,iUpWdt+shape_wdt*2,iUpHgt+shape_hgt*2);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
SetMapChanged();
break;
Import source
2009-05-08 13:28:41 +00:00
// Exact: draw directly to landscape by color & pattern
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Exact:
// Set texture pattern & get material color
C4Rect BoundingBox(iX1 - iGrade, iY1 - iGrade, iGrade*2+1, iGrade*2+1);
BoundingBox.Add(C4Rect(iX2 - iGrade, iY2 - iGrade, iGrade*2+1, iGrade*2+1));
// Draw to landscape
PrepareChange(BoundingBox);
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
ForLine(iX1, iY1, iX2, iY2, [this, line_color, line_color_bkg, iGrade](int32_t x, int32_t y) { return DrawLineLandscape(x, y, iGrade, line_color, line_color_bkg); });
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
FinishChange(BoundingBox);
break;
Import source
2009-05-08 13:28:41 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
bool C4Landscape::DrawBox(int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// get upper-left/lower-right - corners
int32_t iX0=Min(iX1, iX2); int32_t iY0=Min(iY1, iY2);
iX2=Max(iX1, iX2); iY2=Max(iY1, iY2); iX1=iX0; iY1=iY0;
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
BYTE byCol, byColBkg;
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get map color index by material-texture
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!GetMapColorIndex(szMaterial,szTexture,byCol)) return false;
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
if (!GetMapColorIndex(szBackMaterial,szBackTexture,byColBkg)) return false;
Added custom shapes for Map2Landscape zoom
2011-07-16 19:50:49 +00:00
// Get material shape size
int32_t mat = PixCol2Mat(byCol);
int32_t shape_wdt=0, shape_hgt=0;
if (mat>=0 && MaterialMap.Map[mat].CustomShape)
{
shape_wdt = MaterialMap.Map[mat].CustomShape->max_poly_width/MapZoom;
shape_hgt = MaterialMap.Map[mat].CustomShape->max_poly_height/MapZoom;
}
// Draw
Import source
2009-05-08 13:28:41 +00:00
switch (Mode)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Dynamic: ignore
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Dynamic:
break;
Import source
2009-05-08 13:28:41 +00:00
// Static: draw to map by material-texture-index, chunk-o-zoom to landscape
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Static:
// Draw to map
iX1/=MapZoom; iY1/=MapZoom; iX2/=MapZoom; iY2/=MapZoom;
Map->Box(iX1,iY1,iX2,iY2,byCol);
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
MapBkg->Box(iX1, iY1, iX2, iY2, byColBkg);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
// Update landscape
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
MapToLandscape(Map,MapBkg,iX1-1-shape_wdt,iY1-1-shape_hgt,iX2-iX1+3+shape_wdt*2,iY2-iY1+3+shape_hgt*2);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
SetMapChanged();
break;
Import source
2009-05-08 13:28:41 +00:00
// Exact: draw directly to landscape by color & pattern
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
case C4LSC_Exact:
C4Rect BoundingBox(iX1, iY1, iX2 - iX1+1, iY2 - iY1+1);
// Draw to landscape
PrepareChange(BoundingBox);
Surface8->Box(iX1,iY1,iX2,iY2,byCol);
Update GTK+ editor so that one can draw background materials
2015-07-15 02:37:12 +00:00
Surface8Bkg->Box(iX1,iY1,iX2,iY2,byColBkg);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
FinishChange(BoundingBox);
break;
Import source
2009-05-08 13:28:41 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool C4Landscape::DrawChunks(int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, int32_t icntx, int32_t icnty, const char *szMaterial, const char *szTexture, bool bIFT)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
BYTE byColor;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (!GetMapColorIndex(szMaterial, szTexture, byColor)) return false;
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
int32_t iMaterial = ::MaterialMap.Get(szMaterial); if (!MatValid(iMaterial)) return false;
Added Scenario [Landscape] FlatChunkShapes. If set to true, all chunks are drawn flat. Useful for scenario editing to fix little holes in your static landscape.
2013-01-20 11:51:33 +00:00
C4MaterialCoreShape shape = ::Game.C4S.Landscape.FlatChunkShapes ? C4M_Flat : ::MaterialMap.Map[iMaterial].MapChunkType;
Import source
2009-05-08 13:28:41 +00:00
C4Rect BoundingBox(tx - 5, ty - 5, wdt + 10, hgt + 10);
PrepareChange(BoundingBox);
// assign clipper
Surface8->Clip(BoundingBox.x,BoundingBox.y,BoundingBox.x+BoundingBox.Wdt,BoundingBox.y+BoundingBox.Hgt);
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->Clip(BoundingBox.x,BoundingBox.y,BoundingBox.x+BoundingBox.Wdt,BoundingBox.y+BoundingBox.Hgt);
Rename lpDDraw to pDraw
2011-10-03 14:30:18 +00:00
pDraw->NoPrimaryClipper();
Import source
2009-05-08 13:28:41 +00:00
// draw all chunks
int32_t x, y;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (x = 0; x < icntx; x++)
for (y = 0; y < icnty; y++)
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
DrawChunk(tx+wdt*x/icntx,ty+hgt*y/icnty,wdt/icntx,hgt/icnty,byColor,bIFT ? DefaultBkgMat(byColor) : 0, shape,Random(1000));
Import source
2009-05-08 13:28:41 +00:00
// remove clipper
Surface8->NoClip();
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->NoClip();
Import source
2009-05-08 13:28:41 +00:00
FinishChange(BoundingBox);
// success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
C4Rect C4Landscape::getBoundingBox(int *vtcs, int length) const
{
fixed #620 (Loam bridges sometimes do not update the landscape texture properly)
2011-08-14 22:24:22 +00:00
C4Rect BoundingBox(vtcs[0],vtcs[1],1,1);
for(int32_t i=2; i+1 < length; i+=2)
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
{
fixed #620 (Loam bridges sometimes do not update the landscape texture properly)
2011-08-14 22:24:22 +00:00
BoundingBox.Add(C4Rect(vtcs[i],vtcs[i+1],1,1));
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
}
return BoundingBox;
}
Allow script functions to access background landscape Add GetBackMaterial() and GetBackTexture(), and allow DrawMaterialQuad to specify a background mat-tex combination.
2015-07-14 01:02:38 +00:00
bool C4Landscape::DrawPolygon(int *vtcs, int length, const char *szMaterial, const char* szBackMaterial, bool fDrawBridge)
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
{
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
if(length < 6) return false;
if(length % 2 == 1) return false;
Import source
2009-05-08 13:28:41 +00:00
// get texture
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
int32_t iMatTex = ::TextureMap.GetIndexMatTex(szMaterial);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (!iMatTex) return false;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
uint8_t mcol = MatTex2PixCol(iMatTex);
Allow script functions to access background landscape Add GetBackMaterial() and GetBackTexture(), and allow DrawMaterialQuad to specify a background mat-tex combination.
2015-07-14 01:02:38 +00:00
// get background texture
uint8_t mcolBkg = 0;
if (szBackMaterial != NULL)
{
const int32_t iBackMatTex = ::TextureMap.GetIndexMatTex(szBackMaterial);
if (!iBackMatTex) return false;
mcolBkg = MatTex2PixCol(iBackMatTex);
}
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
// do bridging?
uint8_t *conversion_map = NULL;
if (fDrawBridge)
{
Fix DrawMaterialQuad with DMQ_Bridge and non-default texture settings
2013-04-08 17:33:20 +00:00
conversion_map = GetBridgeMatConversion(MatTex2PixCol(iMatTex));
Rename C4Landscape::TRANSPARENT to C4Landscape::Transparent Some stupid windows header seems to have a #define for TRANSPARENT.
2015-08-05 03:15:52 +00:00
mcolBkg = Transparent;
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
}
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
// prepare pixel count update
Implemented free shapes (=polygons) to be added or cleared from the landscape: + Refactored the ShakeFree, BlastFree, DigFree, DrawQuad etc. functions and removed unused functions ClearRectDensity, DigFreeMaterial,... + Moved the polygon fill algorithm from StdSurface8.cpp to C4Landscape.cpp + Clearance functions which used to subtract a circle now subtract something that looks more like a chunk + Pickaxe works with BlastFree now + Removed Dig2ObjectRequest
2011-05-30 22:33:35 +00:00
C4Rect BoundingBox = getBoundingBox(vtcs,length);
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
// draw polygon
PrepareChange(BoundingBox);
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
ForPolygon(vtcs,length/2,NULL,NULL, mcol, mcolBkg, conversion_map);
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
FinishChange(BoundingBox);
return true;
}
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
uint8_t *C4Landscape::GetBridgeMatConversion(int32_t for_material_col) const
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
// safety
Fix DrawMaterialQuad with DMQ_Bridge and non-default texture settings
2013-04-08 17:33:20 +00:00
int32_t for_material = GetPixMat(for_material_col);
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (for_material < 0 || for_material >= MaterialMap.Num) return NULL;
// query map. create if not done yet
Fix DrawMaterialQuad with DMQ_Bridge and non-default texture settings
2013-04-08 17:33:20 +00:00
uint8_t *conv_map = BridgeMatConversion[for_material_col];
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
if (!conv_map)
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
conv_map = new uint8_t[C4M_MaxTexIndex];
for (int32_t i=0; i < C4M_MaxTexIndex; ++i)
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Adjusted PXS code for cases of PXS-density > C4M_Solid (#944).
2013-03-30 13:05:12 +00:00
if ( (MatDensity(for_material)>=GetPixDensity(i)))
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
// bridge pixel OK here. change pixel.
conv_map[i] = for_material_col;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
else
{
// bridge pixel not OK - keep current pixel
conv_map[i] = i;
}
}
BridgeMatConversion[for_material] = conv_map;
}
return conv_map;
}
Allow script functions to access background landscape Add GetBackMaterial() and GetBackTexture(), and allow DrawMaterialQuad to specify a background mat-tex combination.
2015-07-14 01:02:38 +00:00
bool C4Landscape::DrawQuad(int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iX3, int32_t iY3, int32_t iX4, int32_t iY4, const char *szMaterial, const char *szBackMaterial, bool fDrawBridge)
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// set vertices
new function DrawMaterialPolygon
2011-05-29 20:37:40 +00:00
int32_t vtcs[8];
Import source
2009-05-08 13:28:41 +00:00
vtcs[0] = iX1; vtcs[1] = iY1;
vtcs[2] = iX2; vtcs[3] = iY2;
vtcs[4] = iX3; vtcs[5] = iY3;
vtcs[6] = iX4; vtcs[7] = iY4;
Allow script functions to access background landscape Add GetBackMaterial() and GetBackTexture(), and allow DrawMaterialQuad to specify a background mat-tex combination.
2015-07-14 01:02:38 +00:00
return DrawPolygon(vtcs, 8, szMaterial, szBackMaterial, fDrawBridge);
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
BYTE C4Landscape::GetMapIndex(int32_t iX, int32_t iY) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
if (!Map) return 0;
return Map->GetPix(iX,iY);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Some refactoring, and restore support for Map.bmp The new behaviour that allows 255 mat-tex combinations (once we increased C4M_MaxTexCount...) is enabled with MapFg.bmp, and then MapBg.bmp can be used to draw IFT or other fancy things.
2015-07-01 01:58:42 +00:00
BYTE C4Landscape::GetBackMapIndex(int32_t iX, int32_t iY) const
{
if (!MapBkg) return 0;
return MapBkg->GetPix(iX,iY);
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::PrepareChange(C4Rect BoundingBox)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// move solidmasks out of the way
C4Rect SolidMaskRect = BoundingBox;
if (pLandscapeRender)
SolidMaskRect = pLandscapeRender->GetAffectedRect(pLandscapeRender->GetAffectedRect(SolidMaskRect));
for (C4SolidMask * pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
{
pSolid->RemoveTemporary(SolidMaskRect);
}
UpdateMatCnt(BoundingBox, false);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::FinishChange(C4Rect BoundingBox)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Fix crash on ambient map update outside landscape bounds (#1216)
2015-01-06 10:47:25 +00:00
// Intersect bounding box with landscape
BoundingBox.Intersect(C4Rect(0, 0, Width, Height));
Fix assertion on landscape changes outside landscape rectangle (#1232)
2015-01-25 17:23:43 +00:00
if (!BoundingBox.Wdt || !BoundingBox.Hgt) return;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// update render
if(pLandscapeRender)
pLandscapeRender->Update(BoundingBox, this);
UpdateMatCnt(BoundingBox, true);
// Restore Solidmasks
C4Rect SolidMaskRect = BoundingBox;
if (pLandscapeRender)
SolidMaskRect = pLandscapeRender->GetAffectedRect(pLandscapeRender->GetAffectedRect(SolidMaskRect));
for (C4SolidMask * pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
Import source
2009-05-08 13:28:41 +00:00
{
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
pSolid->Repair(SolidMaskRect);
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
C4SolidMask::CheckConsistency();
UpdatePixCnt(BoundingBox);
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
// update FoW
if (pFoW)
Update ambient map on landscape changes
2014-11-18 20:42:00 +00:00
{
FoW/lights preview This is pretty much still prototype stage. Lots of bug, lots of stuff missing.
2012-08-19 18:35:10 +00:00
pFoW->Invalidate(BoundingBox);
Update ambient map on landscape changes
2014-11-18 20:42:00 +00:00
pFoW->Ambient.UpdateFromLandscape(*this, BoundingBox);
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* ++++++++++++++++++ Functions for Script interface +++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
added parameter for DrawMap and DrawDefMap to retain old material if sky is drawn
2012-02-10 20:48:48 +00:00
bool C4Landscape::DrawMap(int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, const char *szMapDef, bool ignoreSky)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// safety
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!szMapDef) return false;
Import source
2009-05-08 13:28:41 +00:00
// clip to landscape size
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!ClipRect(iX, iY, iWdt, iHgt)) return false;
Import source
2009-05-08 13:28:41 +00:00
// get needed map size
int32_t iMapWdt=(iWdt-1)/MapZoom+1;
int32_t iMapHgt=(iHgt-1)/MapZoom+1;
C4SLandscape FakeLS=Game.C4S.Landscape;
FakeLS.MapWdt.Set(iMapWdt, 0, iMapWdt, iMapWdt);
FakeLS.MapHgt.Set(iMapHgt, 0, iMapHgt, iMapHgt);
// create map creator
Move Game.Material to ::MaterialMap
2009-06-05 18:46:03 +00:00
C4MapCreatorS2 MapCreator(&FakeLS, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount);
Import source
2009-05-08 13:28:41 +00:00
// read file
MapCreator.ReadScript(szMapDef);
// render map
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
CSurface8* sfcMap = NULL;
CSurface8* sfcMapBkg = NULL;
if (!MapCreator.Render(NULL, sfcMap, sfcMapBkg))
return false;
Import source
2009-05-08 13:28:41 +00:00
// map it to the landscape
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
bool fSuccess=MapToLandscape(sfcMap, sfcMapBkg, 0, 0, iMapWdt, iMapHgt, iX, iY, ignoreSky);
Import source
2009-05-08 13:28:41 +00:00
// cleanup
delete sfcMap;
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
delete sfcMapBkg;
Import source
2009-05-08 13:28:41 +00:00
// return whether successful
return fSuccess;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
added parameter for DrawMap and DrawDefMap to retain old material if sky is drawn
2012-02-10 20:48:48 +00:00
bool C4Landscape::DrawDefMap(int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, const char *szMapDef, bool ignoreSky)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// safety
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!szMapDef || !pMapCreator) return false;
Import source
2009-05-08 13:28:41 +00:00
// clip to landscape size
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!ClipRect(iX, iY, iWdt, iHgt)) return false;
Import source
2009-05-08 13:28:41 +00:00
// get needed map size
int32_t iMapWdt=(iWdt-1)/MapZoom+1;
int32_t iMapHgt=(iHgt-1)/MapZoom+1;
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool fSuccess=false;
Import source
2009-05-08 13:28:41 +00:00
// render map
C4MCMap *pMap=pMapCreator->GetMap(szMapDef);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
if (!pMap) return false;
Import source
2009-05-08 13:28:41 +00:00
pMap->SetSize(iMapWdt, iMapHgt);
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
CSurface8* sfcMap = NULL;
CSurface8* sfcMapBkg = NULL;
if(pMapCreator->Render(szMapDef, sfcMap, sfcMapBkg))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// map to landscape
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
fSuccess = MapToLandscape(sfcMap, sfcMapBkg, 0, 0, iMapWdt, iMapHgt, iX, iY, ignoreSky);
Import source
2009-05-08 13:28:41 +00:00
// cleanup
delete sfcMap;
Make the C4MapCreatorS2 create background maps
2015-07-01 00:29:52 +00:00
delete sfcMapBkg;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// done
return fSuccess;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Improve C4Landscape const correctness
2015-01-15 18:12:56 +00:00
bool C4Landscape::ClipRect(int32_t &rX, int32_t &rY, int32_t &rWdt, int32_t &rHgt) const
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// clip by bounds
if (rX<0) { rWdt+=rX; rX=0; }
if (rY<0) { rHgt+=rY; rY=0; }
int32_t iOver;
iOver=rX+rWdt-Width; if (iOver>0) { rWdt-=iOver; }
iOver=rY+rHgt-Height; if (iOver>0) { rHgt-=iOver; }
// anything left inside the bounds?
return rWdt>0 && rHgt>0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
bool C4Landscape::ReplaceMapColor(BYTE iOldIndex, BYTE iNewIndex)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// find every occurance of iOldIndex in map; replace it by new index
if (!Map) return false;
int iPitch, iMapWdt, iMapHgt;
BYTE *pMap = Map->Bits;
iMapWdt = Map->Wdt;
iMapHgt = Map->Hgt;
iPitch = Map->Pitch;
if (!pMap) return false;
for (int32_t y=0; y<iMapHgt; ++y)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
for (int32_t x=0; x<iMapWdt; ++x)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (*pMap == iOldIndex)
*pMap = iNewIndex;
Import source
2009-05-08 13:28:41 +00:00
++pMap;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
pMap += iPitch - iMapWdt;
Import source
2009-05-08 13:28:41 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
return true;
}
Import source
2009-05-08 13:28:41 +00:00
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
bool C4Landscape::SetTextureIndex(const char *szMatTex, BYTE iNewIndex, bool fInsert)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (((!szMatTex || !*szMatTex) && !fInsert) || !Inside<int>(iNewIndex, 1, C4M_MaxTexIndex - 1))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
DebugLogF("Cannot insert new texture %s to index %d: Invalid parameters.", (const char *) szMatTex, (int) iNewIndex);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// get last mat index - returns zero for not found (valid for insertion mode)
StdStrBuf Material, Texture;
Material.CopyUntil(szMatTex, '-'); Texture.Copy(SSearch(szMatTex, "-"));
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
BYTE iOldIndex = (szMatTex && *szMatTex) ? ::TextureMap.GetIndex(Material.getData(), Texture.getData(), false) : 0;
Import source
2009-05-08 13:28:41 +00:00
// insertion mode?
if (fInsert)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// there must be room to move up to
BYTE byLastMoveIndex = C4M_MaxTexIndex - 1;
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
while (::TextureMap.GetEntry(byLastMoveIndex))
Import source
2009-05-08 13:28:41 +00:00
if (--byLastMoveIndex == iNewIndex)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
DebugLogF("Cannot insert new texture %s to index %d: No room for insertion.", (const char *) szMatTex, (int) iNewIndex);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// then move up all other textures first
// could do this in one loop, but it's just a developement call anyway, so move one index at a time
while (--byLastMoveIndex >= iNewIndex)
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
if (::TextureMap.GetEntry(byLastMoveIndex))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
ReplaceMapColor(byLastMoveIndex, byLastMoveIndex+1);
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
::TextureMap.MoveIndex(byLastMoveIndex, byLastMoveIndex+1);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// new insertion desired?
if (szMatTex && *szMatTex)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// move from old or create new
if (iOldIndex)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
ReplaceMapColor(iOldIndex, iNewIndex);
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
::TextureMap.MoveIndex(iOldIndex, iNewIndex);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
StdStrBuf Material, Texture;
Material.CopyUntil(szMatTex, '-'); Texture.Copy(SSearch(szMatTex, "-"));
// new insertion
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
if (!::TextureMap.AddEntry(iNewIndex, Material.getData(), Texture.getData()))
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
LogF("Cannot insert new texture %s to index %d: Texture map entry error", (const char *) szMatTex, (int) iNewIndex);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Import source
2009-05-08 13:28:41 +00:00
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// done, success
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// new index must not be occupied
const C4TexMapEntry *pOld;
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
if ((pOld = ::TextureMap.GetEntry(iNewIndex)) && !pOld->isNull())
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
DebugLogF("Cannot move texture %s to index %d: Index occupied by %s-%s.", (const char *) szMatTex, (int) iNewIndex, pOld->GetMaterialName(), pOld->GetTextureName());
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// must only move existing textures
if (!iOldIndex)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
DebugLogF("Cannot move texture %s to index %d: Texture not found.", (const char *) szMatTex, (int) iNewIndex);
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return false;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// update map
ReplaceMapColor(iOldIndex, iNewIndex);
// change to new index in texmap
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
::TextureMap.MoveIndex(iOldIndex, iNewIndex);
Import source
2009-05-08 13:28:41 +00:00
// done, success
Replace BOOL by bool, TRUE by true, FALSE by false
2009-08-15 18:50:32 +00:00
return true;
Import source
2009-05-08 13:28:41 +00:00
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
void C4Landscape::RemoveUnusedTexMapEntries()
{
// check usage in landscape
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
bool fTexUsage[C4M_MaxTexIndex];
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
int32_t iMatTex;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (iMatTex = 0; iMatTex < C4M_MaxTexIndex; ++iMatTex)
fTexUsage[iMatTex] = false;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
for (int32_t y=0; y<Height; ++y)
for (int32_t x=0; x<Width; ++x)
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
{
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
const BYTE pix = Surface8->GetPix(x, y);
const BYTE backPix = Surface8Bkg->GetPix(x, y);
assert(pix < C4M_MaxTexIndex);
assert(backPix < C4M_MaxTexIndex);
fTexUsage[pix] = true;
fTexUsage[backPix] = true;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
}
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
// check usage by materials
for (int32_t iMat = 0; iMat < ::MaterialMap.Num; ++iMat)
{
C4Material *pMat = ::MaterialMap.Map + iMat;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
if (pMat->BlastShiftTo >= 0) fTexUsage[pMat->BlastShiftTo] = true;
if (pMat->BelowTempConvertTo >= 0) fTexUsage[pMat->BelowTempConvertTo] = true;
if (pMat->AboveTempConvertTo >= 0) fTexUsage[pMat->AboveTempConvertTo] = true;
if (pMat->DefaultMatTex >= 0) fTexUsage[pMat->DefaultMatTex] = true;
Cleaned up C4Landscape.cpp, fixed bug that pickaxe does not produce any materials
2011-05-31 01:04:38 +00:00
}
// remove unused
for (iMatTex = 1; iMatTex < C4M_MaxTexIndex; ++iMatTex)
if (!fTexUsage[iMatTex])
::TextureMap.RemoveEntry(iMatTex);
// flag rewrite
::TextureMap.fEntriesAdded = true;
}
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++ Update functions ++++++++++++++++++++++++++++ */
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::HandleTexMapUpdate()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
// Pixel maps must be update
UpdatePixMaps();
// Update landscape palette
Mat2Pal();
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::UpdatePixMaps()
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t i;
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (i = 0; i < C4M_MaxTexIndex; i++) Pix2Mat[i] = PixCol2Mat(i);
for (i = 0; i < C4M_MaxTexIndex; i++) Pix2Dens[i] = MatDensity(Pix2Mat[i]);
for (i = 0; i < C4M_MaxTexIndex; i++) Pix2Place[i] = MatValid(Pix2Mat[i]) ? ::MaterialMap.Map[Pix2Mat[i]].Placement : 0;
for (i = 0; i < C4M_MaxTexIndex; i++) Pix2Light[i] = MatValid(Pix2Mat[i]) && (::MaterialMap.Map[Pix2Mat[i]].Light>0);
Import source
2009-05-08 13:28:41 +00:00
Pix2Place[0] = 0;
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
// clear bridge mat conversion buffers
Introduce background map The background landscape is generated from the background map.
2015-06-22 22:56:04 +00:00
for (int32_t i = 0; i < C4M_MaxTexIndex; ++i)
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
{
delete [] BridgeMatConversion[i];
BridgeMatConversion[i] = NULL;
Import source
2009-05-08 13:28:41 +00:00
}
loam bridge retain IFT and dont draw over higher density (#85, #125)
2010-02-09 19:09:32 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
bool C4Landscape::Mat2Pal()
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
if (!Surface8 || !Surface8Bkg) return false;
Import source
2009-05-08 13:28:41 +00:00
// set landscape pal
Remove some unused variables
2012-12-22 23:11:08 +00:00
int32_t tex;
Import source
2009-05-08 13:28:41 +00:00
for (tex=0; tex<C4M_MaxTexIndex; tex++)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Move Game.TextureMap to TextureMap
2009-06-05 15:09:54 +00:00
const C4TexMapEntry *pTex = ::TextureMap.GetEntry(tex);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (!pTex || pTex->isNull())
Import source
2009-05-08 13:28:41 +00:00
continue;
// colors
Material: Remove color field, use textures as is This also removes ColorByMaterial, which was alread unused in CE and CR.
2009-07-24 21:50:04 +00:00
DWORD dwPix = pTex->GetPattern().PatternClr(0, 0);
Store all channels of a color together in CStdPalette This mostly simplifies things, since most other places use an 32 bit integer to store colors, but might even improve performance through better cache locality.
2012-08-15 22:45:27 +00:00
Surface8->pPal->Colors[MatTex2PixCol(tex)] = dwPix;
Introduce background landscape The background landscape is a 8-bit landscape which stores the material that a particular pixel will be replaced with when it is cleared, e.g. by digging or blasting. This is just the groundwork for this and does not offer much advantage over the IFT flag that was used previously for that purpose. However, additional features such as keeping the background material/texture fixed when loam bridges are built, PXS are incorporated into the landscape or the massmover is moving things around can be added. See http://bugs.openclonk.org/view.php?id=1338 for more details.
2015-06-17 00:58:43 +00:00
Surface8Bkg->pPal->Colors[MatTex2PixCol(tex)] = dwPix;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
// success
return true;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::UpdatePixCnt(const C4Rect &Rect, bool fCheck)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Import source
2009-05-08 13:28:41 +00:00
int32_t PixCntWidth = (Width + 16) / 17;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (int32_t y = Max<int32_t>(0, Rect.y / 15); y < Min<int32_t>(PixCntPitch, (Rect.y + Rect.Hgt + 14) / 15); y++)
for (int32_t x = Max<int32_t>(0, Rect.x / 17); x < Min<int32_t>(PixCntWidth, (Rect.x + Rect.Wdt + 16) / 17); x++)
{
Import source
2009-05-08 13:28:41 +00:00
int iCnt = 0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (int32_t x2 = x * 17; x2 < Min<int32_t>(x * 17 + 17, Width); x2++)
for (int32_t y2 = y * 15; y2 < Min<int32_t>(y * 15 + 15, Height); y2++)
if (_GetDensity(x2, y2))
Import source
2009-05-08 13:28:41 +00:00
iCnt++;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (fCheck)
Import source
2009-05-08 13:28:41 +00:00
assert(iCnt == PixCnt[x * PixCntPitch + y]);
PixCnt[x * PixCntPitch + y] = iCnt;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
}
Import source
2009-05-08 13:28:41 +00:00
void C4Landscape::UpdateMatCnt(C4Rect Rect, bool fPlus)
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
Rect.Intersect(C4Rect(0, 0, Width, Height));
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (!Rect.Hgt || !Rect.Wdt) return;
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Multiplicator for changes
const int32_t iMul = fPlus ? +1 : -1;
// Count pixels
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
for (int32_t x = 0; x < Rect.Wdt; x++)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int iHgt = 0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
int32_t y;
for (y = 1; y < Rect.Hgt; y++)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int32_t iMat = _GetMat(Rect.x+x, Rect.y+y - 1);
// Same material? Count it.
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iMat == _GetMat(Rect.x+x, Rect.y+y))
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
iHgt++;
else
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
{
if (iMat >= 0)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
{
// Normal material counting
MatCount[iMat] += iMul * (iHgt + 1);
// Effective material counting enabled?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (int32_t iMinHgt = ::MaterialMap.Map[iMat].MinHeightCount)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// First chunk? Add any material above when checking chunk height
int iAddedHeight = 0;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (Rect.y && iHgt + 1 == y)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
iAddedHeight = GetMatHeight(Rect.x+x, Rect.y-1, -1, iMat, iMinHgt);
// Check the chunk height
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iHgt + 1 + iAddedHeight >= iMinHgt)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
EffectiveMatCount[iMat] += iMul * (iHgt + 1);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iAddedHeight < iMinHgt)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
EffectiveMatCount[iMat] += iMul * iAddedHeight;
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Next chunk of material
iHgt = 0;
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Check last pixel
int32_t iMat = _GetMat(Rect.x+x, Rect.y+Rect.Hgt-1);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iMat >= 0)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
// Normal material counting
MatCount[iMat] += iMul * (iHgt + 1);
// Minimum height counting?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (int32_t iMinHgt = ::MaterialMap.Map[iMat].MinHeightCount)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
int iAddedHeight1 = 0, iAddedHeight2 = 0;
// Add any material above for chunk size check
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (Rect.y && iHgt + 1 == Rect.Hgt)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
iAddedHeight1 = GetMatHeight(Rect.x+x, Rect.y-1, -1, iMat, iMinHgt);
// Add any material below for chunk size check
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (Rect.y+y < Height)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
iAddedHeight2 = GetMatHeight(Rect.x+x, Rect.y+Rect.Hgt, 1, iMat, iMinHgt);
// Chunk tall enough?
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iHgt + 1 + iAddedHeight1 + iAddedHeight2 >= ::MaterialMap.Map[iMat].MinHeightCount)
{
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
EffectiveMatCount[iMat] += iMul * (iHgt + 1);
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iAddedHeight1 < iMinHgt)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
EffectiveMatCount[iMat] += iMul * iAddedHeight1;
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
if (iAddedHeight2 < iMinHgt)
Change all indentation with spaces to use tabs instead This is a whitespace-only patch. Hopefully, it'll only affect rarely-changed parts of the engine, since all regularly maintained pieces should already use tabs.
2010-03-27 16:05:02 +00:00
EffectiveMatCount[iMat] += iMul * iAddedHeight2;
}
}
}
}
Rerun astyle with missing \ added
2010-03-28 18:58:01 +00:00
}
Import source
2009-05-08 13:28:41 +00:00
Move Game.Landscape to ::Landscape
2009-06-05 15:20:41 +00:00
C4Landscape Landscape;