読者です 読者をやめる 読者になる 読者になる

ボドゲメモ(やったボドゲとその特徴や感想)

今後何かの役に立つかもしれないので、やったボドゲとその特徴を書く
ゲームの紹介ではない

tichu

概要:変則大富豪
特徴:チーム戦・カード交換・割れ目系システム・得点カードの配置

チーム戦

対面とコンビを組んで特典をより多くとったチームの勝利

カード交換

仲間間での相談は禁止されているので、カード交換がコミュニケートとして強い意味を持つ

割れ目系システム

ラージテーチュー、スモールテーチュー、と呼ばれるある種の割れ目システム
スモールテーチューはカードを一枚も出していない状態で宣言することができる。(パスし続けて一枚もカードを出さず、ゲーム終盤に宣言することも可能である)
宣言したプレイヤーが1位になった場合+100。なれなかった場合-100
ラージテーチューは手札が8枚配られた段階でのみ宣言でき(手札は全部で14枚)、宣言したプレイヤーが1位になった場合+200,なれなければ-200

億点カードの配置

tichuでは 
5:5点
T,K:10点
鳳凰(オールマイティ):-25点
竜(単体最強。ただし、これでトリックをとった場合、そのトリックの得点は相手プレイヤーに行く):+25点
となっている
TやKのようなカードに10点を配置したのはゲームに味が出ている

Dancing Dragons

特徴:通し

通し

このゲームは手役を揃え、それを味方に指摘してもらうことで得点するゲームである
したがってチーム間で通しをする必要がある
また、敵が手役を完成させていると思ったらそれを指摘することができる。
その場合も得点できる

いかさまゴキブリ

特徴;いかさま

いかさま

このゲームはいかさまで手札を処分することを目的としたゲームである
いかさまの事例は、2枚だし、カードを引くべき場面で引かない、手札からカードを落とす、山札に戻す、何気なく出す、眼鏡に刺す(現行犯でないと捕まえられないのであとで気が付いても遅い)、等々

王への請願

特徴;運命操作

運命操作

さいころの出目(乱数)を弄ったりすること(カード)で勝利を目指すゲーム
「ランダム要素をコントロールする」という体験が楽しい。
「これはさいころで、出目を操作する」というアナログな感じの処理があっている。デジタルに処理するとだいぶ冷めるきがする
たとえば、「このカードがあると成功率に+2%します」とか書かれてても冷めるじゃない。仮にそれが出目操作と実質同じことだったとしても

ぞんかま

マルチタスク

「手役ができたら手札をそっと倒す」「ほかの人は誰かが倒したのを見たら手役ができてなくても倒してよい」「倒すのが一番遅かった人が負け」というシンプルなゲームなのだが
なんやかんやでしりとりをしながらゲームをしたところ、ものの見事に集中力が分散した
人類にマルチタスクは難しい



電力会社

フェーズ終了時に場に出ている最も高額なカードが山札の下に行き、最終ターンにドバドバ出てくるのがバランス的にうまいなと思った

ドミニオン 帝国

新システム「借金」は6金帯の効果のカードを気軽に生み出せるヤバイシステムだと思った

棺担ぎのクロ6巻を買ってきてた

わーい。
以下メモ。ネタバレとかあるかも。注意

続きを読む

10時間くらいハーツの攻略法を考えてる

唐突にハーツがとても面白いゲームのような気がしてきて延々とCPU相手にハーツをしていた

「ハーツ 攻略」ググればはもっといいのがジャンジャンバリバリ出てくる気がするが
自分の中でかみ砕いたことが大事なのでそれを忘れないように
および自分の中で整理するために書き残しておこうと思う
ただCPU戦で考えた方法なので机上の空論感はある

カードの価値についての考察

戦略にもよる

低いカード (2-4とか)

リードを譲るために必要なのでとても大事
自分が同じ色を独占している場合、他プレイヤーがその色をすでに使い切っている可能性もあるので要注意

高いカード(AKとか)

リードをとることができる。後述のマリア対策などで活躍するかもしれない
ただ取った後どうするかのイメージがないと危険物質である。ヤバイと思ったら早めに捨ててしまおう
高めのカードを持っていることはそれを出さない方法があるなら(つまり低いカードを持っている状況なら)
そこまで不利にならないと思う。むしろ他との比率が重要
ダイヤが3,4,Aみたいなのは良い。
T,Q,Kみたいなのは不本意なリードをとらされ続けたりするのでよくない感じ

中くらいのカード(7-9とか)

とくにないです

