简单Elixir游戏服设计-玩法simple_poker

代码还当https://github.com/rubyist1982/simple 上。

序言

    最近店家在招.NET程序员,我发觉多来企业面试的.NET程序员居然都并未
ASP.NET
MVC项目更,其中包括部分工作4、5年了,甚至8年10年的,许多口深受我之痛感是:工作了4、5年,Web开发仍然停留在拖控件的档次,最极致核心的算法,递归、排序(我未求速排序,你晤面冒泡就尽了)都未会见,数据库方面,很基础之SQL都勾不发生,分组过滤也无会见,更别提性能了,问下多少优化涉,除了应加索引基本就是从未有过下文了。当然,一些病逝N年还是做ASP.NET
WebForm开发之,不熟识MVC,那吧绝非干,底子在嘛,那我哪怕问ASP.NET啦,问了生管道机制、aspx和aspx.cs之间的关系,如何进行互动的等等,都报不达标,真的十分失望,我不要求能够管19个管道事件一一答出,但起码要将HttpHandler,HttpModule,HttpContent、HttpApplication等说出吧!我莫懂得简历上面写的会二配是个什么概念。更有甚者,有些还于简历上面作假,写单什么熟悉各种设计模式,一问,只见面单例和工厂,单例还特会同样种最简便易行的,我也是醉了。又或写啊熟悉nginx和Memcached,我问问两啊发生什么分别,哑口了,唉!知之为知之,不知为不知嘛!不见面之尽管毫无写简历上面贴金,有时候往往事与愿违,不要拿装有的面试官都当傻子。当然矣,也间或会碰到特别是的面试者,不由得感叹,同样工作经验的求职者差别真的比深。

   
部分国产的.NET书籍与国产奶粉一样侵害着一波以平等波的后生程序员,还有一对贪婪的养机构简直是坑爹。说词其实话,相比而言,java程序员给自己之觉得,基础就扎实多矣。这吗难怪,因为我发现许多.net程序员上班就随在店框架形成编码功能,过度依赖微软强大的IDE和助咱封装好之成千上万物,不爱去研究技术,不请甚解,下班就是打打游戏,更别说去逛逛技术论坛或者打上了。好了,就无吐槽了,说多了还是泪液呀!感到欣慰的凡,至少在园子里.net精英还是非常多的……

   打算写一个ASP.NET
MVC4文山会海的文章,供企业新入职且无MVC项目阅的同事学习参考,以便飞适应工作,同时为希望于新家提供一些帮忙,欢迎大家指正,共同进步!并无是说,你看罢了即会了,我这里仅仅是为了吃丁快直达亲手,先用起来,很多情节需好去深入去研究。就哼比练武一般,我这里只是演示一模仿棍法而已,侧重于“招式”。《鹿鼎记》中陈近南于了韦小宝同本书,写的凡各种武功秘籍的目汇总,陈近南练了三十年才起立底地步。

  
我一般将找工作当成找目标,把面试当成亲,所以我错过面试一般喜欢这样说明白:当您见自己对目还是黑眼圈,那是坐自己深夜撸码撸得深沉;当您瞧瞧我那么二十几年的人口四十年份之面部,那是坐自己每每让Bug摧残而小发沧桑;当你见自己凌乱的发型和唏嘘的胡渣,那是坐自身时时以想各种解决方案要颓废;当您看见自己现在还是光棍一个,那可能是匪拿对象引用到实例或者连续遇到了404,毕竟不是各一样客好都好编译通过,我还无找到人生受到生一行Code。我就是是这么一个逼真的程序员,贵公司愿意接受这样一个自己也?

希望大家乐于分享,少说空话多干事实…

章目录

1、ASP.NET
MVC入门到精通——新语法

2、ASP.NET MVC入门到精通——Entity
Framework入门

3、ASP.NET MVC入门到精通——Entity
Framework增删改查

4、ASP.NET MVC入门到精通——NHibernate构建一个ASP.NET
MVC应用程序

**5、ASP.NET MVC入门到精通——NHibernate代码映射**

6、ASP.NET
MVC入门到精通——ASP.Net的片栽开发方式

7、ASP.NET MVC入门到精通——第一独ASP.NET
MVC程序

8、ASP.NET
MVC入门到精通——View(视图)

9、ASP.NET
MVC入门到精通——Controller(控制器)

10、ASP.NET
MVC入门到精通——Model(模型)和说明

11、ASP.NET
MVC入门到精通——AspnetMVC分页

