public interface ITimeZone {
    float relativeTimeScale { get; set; }
    float timeScale {get; set;}
    float deltaTime {get;}
    float fixedDeltaTime {get;}

    // we need to handle multiple sources of timeScale change.
    void ChangeTimeScale(float newTimeScale, int priority);

    // Sometimes we need to tween timeScale, such as bullet time.
    // Same as above, we need to handle multiple sources by priority.
    void TweenTimeScale(ITweenInfo tweenInfo, int priority);
}

void DoUpdate(){
    hero.animator.speed = hero.localTimeScale;
}

IEnumerator PlayEffectCrt(float duration){
    if(hero.localTimeScale == 1)
        yield break;

    float timer;
    while(timer < duration){
        particleSystem.Simulate(hero.localDeltaTime);
        timer += hero.localDeltaTime;
        yield return null;
    }
}

particleSystem.main.simulationSpeed = hero.localTimeScale;

if(effect.playInUnscaledTime)
    particleSystem.main.simulationSpeed = 1;

IEnumerator WaitForSecondsLocal(float duration) {
    float timer = 0;
    while(timer <= duration) {
        timer += LocalDeltaTime;
        yield return null;
    }
}

// Example
IEnumerator DoSkill(Skill skill){
    SkillOn(skill);
    yield return hero.WaitForSecondsLocal(skill.duration);
    SkillEnd();
}

// file: UnityStandardCore.cginc
half4 fragForwardBaseInternal (VertexOutputForwardBase i)
{
    FRAG_SETUP(i);

    // Unity standard PBS
    half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
    
    //-----------custom functions (forward base)-------------
    // apply custom Emission
    c.rgb += Emission(i.tex.xy) * _EmissionMultiplier;

#ifdef _ZGAME_HSBC
	// apply HSBC effect
	c.rgb = HSBC(c.rgb, _HsbcParam, i.tex.xy);
#endif

#ifdef _ZGAME_RIM
    // apply rim color
    c.rgb += Rim(s);
#endif

	// apply extra light
#ifdef _ZGAME_FORWARD_BASE_MULTI_LIGHT
	c.rgb += ExtraLight(s, _ExtraLightDir_1, _ExtraLightColor_1, ExtraLightAtten(s.posWorld, _ExtraLightPos_1, _ExtraLightDir_1));
	c.rgb += ExtraLight(s, _ExtraLightDir_2, _ExtraLightColor_2, ExtraLightAtten(s.posWorld, _ExtraLightPos_2, _ExtraLightDir_2));
#endif

#ifdef _ZGAME_SUBSURFACE_SCATTERING
	// apply subsurface scattering
	c.rgb = c.rgb + SSS(mainLight.dir, s.normalWorld, -s.eyeVec, mainLight.color, i.tex.xy);
#endif

#ifdef _ZGAME_UV_FLOW
	// apply uv flow
	c.rgb += UV_Flow(i.tex);
#endif

    //------------end custom functions --------

    UNITY_APPLY_FOG(i.fogCoord, c.rgb);
    return OutputForward (c, s.alpha);
}

#ifdef _ZGAME_FORWARD_BASE_MULTI_LIGHT
half4 _ExtraLightDir_1;
fixed4 _ExtraLightColor_1;
fixed4 _ExtraLightPos_1;

half4 _ExtraLightDir_2;
fixed4 _ExtraLightColor_2;
fixed4 _ExtraLightPos_2;

inline fixed3 ExtraLight(FragmentCommonData s, half4 lightDir, fixed4 lightColor, fixed atten)
{
	UnityLight l;
	l.color = lightColor.rgb * lightColor.a * 2 * atten;
	l.dir = lightDir.xyz;
	UnityIndirect noIndirect = ZeroIndirect();
	return UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, l, noIndirect);	
}

inline half ExtraLightAtten(half3 worldPos, half4 lightPos, half4 lightDir) {
	half dist_proj = dot(worldPos - lightPos.xyz, lightDir.xyz);
	half dist2 = dist_proj * dist_proj;
	return saturate((lightPos.w + 1) / (dist2 + 0.01) - lightPos.w);
}
#endif

#ifdef _ZGAME_SUBSURFACE_SCATTERING
half _SSS_Sigma;
half _SSS_Power;
fixed4 _SSS_Color;
sampler2D _SSS_Ramp;
sampler2D _SSS_Mask;

// subsurface scattering
inline fixed3 SSS(half3 lightDir, half3 normal, half3 viewDir, fixed3 lightColor, half2 uv) {	
	// half f = _SSS_Sigma * max(dot(-normal, lightDir), 0) + (1 - _SSS_Sigma) * (dot(-viewDir, lightDir) * 0.5 + 0.5);
	// fixed3 c = pow(f, _SSS_Power) * _SSS_Color.rgb * 2;
	
	half nl = dot(normal, lightDir);
	fixed3 c = pow(tex2D(_SSS_Ramp, half2(nl / 2 + 0.5, 0.5)), _SSS_Power) * _SSS_Color.rgb * lightColor;
	
	// apply mask
	c = c * tex2D(_SSS_Mask, uv).r;

	return c;
}
#endif

#ifdef _ZGAME_RIM
fixed3 _RimColor;
half _RimPower;
// Add rim color to this character
inline fixed3 Rim(FragmentCommonData s) {
    half rimDot = 1 - saturate(dot(s.normalWorld, -s.eyeVec));
    return _RimColor * pow(rimDot, _RimPower);
}
#endif