C 猜猜猜😀文字小游戏

前言 - 随机性

　　随机数生成 - https://zh.wikipedia.org/wiki/%E9%9A%8F%E6%9C%BA%E6%95%B0%E7%94%9F%E6%88%90

　　没啥事情, 写了个猜猜猜(猜数字)小游戏. 遇到猜的部分, 那肯定会用到随机函数. 我们为了多平台行为一致, 就统一

整合一个伪随机函数实现方案, 让随机更随机. 一开始看下接口设计 rand.h

 #ifndef _RAND_H
 #define _RAND_H

 #include <stdint.h>
 #include <assert.h>

 //
 // 传承(抄袭)不灭(创新) rand 库
 // 大体思路
 //  { r | r[n+1] = (a*r[n] + c) mod m
 //      , n >= 0
 //      , m = 0xFFFFFFFFFFFF = 2 ^ 48
 //      , a = 0x0005DEECE66D = 0x5DEECE66D,
 //      , c = 0x000B         = 0xB
 //  }
 //
 struct rand {
     uint32_t x0, x1, x2;
     uint32_t a0, a1, a2;
     uint32_t c;
 };

 typedef struct rand rand_t[];

 //
 // rand_init - 随机函数对象初始化种子
 // r         : 随机函数对象
 // seed      : 种子数
 // return    : void
 //
 extern void rand_init(rand_t r, int64_t seed);

 //
 // rand_rand - 获取一个随机值
 // r         : 随机函数对象
 // return    : 返回 [0, INT32_MAX] 随机数
 //
 extern int32_t rand_rand(rand_t r);

 //
 // r_rand - 得到 [0, INT32_MAX] 随机数
 // r_ranb - 得到 [0, INT64_MAX] (int64 = big int32) 随机数
 // r_rang - 得到 range [min, max] 随机数
 //
 extern int32_t r_rand(void);

 extern int64_t r_ranb(void);

 inline int32_t r_rang(int32_t min, int32_t max) {
     assert(max >= min);
     return r_rand() % (max - min + ) + min;
 }

 #endif//_RAND_H

rand.c 

 #include "rand.h"

 #define X0              (0x330E)
 #define X1              (0xABCD)
 #define X2              (0x1234)
 #define A0              (0xE66D)
 #define A1              (0xDEEC)
 #define A2              (0x0005)
 #define C               (0x000B)

 #define N               (16)
 #define MASK            ((1 << N) - 1)
 #define LOW(x)          ((uint32_t)(x) & MASK)
 #define HIGH(x)         LOW((x) >> N)

 //
 // rand_init - 随机函数对象初始化种子
 // r         : 随机函数对象
 // seed      : 种子数
 // return    : void
 //
 inline void
 rand_init(rand_t r, int64_t seed) {
     r->x0 = X0; r->x1 = LOW(seed); r->x2 = HIGH(seed);
     r->a0 = A0; r->a1 = A1; r->a2 = A2;
     r->c = C;
 }

 #define CARRY(x, y)     ((x + y) > MASK) // 基于 16 位判断二者和是否进位
 #define ADDRQ(x, y, z)  z = CARRY(x, y); x = LOW(x + y)
 #define MUL(m, x, y, z) m = (x) * (y); z##0 = LOW(m); z##1 = HIGH(m)

 inline void rand_next(rand_t r) {
     uint32_t m, p0, p1, q0, q1, s0, s1, c0, c1;

     MUL(m, r->a0, r->x0, p);
     ADDRQ(p0, r->c, c0);
     ADDRQ(p1, c0, c1);
     MUL(m, r->a0, r->x1, q);
     ADDRQ(p1, q0, c0);
     MUL(m, r->a1, r->x0, s);

     m = c0 + c1 + CARRY(p1, s0) + q1 + s1
         + r->a0 * r->x2 + r->a1 * r->x1 + r->a2 * r->x0;
     r->x2 = LOW(m);
     r->x1 = LOW(p1 + s0);
     r->x0 = LOW(p0);
 }

 //
 // rand_rand - 获取一个随机值
 // r         : 随机函数对象
 // return    : 返回 [0, INT32_MAX] 随机数
 //
 inline int32_t
 rand_rand(rand_t r) {
     rand_next(r);
     return (r->x2 << (N - )) + (r->x1 >> );
 }

 //
 // 想过 - 朵朵浪花, 也不曾看见云彩飘过 :0
 //
 static rand_t r_r = { { X0, X1, X2 , A0, A1, A2 , C } };

 // EXTERN_RUN(r_init) 启动初始化
 extern inline void r_init(int64_t seed) {
     rand_init(r_r, seed);
 }

 inline int32_t
 r_rand(void) {
     return rand_rand(r_r);
 }

 inline int64_t
 r_ranb(void) {
     uint64_t x = ((r_rand() << N) ^ r_rand()) & INT32_MAX;
     uint64_t y = ((r_rand() << N) ^ r_rand()) & INT32_MAX;
     return ((x <<  * N) | y) & INT64_MAX;
 }