12、ASP.NET
MVC入门到精通——HtmlHelper

13、ASP.NET
MVC入门到精通——MVC请求管道

14、ASP.NET
MVC入门到精通——Ajax

15、ASP.NET
MVC入门到精通——MVC-路出于

16、ASP.NET
MVC入门到精通——MVC过滤器

17、ASP.NET
MVC入门到精通——Spring.net入门

18、ASP.NET MVC入门到精通——Spring.net…

19、ASP.NET
MVC入门到精通——Unity

**20、ASP.NET
MVC入门到精通——WebAPI**

**21、**ASP.NET
MVC入门到精通——ASP.NET
MVC4优化**

22、ASP.NET
MVC入门到精通——搭建项目框架

23、ASP.NET
MVC入门到精通——业务层和数据层父类及接口-T4模板

24、ASP.NET
MVC入门到精通——数据库仓储

25、ASP.NET
MVC入门到精通——Spring.net-业务层仓储

26、ASP.NET
MVC入门到精通——后台管理区域与分离、Js压缩、css、jquery扩展

……………..

暂时列出这部分,后续要发要长的我会马上更新,工作其实是忙碌,只能采用业余时间进行整理,我或许并无见面严格依照这列表顺序进行翻新,旨在为ASP.NET
MVC初家提供一些带,所以多情节无见面称得专程深刻,但是我会力求通俗易懂。

最后,打下广告,公司官网:http://www.mosuda.com/、http://www.kjy.cn

干活地方:深圳市初能源更新产业园 | 康同严正厦五楼

即公司招聘如下:

高级.NET工程师2名

任职要求:
1、3年因为上.net b/s开发经历,熟练掌握.net开发架构和MVC设计模式;
2、熟练运用HTML、Javascript、CSS、XML、AJax,精通三重叠架构模式;
3、精通sqlserver数据库,熟悉其它1~2种数据库;
4、责任心强,性格开朗,人品正直,具有优良的联络能力跟团队合作精神;
5、熟悉电子商务网站开发者优先。

工作任务:
1、负责系统机能的编程实现与单元测试;
2、参与部分求分析及软件功能设计;
3、编写部分支出文档;
4、承担部分已达成丝网保护工作;

高级JAVA工程师4名

岗位职责:
1、主要担负店铺软件和新产品之开销
2、根据计划要求,完成编码、单元测试
3、负责店现有产品技术优化方案制订与实践,负责新产品之分析和计划
4、负责带技术团队成功产品之路计划、开发及保护

任职要求:
1、大专和以上学历,计算机、软件等息息相关标准;
2、3-5年Java开发经历,熟悉J2EE体系布局;
3、熟悉面向对象编程技术同软件开发流程,有可观的整还是模块设计能力;
4、熟练掌握数据库基本知识,至少发生同等种大型数据库的动开发经历;
5、熟练应用CSS、JQuery、xml、Ajax等技巧;
6、熟悉eclipse开发环境,熟练掌握spring、structs、Hibernate等框架技术;
7、对Linux有自然了解,能为此Shell进行健康的保护,熟悉Websphere、Weblogic、Tomcat等应用服务器的布置以及调优;
8、有比强的独立上能力;良好的编程习惯及编程风格;
具有得天独厚的关联理解能力,能接受比充分工作压力,具有组织合作精神,工作肯干,态度认真;
9、具备互联网,电子商务,物流,仓储系统开发经验者优先;

假设有意来企业求职者,请用简历发送到我之干活邮箱zouqiongjun@126.com,谢谢!有其他问题,可以叫本人发短消息还是邮件都只是!

商店活动照

 下转该建模游戏桌了