スペードのJ以下

何を出してもマリアをつかまされることがないから安心

マリア対策

ブラックマリアは超怖いので取りたくない

スペード狩り

J以下のスペードを延々と出し続けてQの自爆or KAの登場を待つ

その他の色狩り

クラブorダイヤをリードを守りつつ1,2回上から出して
マリアを持っているプレイヤーがその色を切らしたと思ったら弱いカードを出し、他人にリードをとらせマリアをとっていただく
カンに頼ってるので一歩間違えると死ぬ。
スペードのAKが残っててスペード狩りされると死ぬときにオススメ

シュートザームーン

シュートザームーンは(4人対戦なら)相手に計78点入るのでマリアの6倍強い?
CPU相手ならそこそこ決まるので手札によっては狙うのは選択肢としてアリだと思う

シュートザームーンを狙うには?

大体AKとか+一色になる必要がある。ハートのAKがあると楽

概ね最終盤にリードを守り切る必要がある。
なので最終的に
何が出ても勝てるカード(AKとか)+リードをとり続けることができる同じ色のカード
の状態になる必要があり、そういう手札である必要がある

また、ハートの低い数字は持っていると失敗率が上がるので交換してしまうべき
(自分がそのカードを獲得す出来る状況は相手がハートを持っていない状況など。ハートがたくさんあるのならば問題ないかもしれない)

その他の色の低いカードは序盤に適当に捨ててしまう

感覚的にはハートのAK+ハートの高い数字+同じ色でリードを守り切れるカード5枚くらいで狙いだせる気がする
失敗したなと思ったら(例えばハートを独占しようとしたけれどどう考えてもこのまま上から出していくと最後に数枚持っていかれるときとか)
あきらめて独占色の下から出そう。他人にリードが移る可能性がある

ハートのA-Jがそろってるとほぼ決まる

その他

リードをとっても良い時はビジョンをもって積極的にリードをとるべきだと思った

C91 txt.txt欠席します

体調を崩してしまい参加が困難であるため、欠席します
申し訳ありません

それでも構造体をtupleに変換したい

前 最近書いたマクロ(構造体をtupleに変換したい) - TXT.TXT


これもC++ Advent Calendar 2016の9日目の記事です

はじまり

struct S
{
    int x;
    std::string s;
};

構造体に

bool operator<(S const&lhs,S const&rhs)
{
    return std::tie(lhs.x,lhs.s) < std::tie(rhs.x,rhs.s);
}

自動生成できるものを自動生成したい
それにはやっぱりtupleへの変換が必要だ

構造化束縛なら?

C++17(1z)で構造化束縛(Structured Bindings)という機能が入る
C++1z 構造化束縛 - Faith and Brave - C++で遊ぼう
詳しくは上などを見てほしいが結論を言うと

template<class T>
auto to_tie(T&&s)
{
    auto &[x1,x2] =s;
    return std::tie(x1,x2);
}

こういうこういう関数が作れる
[Wandbox]三へ( へ՞ਊ ՞)へ ハッハッ

ただ残念ながら自分は[X1,X2]の部分を可変長にする方法は知らない
これは必要なだけ書きなぐれば解決するのでそこまで困らないのだが
問題はこれをSFINAEの文脈で使う方法を思いつかないので適切な関数に振り分ける方法が思いつかない


なのでコンストラクタの引数の数から推定しようと思う
万能解とは言えないが、今回のケースではうまく行くし大丈夫な時は大丈夫だろう
だめでも構造化束縛で失敗するだろうし

実装

面倒なので1-3要素まで
まず構造体の引数の数をコンストラクタの引数の数から推測する

template<class T>auto impl(Nice<3>*)->decltype(T{{},{},{}},Idx<3>{}){return {};}
template<class T>auto impl(Nice<2>*)->decltype(T{{},{}},Idx<2>{}){return {};}
template<class T>auto impl(Nice<1>*)->decltype(T{{}},Idx<1>{}){return {};}
template<class T>
auto len(){return impl<T>(static_cast<Nice<3>*>(nullptr));}

それを元に構造体束縛でtieする

template<class T>
auto impl2(T&s,Idx<1>){auto &[x1] = s;return std::tie(x1);}
template<class T>
auto impl2(T&s,Idx<2>){auto &[x1,x2] = s;return std::tie(x1,x2);}
template<class T>
auto impl2(T&s,Idx<3>){auto &[x1,x2,x3] = s;return std::tie(x1,x2,x3);}

template<class T>
auto to_tie(T&s){return impl2(s,len<T>());}

