Added ingame credits

CREDITS

@@ -20,6 +20,7 @@ General:
 - Hachem Muche for many patches and scaling issues
 - Dekar for artifacts, debug help (slave? ;> ), icons, ...
 - Shibari for artifacts and talents balancing
+- Sage Acrin
 
 Lore:
 - Darren Grey

game/engines/default/data/gfx/ui/definitions/default.lua

@@ -68,3 +68,10 @@ tombstone = {
 	frame_oy1 = -16,
 	frame_oy2 = 16,
 }
+
+invisible = {
+	frame_ox1 = 0,
+	frame_ox2 = 0,
+	frame_oy1 = 0,
+	frame_oy2 = 0,
+}

game/engines/default/engine/Game.lua

@@ -155,8 +155,10 @@ function _M:display(nb_keyframes)
 		self.flyers:display(nb_keyframes)
 	end
 
-	if not self.suppressDialogs then
-		for i, d in ipairs(self.dialogs) do
+	if not self.suppressDialogs and #self.dialogs then
+		local last = self.dialogs[#self.dialogs]
+		for i = last and last.__show_only and #self.dialogs or 1, #self.dialogs do
+			local d = self.dialogs[i]
 			d:display()
 			d:toScreen(d.display_x, d.display_y, nb_keyframes)
 		end

game/engines/default/modules/boot/class/Game.lua

@@ -372,8 +372,10 @@ function _M:display(nb_keyframes)
 			end
 			self.background:toScreenFull(x, y, w, h, w * self.background_tw / self.background_w, h * self.background_th / self.background_h)
 		end
-		self.tooltip:display()
-		self.tooltip:toScreen(5, 5)
+		if #self.dialogs == 0 or not self.dialogs[#self.dialogs].__show_only then
+			self.tooltip:display()
+			self.tooltip:toScreen(5, 5)
+		end
 		self.logdisplay:toScreen()
 		engine.GameEnergyBased.display(self, nb_keyframes)
 		if self.full_fbo then self.full_fbo:use(false) self.full_fbo:toScreen(0, 0, self.w, self.h, self.full_fbo_shader.shad) end
@@ -410,8 +412,10 @@ function _M:display(nb_keyframes)
 --		core.display.drawQuad(0, 0, game.w, game.h, 128, 128, 128, 128)
 	end
 
-	self.tooltip:display()
-	self.tooltip:toScreen(5, 5)
+	if #self.dialogs == 0 or not self.dialogs[#self.dialogs].__show_only then
+		self.tooltip:display()
+		self.tooltip:toScreen(5, 5)
+	end
 
 	self.logdisplay:toScreen()
 

game/engines/default/modules/boot/data/gfx/shaders/awesomeaura.frag

+uniform sampler2D tex;
+uniform sampler2D flames;
+
+uniform float alpha;
+uniform float tick;
+uniform float time_factor;
+uniform float flameScale;
+
+vec4 permute( vec4 x ) {
+
+	return mod( ( ( x * 34.0 ) + 1.0 ) * x, 289.0 );
+
+} 
+
+vec4 taylorInvSqrt( vec4 r ) {
+
+	return 1.79284291400159 - 0.85373472095314 * r;
+
+}
+
+float snoise( vec3 v ) {
+
+	const vec2 C = vec2( 1.0 / 6.0, 1.0 / 3.0 );
+	const vec4 D = vec4( 0.0, 0.5, 1.0, 2.0 );
+
+	// First corner
+
+	vec3 i  = floor( v + dot( v, C.yyy ) );
+	vec3 x0 = v - i + dot( i, C.xxx );
+
+	// Other corners
+
+	vec3 g = step( x0.yzx, x0.xyz );
+	vec3 l = 1.0 - g;
+	vec3 i1 = min( g.xyz, l.zxy );
+	vec3 i2 = max( g.xyz, l.zxy );
+
+	vec3 x1 = x0 - i1 + 1.0 * C.xxx;
+	vec3 x2 = x0 - i2 + 2.0 * C.xxx;
+	vec3 x3 = x0 - 1. + 3.0 * C.xxx;
+
+	// Permutations
+
+	i = mod( i, 289.0 );
+	vec4 p = permute( permute( permute(
+		i.z + vec4( 0.0, i1.z, i2.z, 1.0 ) )
+		+ i.y + vec4( 0.0, i1.y, i2.y, 1.0 ) )
+		+ i.x + vec4( 0.0, i1.x, i2.x, 1.0 ) );
+
+	// Gradients
+	// ( N*N points uniformly over a square, mapped onto an octahedron.)
+
+	float n_ = 1.0 / 7.0; // N=7
+
+	vec3 ns = n_ * D.wyz - D.xzx;
+
+	vec4 j = p - 49.0 * floor( p * ns.z *ns.z );  //  mod(p,N*N)
+
+	vec4 x_ = floor( j * ns.z );
+	vec4 y_ = floor( j - 7.0 * x_ );    // mod(j,N)
+
+	vec4 x = x_ *ns.x + ns.yyyy;
+	vec4 y = y_ *ns.x + ns.yyyy;
+	vec4 h = 1.0 - abs( x ) - abs( y );
+
+	vec4 b0 = vec4( x.xy, y.xy );
+	vec4 b1 = vec4( x.zw, y.zw );
+
+
+	vec4 s0 = floor( b0 ) * 2.0 + 1.0;
+	vec4 s1 = floor( b1 ) * 2.0 + 1.0;
+	vec4 sh = -step( h, vec4( 0.0 ) );
+
+	vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+	vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+	vec3 p0 = vec3( a0.xy, h.x );
+	vec3 p1 = vec3( a0.zw, h.y );
+	vec3 p2 = vec3( a1.xy, h.z );
+	vec3 p3 = vec3( a1.zw, h.w );
+
+	// Normalise gradients
+
+	vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );
+	p0 *= norm.x;
+	p1 *= norm.y;
+	p2 *= norm.z;
+	p3 *= norm.w;
+
+	// Mix final noise value
+
+	vec4 m = max( 0.6 - vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ), 0.0 );
+	m = m * m;
+	return 42.0 * dot( m*m, vec4( dot( p0, x0 ), dot( p1, x1 ),
+		dot( p2, x2 ), dot( p3, x3 ) ) );
+
+}  
+
+vec2 snoise2(vec3 pos)
+{
+	return vec2(snoise(pos), snoise(pos + vec3(0.0, 0.0, 1.0)));
+}
+
+float GetFireDelta(float currTime, vec2 pos, float freqMult, float stretchMult, float scrollSpeed, float evolutionSpeed)
+{
+	//firewall
+	float delta = 0.0;
+//	pos.y += (1.0 - pos.y) * 0.5;
+	//pos.y += 0.5;
+	pos.y /= stretchMult;
+	pos *= freqMult;
+	pos.y -= currTime * scrollSpeed;
+//	pos.y -= currTime * 3.0;
+
+	
+	delta += snoise(vec3(pos * 1.0, currTime * 1.0 * evolutionSpeed)) * 1.5;
+	delta += snoise(vec3(pos * 2.0, currTime * 2.0 * evolutionSpeed)) * 1.5;
+	delta += snoise(vec3(pos * 4.0, currTime * 4.0 * evolutionSpeed)) * 1.5;	
+	delta += snoise(vec3(pos * 8.0, currTime * 8.0 * evolutionSpeed)) * 1.5;
+	delta += snoise(vec3(pos * 16.0, currTime * 16.0 * evolutionSpeed)) * 0.5;
+
+	return delta;
+}
+
+vec4 GetFireAuraColor(float currTime, vec2 planarPos, float freqMult, float stretchMult, float ampMult, float power, float scrollSpeed, float paletteCoord)
+{		
+	float delta =  
+		GetFireDelta(currTime, planarPos + vec2(currTime * scrollSpeed * 0.0, 0.0), freqMult, stretchMult, 2.5, 0.5) * (1.0 - planarPos.x)	+ 
+		GetFireDelta(currTime, vec2(planarPos.x + currTime * scrollSpeed * 0.0 - 1.0, planarPos.y), freqMult, stretchMult, 2.5, 0.5) * planarPos.x;
+		
+	delta *= min(1.0, max(0.0, 1.0 * (1.0 - planarPos.y)));
+	delta *= min(1.0, max(0.0, 1.0 * (0.0 + planarPos.y)));
+
+	float verticalPos = 1.0 - planarPos.y + delta * ampMult;	
+	verticalPos = min(0.99, verticalPos);
+	verticalPos = max(0.01, verticalPos);
+	
+	return texture2D(flames, vec2(paletteCoord, verticalPos));
+}
+
+
+vec4 Uberblend(vec4 col0, vec4 col1)
+{
+//	return vec4((1.0 - col0.a) * (col1.rgb) + col0.a * (col1.rgb * col1.a + col0.rgb * (1.0 - col1.a)), min(1.0, col0.a + col1.a));
+//	return vec4((1.0 - col1.a) * (col0.rgb) + col1.a * (col1.rgb * col1.a + col0.rgb * (1.0 - col1.a)), min(1.0, col0.a + col1.a));
+	return vec4(
+		(1.0 - col0.a) * (1.0 - col1.a) * (col0.rgb * col0.a + col1.rgb * col1.a) / (col0.a + col1.a + 1e-1) +
+		(1.0 - col0.a) * (0.0 + col1.a) * (col1.rgb) +
+		(0.0 + col0.a) * (1.0 - col1.a) * (col0.rgb * (1.0 - col1.a) + col1.rgb * col1.a) +
+		(0.0 + col0.a) * (0.0 + col1.a) * (col1.rgb),
+		min(1.0, col0.a + col1.a));
+}
+
+
+void main(void)
+{
+	vec2 radius = gl_TexCoord[0].xy - vec2(0.5, 0.5);
+	float innerRadius = 0.25;
+	float outerRadius = 0.5;
+	
+	vec2 planarPos;
+	vec4 displacement = texture2D(tex, gl_TexCoord[0].xy);
+	planarPos.x = displacement.b;	
+	planarPos.y = displacement.a * 3.0 * (1.0 + 10.0 * pow((planarPos.x) * (1.0 - planarPos.x) * 4.0, 1.0)) / max(flameScale, 1e-3);
+	
+	vec4 resultColor = vec4(0.0, 0.0, 0.0, 0.0);
+		
+	resultColor = GetFireAuraColor(tick / time_factor, planarPos, 6.0, 15.0 * max(flameScale, 1e-3), 1.0, 1.0, 1.0, 0.75);//texture2D(tex, gl_TexCoord[0].xy) * texture2D(flames, gl_TexCoord[0].xy) + 0.2;
+	
+	gl_FragColor = resultColor;
+	gl_FragColor.a *= alpha;
+}
\ No newline at end of file