defmodule SimplePoker do
    @cards  for i <- 1..4, j<- 1..13, do: {i, j}
    @ten 10
    @ace 1
    @tian_gong [8,9]
    @ignore 0
    def init_cards, do: @cards
    # 洗牌
    def shuffle(cards), do: cards |> Enum.shuffle

    # 初始发牌
    def init_deal(cards, seat_num) do
        {cs, left} = cards |> Enum.split(seat_num * 2)
        {:ok, Enum.chunk_every(cs, 2), left}
    end

    # 补单张
    def deal([card| left]), do: {:ok, card, left} 

    def single_point({_, p}) when p < @ten, do: p
    def single_point(_), do: @ten

    def normal_power(cards) do
        sum = cards |> Enum.map( &single_point(&1) ) |> Enum.sum 
        rem(sum, @ten)
    end
    # 牌力计算, 需参考是否开牌
    def power([_a, _b] = cards, is_open) do
        p = normal_power(cards)
        cond do
            p in @tian_gong and is_open -> {:tian_gong, p}
            true ->{:normal, p}
        end
    end

    def power(cards, false) do
        cond do
            is_flush_straight?(cards) -> {:flush_straight, @ignore}
            is_three?(cards) -> {:three, @ignore}
            is_flush?(cards) -> {:flush, @ignore}
            is_straight?(cards) -> {:straight, @ignore}
            true -> {:normal, normal_power(cards)}
        end    
    end

    # a 是否赢 b
    # 都是天公,比点数
    def win?({:tian_gong, p1}, {:tian_gong, p2}), do: p1 > p2
    # 天公比其他都大
    def win?({:tian_gong, _}, _), do: true
    def win?(_, {:tian_gong, _}), do: false

    # 非普通牌,通牌型一样大
    def win?({same, _}, {same, _}) when same != :normal, do: false
    # 同花顺比余下都大, 以下类推
    def win?({:flush_straight, _}, _), do: true
    def win?(_, {:flush_straight, _}), do: false
    def win?({:three, _}, _), do: true
    def win?(_, {:three, _}), do: false
    def win?({:flush, _}, _), do: true
    def win?(_, {:flush, _}), do: false
    def win?({:straight, _}, _), do: true
    def win?(_, {:straight, _}), do: false 
    # 普通牌需要比较点数
    def win?({:normal, p1}, {:normal, p2}), do: p1 > p2

    # 赢多少倍
    def multiply({:tian_gong, _}), do: 1
    def multiply({:flush_straight, _}), do: 16
    def multiply({:three, _}), do: 8
    def multiply({:flush, _}), do: 4
    def multiply({:straight, _}), do: 2
    def multiply({:normal, _}), do: 1


    def is_flush?([{s, _}, {s, _}, {s, _}]), do: true
    def is_flush?(_), do: false

    def is_straight?([{_, p1}, {_, p2}, {_, p3}]) do
        [n1, n2, n3] = [p1, p2, p3] |> Enum.sort 
         cond do
             n1 + 1 == n2 and n2 + 1 == n3 -> true
             n1 == @ace and n2 + 1 == n3 -> true
             n1 == @ace and n2 + 2  == n3 -> true    
             true -> false
         end    
    end

    def is_three?([{_, p}, {_, p}, {_, p}]), do: true
    def is_three?([{_, p1}, {_, p2}, {_, p3}]) do
        case [p1, p2, p3] |> Enum.sort do
            [@ace, @ace, _] -> true
            [@ace, n, n] -> true
            _other -> false
        end
    end

    def is_flush_straight?(cards), do: is_flush?(cards) and is_straight?(cards)

end

# SimplePoker.init_cards |> SimplePoker.shuffle |> IO.inspect
# SimplePoker.init_cards |> SimplePoker.init_deal(2) |> IO.inspect

model 以新增 simple_poker.ex , 代码不多,做了点简单注释,可以贴下