後はそれを元にやりたいことをやる

template<class T>
bool cmp(T const&lhs,T const&rhs)
{
    return to_tie(lhs) < to_tie(rhs);
}

[Wandbox]三へ( へ՞ਊ ՞)へ ハッハッ


できないこと

T x={ {},{}/*略*/,{}};

の形式で初期化できない構造体はこの方法は使えない
explicitとかあるとまずいかもしれない
(これに関しては特に困らなさそうなので深く考えていないが、もしかしたらなんかいい方法があるのかもしれない)

また、マクロを使った場合にくらべ型名を取ることができないのでjson objectで鍵を持たせるなどができない


そして最大の問題は手元のコンパイラで動かない。未来はようカモン

最近書いたマクロ(構造体をtupleに変換したい)

これはC++ Advent Calendar 2016の9日目の記事です

はじまり

こんな感じのコードを書いていた

struct try_focus {
    Player p; Card c;
};
string to_json(try_play const &a){
    return make_json("try_play", a.p, a.c);
}
struct try_exc_hand {
    Player p; Card c1;Card c2;
};
string to_json(try_exc_hand const &a){
    return make_json("try_exc_hand", a.p, a.c1, a.c2);
}
struct nodata{};
string to_json(try_exc_hand const &){
    return make_json("nodata");
}
/*以下略*/
struct Key{
    Player p; Card c;
    bool operator<(Key const &rhs){return std::tie(p,c) < std::tie(rhs.p,rhs.c);}
};
struct Key{
    string s;rect r;
    bool operator<(Key const &rhs){return std::tie(s,r) < std::tie(rhs.s,rhs.r);}
};
/*以下略*/
struct pos{
    int p1,p2,p3;
    bool operator==(Key const &rhs)const{return std::tie(p1,p2) == std::tie(rhs.p1,rhs.p2);}
};
/*後で追加したp3を比較要素に追加し忘れた*/

あ!つらい!!
我に二度同じ文言書かすものみな死に絶えればいいのに!!!

はじまり2

そんな分けでいい感じのマクロないかな、とboost内をあさっていたところ BOOST_FUSION_DEFINE_STRUCT_INLINE なる顧客が本当に必要だったものが!
さっそく使おう
(ファンが不吉な音を立て始める)
(IDE候補検索が遅れる、出ない)
(IDEが長考する)
(締め切りがヤバイ)

もうだめだ。自分で書こう

つまりこうなりたいという気持ちがあります

hashとかoperator<とか決まりきった文句はいい感じに定義されててほしいし
to_stringとかto_jsonはちょっと頑張ったら定義できるようにしたい
それらは構造体をtupleに変換できれば解決します

書いた

#define LUCKY_STRUCT_WHITE 

#define LUCKY_STRUCT8_IMPL(name,X1,X2,X3,X4,X5,X6,X7,X8,...) \
struct name##define{ \
    template<class LUCKY_STRUCT_WHITE##X1,class LUCKY_STRUCT_WHITE##X2,class LUCKY_STRUCT_WHITE##X3,class LUCKY_STRUCT_WHITE##X4,class LUCKY_STRUCT_WHITE##X5,class LUCKY_STRUCT_WHITE##X6,class LUCKY_STRUCT_WHITE##X7,class LUCKY_STRUCT_WHITE##X8, class...>struct impl{ \
        LUCKY_STRUCT_WHITE##X1 X1;LUCKY_STRUCT_WHITE##X2 X2;LUCKY_STRUCT_WHITE##X3 X3;LUCKY_STRUCT_WHITE##X4 X4;LUCKY_STRUCT_WHITE##X5 X5;LUCKY_STRUCT_WHITE##X6 X6;LUCKY_STRUCT_WHITE##X7 X7;LUCKY_STRUCT_WHITE##X8 X8; \
        auto operator|(::lucky_struct::to_tie_t){return std::tuple_cat(std::tie(X1),std::tie(X2),std::tie(X3),std::tie(X4),std::tie(X5),std::tie(X6),std::tie(X7),std::tie(X8));} \
        auto operator|(::lucky_struct::get_name_t)const{return #name;} \
    };\
    template<class...T>using type = impl<T... ,void,void,void,void,void,void,void,void>;\
};\
using name=typename name##define::type
#define LUCKY_STRUCT8(name,...) LUCKY_STRUCT8_IMPL(name,__VA_ARGS__, , , , , , , )