game/engines/default/modules/boot/data/gfx/shaders/awesomeaura.lua

+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009 - 2014 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+return {
+	frag = "awesomeaura",
+	vert = nil,
+	args = {
+		tex = { texture = 0 },
+		flames = { texture = 1 },
+		alpha = alpha or 1,
+		time_factor = time_factor or 4000,
+		flameScale = flame_scale or 1,
+	},
+	clone = false,
+}

game/engines/default/modules/boot/data/gfx/shaders/crystalineaura.frag

+uniform sampler2D displMapTex;
+uniform sampler2D normalMapTex;
+
+uniform float spikeLength;
+uniform float spikeWidth;
+uniform float spikeOffset;
+
+uniform float growthSpeed;
+
+uniform float tick;
+uniform float tick_start;
+uniform float time_factor;
+
+uniform vec3 color;
+
+void main(void)
+{
+	vec2 radius = gl_TexCoord[0].xy - vec2(0.5, 0.5);
+	float innerRadius = 0.25;
+	float outerRadius = 0.5;
+	
+	vec2 planarPos;
+	vec4 displacement = texture2D(displMapTex, gl_TexCoord[0].xy);
+
+	vec2 point = gl_TexCoord[0].xy;
+	float eps = 0.05;
+	vec2 basisY = vec2(
+		 texture2D(displMapTex, point + vec2(eps, 0.0)).a - texture2D(displMapTex, point + vec2(-eps, 0.0)).a,
+		-texture2D(displMapTex, point + vec2(0.0, eps)).a + texture2D(displMapTex, point + vec2(0.0, -eps)).a);
+	basisY /= length(basisY) + 0.001;
+	vec2 basisX = vec2(basisY.y, -basisY.x);
+
+	planarPos.x = displacement.b * 6.0 / spikeWidth + spikeOffset;
+	planarPos.y = displacement.a * 20.0 / (spikeLength * clamp((tick - tick_start) / time_factor * growthSpeed, 0.0, 1.0) + 0.001);
+
+	vec4 normalMap = texture2D(normalMapTex, vec2(planarPos.x, clamp(1.0 - planarPos.y, 0.01, 0.99)));
+	vec3 localNormal = normalMap.rgb;
+	localNormal -= vec3(0.5, 0.5, 0.5);
+	localNormal.x = -localNormal.x;
+	localNormal.z = -localNormal.z;
+	localNormal /= length(localNormal);
+
+	vec3 globalNormal;
+	globalNormal.xy  = basisX * localNormal.x + basisY * localNormal.y;
+	globalNormal.z = localNormal.z;
+
+	vec2 lightDir2 = vec2(cos(tick / time_factor), sin(tick / time_factor));
+	float ang = 3.1415 * 0.2;
+	vec3 lightDir3 = vec3(lightDir2 * sin(ang), cos(ang));
+
+	float diffuse = clamp(-dot(lightDir3, globalNormal), 0.0, 1.0);
+	float specular = 0.0;
+	if(dot(lightDir3, globalNormal) < 0.0)
+	{
+		vec3 reflectedLight = lightDir3 - globalNormal * dot(lightDir3, globalNormal) * 2.0;
+		specular += pow(clamp(-dot(reflectedLight, vec3(0.0, 0.0, 1.0)), 0.0, 1.0), 30.0);
+	}
+	//vec3(0.624, 0.820, 0.933);
+	vec4 resultColor = vec4(color * diffuse + vec3(1.0, 1.0, 1.0) * specular, normalMap.a * gl_Color.a);
+	
+	gl_FragColor = resultColor;///
+}
\ No newline at end of file