defmodule SimplePokerTest do
  use ExUnit.Case
  doctest SimplePoker

  setup do
      %{
          s_ace: {1,1},   # 黑桃A
          h_ace:  {2, 1}, # 红桃A,
          c_ace: {3, 1},  # 梅花A
          s_two: {1, 2},  # 黑桃2
          h_two: {2, 2},  # 红桃2
          c_two: {3, 2},  # 梅花2
          s_three: {1, 3},  # 黑桃3
          h_three: {2, 3}, # 红桃3
          s_four: {1, 4},  # 黑桃4
          h_four: {2, 4},  # 红桃4
          s_five: {1, 5}, # 黑桃5
          s_eight: {1, 8}, # 黑桃8
          s_nine: {1, 9}, # 黑桃9
          s_ten: {1, 10}, # 黑桃10
          s_jack: {1, 11}

      }
  end  


  test "同花: 黑桃A,黑桃2, 黑桃3 ", cards do
      flush_cards = [cards.s_ace, cards.s_two, cards.s_three]
      assert SimplePoker.is_flush?(flush_cards)
  end

  test "非同花: 黑桃A, 红桃A, 黑桃2 ", cards do
      not_flush_cards = [cards.s_ace, cards.h_ace, cards.s_two]
      refute SimplePoker.is_flush?(not_flush_cards) 
  end

  test "三条: 普通", cards do
      normal_three = [cards.s_two, cards.h_two, cards.c_two]
      assert SimplePoker.is_three?(normal_three)
  end

  test "三条:1张A + 1对 ", cards do
    one_ace_and_one_pair = [cards.s_two, cards.h_two, cards.s_ace]
    assert SimplePoker.is_three?(one_ace_and_one_pair)
  end

  test "三条: 2张A + 1张2 ", cards do
    two_ace_and_one = [cards.s_ace, cards.h_ace, cards.s_two]    
    assert SimplePoker.is_three?(two_ace_and_one)
  end

  test "非三条: A, 2, 3", cards do
      not_three = [cards.s_ace, cards.s_two, cards.s_three]
      refute SimplePoker.is_three?(not_three)
  end

  test "顺子: 普通 黑桃2, 黑桃3, 红桃4", cards do
      normal_straight = [cards.s_two, cards.s_three, cards.h_four]
      assert SimplePoker.is_straight?(normal_straight)
  end

  test "顺子: 普通 黑桃A, 黑桃2, 红桃3", cards do
      one_ace_normal_straight = [cards.s_ace, cards.s_two, cards.h_three]
      assert SimplePoker.is_straight?(one_ace_normal_straight)
  end

  test "顺子: 普通 黑桃A, 黑桃2, 红桃4", cards do
      one_ace_normal_straight = [cards.s_ace, cards.s_two, cards.h_four]
      assert SimplePoker.is_straight?(one_ace_normal_straight)
  end

  test "非顺子: 黑桃A, 黑桃2, 红桃2", cards do
      not_straight = [cards.s_ace, cards.s_two, cards.h_two]
      refute SimplePoker.is_straight?(not_straight)
  end

  test "同花顺: 普通", cards do
      normal_flush_straight = [cards.s_two, cards.s_three, cards.s_four]
      assert SimplePoker.is_flush_straight?(normal_flush_straight)    
  end

  test "普通三张", cards do
      normal = [cards.s_two, cards.s_two, cards.h_three]
      assert {:normal, _} = SimplePoker.power(normal, false)
  end

  test "天公9点", cards do
      assert {:tian_gong, 9} = [cards.s_ace, cards.s_eight] |> SimplePoker.power(true) 
      assert {:tian_gong, 9} = [cards.s_four, cards.s_five] |> SimplePoker.power(true)
  end

  test "普通9点", cards do
      assert {:normal, 9} = [cards.s_ace, cards.s_eight] |> SimplePoker.power(false)
  end

  test "single_point", cards do
       assert  1 == cards.s_ace |> SimplePoker.single_point
       assert 10 == cards.s_ten |> SimplePoker.single_point 
       assert 10 == cards.s_jack |> SimplePoker.single_point
  end

  test "win?" do
      tian_gong_9 = {:tian_gong, 9}
      tian_gong_8 = {:tian_gong, 8}
      flush_straight = {:flush_straight, 0}
    three = {:three, 0}
    flush = {:flush, 0}
    straight = {:straight, 0}
    normal_9 = {:normal, 9}
    normal_8 = {:normal, 8}

    assert SimplePoker.win?(tian_gong_9, tian_gong_8) 
    refute SimplePoker.win?(tian_gong_9, tian_gong_9)
    refute SimplePoker.win?(tian_gong_8, tian_gong_9)
    assert SimplePoker.win?(tian_gong_9, flush_straight)
    refute SimplePoker.win?(flush_straight, tian_gong_9)

    refute SimplePoker.win?(flush_straight, flush_straight)
    assert SimplePoker.win?(flush_straight, three)
    refute SimplePoker.win?(three, flush_straight)

    assert SimplePoker.win?(three, flush)
    refute SimplePoker.win?(flush, three)

    assert SimplePoker.win?(flush, straight)
    refute SimplePoker.win?(straight, flush)

    assert SimplePoker.win?(straight, normal_9)
    refute SimplePoker.win?(normal_9, straight)

    assert SimplePoker.win?(normal_9, normal_8)
    refute SimplePoker.win?(normal_9, normal_9)
    refute SimplePoker.win?(normal_8, normal_9)
  end

end

simple_poker_test.exs

做到现在感觉到时尚无以umbrella的必要(也许下会发现必要吧),model 应用了可统一到game_server。

测试代码 simple_poker_test.exs

simple_poker.ex

达成磨介绍了玩法,现在编写了玩法的简要建模。