算法层面网上资料很够(redis rand48 原理) . 我这里只聊聊工程实现方面, 可以看出来多线程并发发起 r_rand()

请求是不可控的(非线程安全, 你也不知道内部运行状态是啥). 但如果存在特殊业务需要可窥探随机序列时候,

rand_init  就可以运用上了, 来构建多线程情况下可控的随机函数对象.

　　 对于 r_init 多数使用 time(NULL) 时间量初始化种子, 有没有人觉得不太可靠, 毕竟服务器时间也可以改. 有

没有想过让其更加混乱一点. 这里有个小想法, 提出来可供大家一块参略讨论讨论.

 1 //
 // EXTERN_RUN - 函数包装宏, 声明并立即使用
 // frun     : 需要执行的函数名称
 // ...      : 可变参数, 保留
 //
 #define EXTERN_RUN(frun, ...)                          \
 do {                                                   \
     extern void frun();                                \
     frun (__VA_ARGS__);                                \
 } while()

 // 此后 :) 随机与你无关 ~
 EXTERN_RUN(rand_restrict);

 // rand_nationalism - 民族主义, 国家是人民所共有, 各族平等, 团结一致
 static void rand_nationalism(void) {
     struct timespec s;
     (void)timespec_get(&s, TIME_UTC);
     EXTERN_RUN(r_init, s.tv_nsec + s.tv_sec);
     for (int32_t i = BUFSIZ; i >  ; --i) {
         (void)timespec_get(&s, TIME_UTC);
         EXTERN_RUN(r_init, s.tv_nsec + i);
     }
 }

 // rand_democracy - 民权主义, 政治是人民所共管, 选举权、罢免权、创制权和复决权
 static void rand_democracy(void) {
     int32_t x, y, z, w;
     do {
         x = r_rand();
         y = r_rand();
         z = r_rand();
         w = r_rand();
     } while (!(x > y && y > z && z > w && w > INT16_MAX));
 }

 // rand_livelihood - 民生主义, 利益是人民所共享, 让人像个人
 static void rand_livelihood(void) {
     for (int32_t i = r_rand(); i >= ; --i)
         r_rand();
 }

 // rand_restrict - 三权制衡在随机函数初中运用
 void rand_restrict(void) {
     thread_async(rand_nationalism);
     thread_async(rand_democracy);
     thread_async(rand_livelihood);
 }

传送门 核心是引入多线程互相竞争制约, 让随机函数你我不知, 模糊不清, 捉摸不透.  这里只是瞎弄一个思路.

大家有更好的想法可以在评论区和我一块交流.

正文 - 猜猜猜

　　是不是要开始扯闲篇. 那就用上面随机库写个猜猜猜游戏吧 ~

main.c

#include "rand.h"
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//
// EXTERN_RUN - 函数包装宏, 声明并立即使用
// frun     : 需要执行的函数名称
// ...      : 可变参数, 保留
//
#define EXTERN_RUN(frun, ...)                          \
do {                                                   \
    extern void frun();                                \
    frun (__VA_ARGS__);                                \
} while()

//
// GUESS_THRESHOLD_INT - 猜数最多次数
// GUESS_TEMPER_INT    - 遇到小脾气不再触发提示
// GUESS_MAX_INT       - 最大值区间
//
#define GUESS_THRESHOLD_INT     (8)
#define GUESS_TEMPER_INT        (3)
#define GUESS_MAX_INT           (8964)

// guess 猜数字游戏对象
struct guess {
    int32_t max;                          // 数字区间上限
    int32_t correct;                      // 正确数值
    int32_t use;                          // 已经猜数次数
    int32_t numbers[GUESS_THRESHOLD_INT]; // 用户猜数数组
    int32_t now;                          // 用户当前输入值
};

// guess_run 猜数字游戏开始
void guess_run(struct guess * restrict g);
// guess_guess 猜数字开启猜猜猜
bool guess_guess(struct guess * restrict g);
// guess_end 猜数字游戏结束总结
void guess_end(struct guess * restrict g);

// threshold_input - 获取猜数字的范围
static int32_t threshold_input(int argc, char * argv[]) {
    int32_t max = GUESS_MAX_INT;
    if (argc > ) {
        int num = atoi(argv[]);
        if (num <= ) {
            printf("亲， 别