打算制作-恒久不变的游戏逻辑-新的语言(语法兹略)

instemast

RT.

这种语言需要把

游戏逻辑编程

和

电脑,网络

完全独立开来！


“这不可能”
---- 莎士比亚的作品，数学定理...这些东西常年不变，但几年前的Code却很难编译


举例：

在计算机中实现这样的逻辑： 并行的一些 Ball 的 2 种运动状态，有多种实现方式：

(1) 协同多任务 + 状态变量

Ball::Update (Float dt)
{
    assert (dt < 0.1f); // 主循环应该确保采样率
    switch (m_State)
    {
    case 0:
        m_X += m_Speed * dt;
        if (m_X > 100.0f)
        {
            m_Speed *= - 1;  // 反向
        }
        else if (m_X < 0.0f)
        {
            m_Speed *= - 2.0f;  // 正向加速
            this->m_Next = new Ball_State1;
        }
    case 1:
        m_X += m_Speed * dt;
        if (m_X > 100.0f)
        {
            m_Speed *= - 1;  // 反向
        }
        else if (m_X < 0.0f)
        {
            m_Speed *= - 0.5f;  // 正向减速
            this->m_Next = new Ball_State1;
        }        
    }
}

(2) 协同多任务 + 状态对象

Ball_State0::Update (Float dt)
{
    assert (dt < 0.1f);
    m_X += m_Speed * dt;
    if (m_X > 100.0f)
    {
        m_Speed *= - 1;  // 反向
    }
    else if (m_X < 0.0f)
    {
        m_Speed *= - 2.0f;  // 正向加速
        this->m_Next = new Ball_State1;
    }
}

Ball_State1::Update (Float dt)
{
    assert (dt < 0.1f);
    m_X += m_Speed * dt;
    if (m_X > 100.0f)
    {
        m_Speed *= -1;  // 反向
    }
    else if (m_X < 0.0f)
    {
        m_Speed *= 0.5f;  // 正向减速
        this->m_Next = new Ball_State0;
    }
}

(3) win32 multi-thread

Ball::ThreadProc(Float dt)
{
    assert (dt < 0.1f); // 主循环应该确保采样率

_state_0:
    while(1)
    {
        // 计算 dt
        m_X += m_Speed * dt;
        if (m_X > 100.0f)
        {
            m_Speed *= - 1;  // 反向
        }
        else if (m_X < 0.0f)
        {
            m_Speed *= - 2.0f;  // 正向加速
            break;
        }
    }
    while(1)
    {
        // 计算 dt
        m_X += m_Speed * dt;
        if (m_X > 100.0f)
        {
            m_Speed *= - 1;  // 反向
        }
        else if (m_X < 0.0f)
        {
            m_Speed *= - 0.5f;  // 正向减速
            goto _state_0;
        }        
    }
}

instemast

以上编程方法都太复杂了，我们希望这样：

用过程式语言，实现状态机（就像console或win32multi-thread程序一样，而不是麻烦的状态变量等）

用函数式语言，实现系统的运行规则（就像写数学题那样方便安全，而程序代码很底层）

以上代码用一种理想的  伪  代码可以这样写：

// 规律:
using system::time
with class Ball
    m_X (t)  ==  m_X (0) + m_Speed * t
end with

// 状态转换:
_state_0:
    if (m_X >= 100)
        m_Speed *= -1
    else if m_X <= 0
        m_Speed *= -2.0
        goto _state_1
    end if
_state_1:
    if (m_X >= 100)
        m_Speed *= -1
    else if m_X <= 0
        m_Speed *= -0.5
        goto _state_0
    end if

以上是简单的情形(经典运动)

对于复杂的情形，可以用这样的风格，比如：
// 规律:
using system::time
with class Ball
    m_X (t + dt)  ==  m_X (t) + m_Speed * dt
end with

instemast

这种语言的好处   之   一   是， 可以自动进行网络同步（线性或非线性的）！而根本不用程序员关心！
因为系统的运行规律不是用过程式语言描述的，所以，执行顺序被自动决定。

也不用担心线程安全和线程同步等问题----代码是不变的。（现在的 F# .net 涉及到一些这方便的支持）

而过程式语言，被用在状态转换上，这样，不需要额外的脚本也能进行方便的状态转换。

liuzewei

无法理解啊！

请问你现在在什么公司工作～非常好奇～！

instemast

比如说，如果我考虑到不同平台的环境不同，那么一个 x = 2 * y 这样的语句，也不敢随随便便就写。
封装可以解决一部分问题，但无法解决复杂的情况，比如多任务，网络同步。

脚本的话，仍然是基于过程式的编程，虽然方便编写多任务代码（c++中的协作多任务就麻烦到想要跳楼），
但是脚本不能自动地为我们保证安全性，也不能提供仿真的算法（这当然需要自己编码）。

在logic编程中，数学关系式，状态转换并不那么难写，难度在于，实际的编码比较繁琐，基本都是手工做，
而且如果运行环境，网络状况有大的改变，代码也需要有相当大的修改。（因为不是什么东西都可以封装的，比如通过封装类库，你不能把多线程转换成单线程！除非翻译代码）

一个小小的 x = 2 * y 这样的代码，数都数不清，修改起来十分痛苦。
所以，建立一个长久不变的语言，很有必要。
而对于  逻  辑  代码的话，这是可能的！

梁某

恒久不变的游戏逻辑...这个是什么东西...楼主创造的新名词吗？？

qrli

恒久不变，就是说

否定马克思哲学：世界是不断变化的
否定道家哲学：持而盈之，不如其已；揣而??之，不可长保。
否定佛家哲学：诸行无常，诸法无我
否定西方哲学：The only constant is change.
否定草根哲学：三十年河东，三十年河西

其实lz想说的是独立于底层。

sander_like_kof

qrli曲解楼主了, lz想说的是独立于底层不假,但你说他否定那一系列经典哲学理论,我看他没那意思. 不过要实现他那语言,还是先实现强大的AI在说吧,否则一切都是不切实际的假想.

sander_like_kof

这种语言的好处   之   一   是， 可以自动进行网络同步（线性或非线性的）！

既然他谈到 "线性或非线性的", 就表示他是承认世界是多样的,是变化的啊. 他是想以不变应万变. 不过实际情况多是以少变应多变.

qrli

我那前面是开玩笑的，那么夸张还能当真啊