Tiles

Are they tiles or are they blobs? Where did you put them, or implement them, in your mod? at the World.png, or at the Structures folder or whatever (like trapblocks, doors, items etc)?

 

I made plenty of custom tiles some ago, but they're not buildable. I did them all for the map loaders, and, ayep, they won't appear on the minimap. Check this thread perhaps you can get some further info:
https://forum.thd.vg/threads/implementing-custom-tiles-not-blobs-at-the-map-loaders.25694/

If you want further functionaility, @Geti might help you with that here.

 

the person you should be asking for help is @Skinney

 

There are a couple hooks for tiles that you will need to make use of.

TileType server_onTileHit(CMap@ this, f32 damage, u32 index, TileType oldTileType)
void onSetTile(CMap@ this, u32 index, TileType newtile, TileType oldtile)
bool onMapTileCollapse(CMap@ this, u32 offset)

In example, returning true for bool onMapTileCollapse(CMap@ this, u32 offset) will create a verlet.

If I remember correctly. The minimap is mostly obfuscated from scripting. You could try setting things with void SetMinimapVars(const string&in texture, const uint16 frame, const Vec2f framesize), but I'm not sure how successful you will be in replicating the behavior you want.

 

Minimap isn't exposed to scripting - as you're making a mod though, you do have the option to disable it and write your own minimap. Unattractive option, but the GUI rendering stuff is pretty powerful.

In the medium term I'll look at how feasible a binding would be for outputting a minimap colour for a modded tile.

Out of interest, are you using the vanilla tiles and only adding your extended tiles above 255? Or are you replacing the vanilla behaviour completely (like TR does)?

 

ok, I made a shim for this which will be in the next build.
Here's a look at a simple proof of concept:

Code:

void onInit(CMap@ this)
{
    this.legacyTileMinimap = false; //use for all tiles
    this.MakeMiniMap(); //regenerate here because onInit is called late
}

void CalculateMinimapColour( CMap@ this, u32 offset, TileType tile, SColor &out col)
{
    col = this.isTileSolid(tile) ? SColor(0xffa0a0a0) : SColor(0xff404040);
}

Results in a map like this

Note that these are MAP scripts and are probably best put as part of your maploader which sets up all the extra tiletypes anyway. There's an issue with using onInit as well -

legacyTileMinimap works (means it'll use the script for all tiles instead of tiles >255) - but onInit for maps isn't early enough to take part in minimap generation, so you still end up with a default minimap for tiles under 255.

If you put the code in your map loader (as I'd suggest) then you're fine and shouldn't need the minimap regen, but you will still need the legacyTileMinimap flag if you're replacing tiles under 255.

If you're making tiles above 255 you should be fine anyway without setting the flag or regenerating the map - but for anyone making a mode that completely replaces the tiles and wants to use the minimap stuff, that's something to keep in mind. Documenting this here but I'll need to put something in the release log too.

There's still no support for making your own preview image for the server browser. That was a bit much of a pain to address at the moment, and I'm vaguely concerned people will use it to upload porn images or similar :/


Now, About tiles collapsing: it looks like you just need to set the SOLID flag for the tile. The code that determines if the collapsing body does damage is just this:

 

Wherever you're setting tile flags, probably in your map loader (example from TR source)

Code:

//(Trench Run PNGLoader.as line 116)

void onSetTile(CMap@ map, u32 index, TileType newtile, TileType oldtile)
{
	//here's where we're setting up the flags

	//all tiles like this to prevent shading (not a good idea for KAG)
	map.AddTileFlag(index, Tile::LIGHT_SOURCE | Tile::LIGHT_PASSES);

	bool isSomething = false;
	//background will render behind most objects
	if (TWMap::isTileTypeBackground(newtile))
	{
		isSomething = true;
		map.AddTileFlag(index, Tile::BACKGROUND);
	}

	//we use the ladder flag in TR for climbing, it's not used in KAG any more
	if (TWMap::isTileTypeLadder(newtile))
	{
		isSomething = true;
		map.AddTileFlag(index, Tile::LADDER);
	}

	//solid tiles are marked solid and collide, so they block raycasts
	// and create collision lines
	if (TWMap::isTileTypeSolid(newtile))
	{
		isSomething = true;
		map.AddTileFlag(index, Tile::SOLID | Tile::COLLISION);
	}

	//if we didn't find anything, mark the tile as "water passes"
	// - I'm not 100% why we do this in TR since we keep water static there..
	if (!isSomething) //empty
	{
		map.AddTileFlag(index, Tile::WATER_PASSES);
	}

	// (then there's a bunch of stuff for flipping and rotating tiles
	//  for autotiling)

	if (newtile != oldtile)
	{
		// (then there's effects for destruction/tile changes:
		//  creating particles, playing sounds, etc)
	}
}

Reading the TR maploader (PNGLoader.as) might help see how custom tiles can be implemented.

 

Do a little debugging and print the flags of the tile under the cursor to double check it's actually set properly.

 

You would have to fetch adjacent positions and set new tiles based on your conditions for those positions within void onSetTile(CMap@ this, u32 index, TileType newtile, TileType oldtile).

 

Neither, it's a totally separate system - this is also the reason answer to 1 and 4 "you can't, as far as I know".

It's a custom verlet physics system that MM wrote one weekend. There wasn't even binds for allowing custom tiles to collapse before skinney asked for them.

 

I'm honestly not sure - as Verra said I'd make sure your flags are actually getting set, read them in your onMapTileCollapse and see if they're somehow missing/changed from what you set.

I don't have time to debug mods at the moment I'm afraid - I'm trying to get a build out today and if I get time, then update the official modded server with another mod (provided I can get it working).

What we did in TR about collapses was to avoid the built-in collapse system entirely and spawned crate blobs that would fall and re-settle when they hit the ground, or kill people they fell on. It wasn't perfect and doesn't have the same spectacle as the built in blocks but you have control over that, so it might be a viable workaround in the short term.

Sorry that I can't give more insights into it at this point.