8要素までの構造体を定義するマクロのコア部分
tupleに結び付けられるし余計な要素が入ることもない
そしてそこまで重くない(当社比)
[Wandbox]三へ( へ՞ਊ ՞)へ ハッハッ


コードの動き

8要素までだとコードの動きが追いづらいので2要素かつ機能を一部削ったマクロで考える

#define LUCKY_STRUCT2_IMPL(name,X1,X2,...) \
struct name##define{ \
    template<class LUCKY_STRUCT_WHITE##X1,class LUCKY_STRUCT_WHITE##X2, class...>struct impl{ \
        LUCKY_STRUCT_WHITE##X1 X1;LUCKY_STRUCT_WHITE##X2 X2; \
        auto operator|(::lucky_struct::to_tie_t){return std::tuple_cat(std::tie(X1),std::tie(X2));} \
    };\
    template<class...T>using type = impl<T... ,void,void>;\
};\
using name=typename name##define::type
#define LUCKY_STRUCT2(name,...) LUCKY_STRUCT2_IMPL(name,__VA_ARGS__, )
  LUCKY_STRUCT2(Alpha,val)<int>;

このように定義するとマクロはまず以下のように展開される

  LUCKY_STRUCT2_IMPL(Alpha,val,)<int>

引数はname=Alpha,X1=val, X2= となりLUCKY_STRUCT2_IMPLが展開される

struct Alphadefine{
    template<class LUCKY_STRUCT_WHITEval,class LUCKY_STRUCT_WHITE, class...>struct impl{
        LUCKY_STRUCT_WHITEval val;LUCKY_STRUCT_WHITE ;  //1
        auto operator|(::lucky_struct::to_tie_t){return std::tuple_cat(std::tie(val),std::tie());} //2
    };
    template<class...T>using type = impl<T... ,void,void>;
};
using Alpha=typename Alphadefine::type<int>

そしてLUCKY_STRUCT_WHITE が に置換される

struct Alphadefine{
    template<class LUCKY_STRUCT_WHITEval,class , class...>struct impl{
        LUCKY_STRUCT_WHITEval val; ;   //1
        auto operator|(::lucky_struct::to_tie_t){return std::tuple_cat(std::tie(val),std::tie());}  //2
    };
    template<class...T>using type = impl<T... ,void,void>;
};
using Alpha=typename Alphadefine::type<int>

//1の部分
メンバ変数の定義。
X2は空だったので変数名は定義されず、LUCKY_STRUCT_WHITE##X2もLUCKY_STRUCT_WHITEになり空に置換され、第2変数を構成する要素は構造体から消えた
X1は名前を持っていたのでLUCKY_STRUCT_WHITEval val;という定義になる。LUCKY_STRUCT_WHITEval はテンプレート引数として使われる

//2の部分
X1は名前を持っていたのでstd::tie(val)に、X2は空だったのでstd::tie()になった。これらはtuple_catで結合され最終的に1要素のtieが出力される

こうして2要素まで定義できるマクロで1要素の変数を持つ構造体が定義できた
もちろん余計なストレージを所有することなどない
これを8要素に拡張すれば上で定義したものになる。もっと必要なら16や32など拡張してもいいだろう(そんな必要になることはないと思うが)

あとは適当に好きな関数を定義すれば比較も出力も思うが儘だろう
とりあえず比較を実装した
[Wandbox]三へ( へ՞ਊ ՞)へ ハッハッ









つづく

txt-txt.hateblo.jp

じてんしゃそーぎょーさん、しんさくですってよ



おおおおおおおおおおおおおおおおおおおおお(中略。季節が春になるまで叫び続ける)

ちょっとPSVR買ってくる

    • 追記(一時間後ぐらい)

PSVR品薄なのね。初めて知った
あと今日ps4proの発売日なのね
何とか発売までに手に入れないと……。とりあえず明日それっぽい店のぞいてみるか

ボイス付き説が出ているけれどフルボイスとかハーフボイスとかだったりするんだろうか?
文字が見えないけれどどうなるんだろう
ヒロイン子は鮭の一族なんだろか?
しかしこの子いつになく涼しげな恰好をしているな(カコを思い浮かべながら)。何つーか「プレイエリアの外です」が出てきそうな恰好をしているぞ
自転車創業なのに。パンツが禁則されてしまう系世界なのに。
「ひとかけら版」ってなんじゃろ。『※本作はプロローグ版です。』とあるけれどつまり、・・・・・・どういうことだ?
dengekionline.com

とりあえずデジゲー博まで心の一部のどっかしらを温かくして待ってますか

とか言ってたらこんな時間だよ。(161110-0245)