game/engines/default/modules/boot/data/gfx/shaders/crystalineaura.lua

+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012, 2013 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+return {
+	frag = "crystalineaura",
+	vert = nil,
+	args = {
+		displMapTex = { texture = 0 },
+		normalMapTex = { texture = 1 },
+
+		spikeLength = spikeLength or 1.0, -- 1.0 means normal length, 0.5 is half-sized spikes, 2.0 is double-sized, etc
+		spikeWidth = spikeWidth or 1.0, -- use different values for different effects. 1.0 is normal width
+		spikeOffset = spikeOffset or 0.0, -- use different values for different effects. such as offset = 0.0 for ice spikes and 0.123123 for rock spikes
+
+		growthSpeed = growthSpeed or 1.0, -- 1.0 is normal growth speed
+
+		time_factor = time_factor or 500,
+
+		color = color or {0.624, 0.820, 0.933},
+	},
+	resetargs = {
+		tick_start = function() return core.game.getTime() end,
+	},		
+	clone = false,
+}

game/engines/default/modules/boot/data/gfx/shaders/textoutline.frag

+uniform sampler2D tex;
+uniform vec2 textSize;
+uniform float intensity; 
+uniform vec2 outlineSize;
+uniform vec4 outlineColor;
+
+void main(void)
+{
+	float xOffset = outlineSize.x / textSize.x;
+	float yOffset = outlineSize.y / textSize.y;
+
+	gl_FragColor = texture2D(tex, gl_TexCoord[0].xy); //default text color
+
+	//sobel distance to glyph base line approximation
+	vec4 col02 = texture2D(tex, gl_TexCoord[0].xy + vec2(xOffset,  -yOffset));
+	vec4 col12 = texture2D(tex, gl_TexCoord[0].xy + vec2(xOffset,   0.0     ));
+	vec4 col22 = texture2D(tex, gl_TexCoord[0].xy + vec2(xOffset,   yOffset));
+	vec4 col01 = texture2D(tex, gl_TexCoord[0].xy + vec2(0.0,        -yOffset));
+	vec4 col21 = texture2D(tex, gl_TexCoord[0].xy + vec2(0.0,         yOffset));
+	vec4 col00 = texture2D(tex, gl_TexCoord[0].xy + vec2(-xOffset, -yOffset));
+	vec4 col10 = texture2D(tex, gl_TexCoord[0].xy + vec2(-xOffset,  0.0     ));
+	vec4 col20 = texture2D(tex, gl_TexCoord[0].xy + vec2(-xOffset,  yOffset));
+	
+	
+	float xDist = 0.0 - col00.a - col01.a * 2.0 - col02.a + col20.a + col21.a * 2.0 + col22.a;
+	float yDist = 0.0 - col00.a + col02.a - col10.a * 2.0 + col12.a * 2.0 - col20.a + col22.a;
+	
+	//transperency of current outline pixel
+	float alpha = min(1.0, sqrt(xDist * xDist + yDist * yDist) * intensity); 
+	
+	//outlineColor = vec4(0, 0, 0, 1);
+	//blending character glyph over its outline
+	gl_FragColor = (gl_FragColor * gl_FragColor.a + outlineColor * alpha * (1.0 - gl_FragColor.a)) * gl_Color;
+}