Jelly, 10 bytes

UÐeẎṙṁ⁸UÐe

A dyadic Link accepting the marix on the left and the rotation integer on the right (uses the reverse meaning of positive / negative)

Try it online!

How?

UÐeẎṙṁ⁸UÐe - Link: matrix of integers, M; integer, R
 Ðe - apply to even indices of M:
U - reverse each
 Ẏ - tighten
 ṙ - rotate left by R
 ṁ - mould like:
 ⁸ - chain's left argument, M
 Ðe - apply to even indices:
 U - reverse each

R, 121 110 101 bytes

function(m,n,o=t(m))o)+1]=o;o[,j]=o[i,j];t(o)

Try it online!

Walkthrough

function(m,n) # Input: m - matrix, n - shift
 o <- t(m) # Transpose the matrix, since R works in column-major order
 # while our snake goes in row-major order
 i <- nrow(o):1 # Take row indices in reverse
 j <- c(F,T) # Take even column indices (FALSE, TRUE, FALSE, TRUE, ...)
 o[,j] <- o[i,j] # "Normalize" the matrix by reversing every second column
 o[(seq(o)+n-1) %% # Perform the shift: add n-1 to indices,
 length(o)+1] <- o # Modulo sequence length, and +1 again
 o[,j] <- o[i,j] # Reverse even columns again to return to snake form
 t(o) # Transpose the matrix back to orginal shape and return

Python 3.8 (pre-releasSSSse), 119 bytes

lambda m,r,n=-1:[[m[(k:=(j+(s:=r+i)//w)%h)][::n**k][s%w]for i in range(w:=len(m[0]))][::n**j]for j in range(h:=len(m))]

An unnamed function accepting matrix, rotation which yields the new matrix.

Uses the opposite rotation sign.

Try it online!

How?

We set n=-1 upfront to save on parentheses later and take the matrix as m and the rotation as r.

A new matrix is constructed with the same dimensions as m - with a width of w (w:=len(m[0])) and a height of h (h:=len(m)).

Every other row of this matrix is reversed ([::n**j]).

The values are looked up by calculating their row and column in the original, m using the current elements row, i, and column, j...

We set s to r+i and k to (j+s//w)%h. k is the row of the original to access for our current element.

In order to easily access odd indexed rows from the right we reverse such rows before accessing their elements (with [:n**k]), this means the element of interest is at s%w.

J, 41 30 21 bytes

-11 bytes thanks to Jonah!

-9 bytes thanks to FrownyFrog & ngn !

$@]t@$(|.,@t=.|.@]/)

Try it online!

Reversed +/-

JavaScript (Node.js), 102 bytes

Takes input as (matrix)(integer). The meaning of the sign of the integer is inverted.

m=>n=>(g=m=>m.map(r=>r.sort(_=>~m,m=~m)))(m.map(r=>r.map(_=>a[(l+n++%l)%l]),l=(a=g(m).flat()).length))

Try it online!

Helper function

The helper function $g$ is used to 'snakify' or 'unsnakify' a matrix by reversing rows at odd indices.

g = m => // m[] = input matrix
 m.map(r => // for each row r[] in m[]:
 r.sort(_ => // sort r[]:
 ~m, // using either 0 (don't reverse) or -1 (reverse)
 m = ~m // and toggling m before each iteration
 // (on the 1st iteration: m[] is coerced to 0, so it yields -1)
 ) // end of sort()
 ) // end of map()

Main function

m => n => // m[] = matrix, n = integer
 g( // invoke g on the final result
 m.map(r => // for each row r[] in m[]:
 r.map(_ => // for each entry in r[]:
 a[(l + n++ % l) % l] // get the rotated value from a[]; increment n
 ), // end of inner map()
 l = ( // l is the length of a[]:
 a = g(m).flat() // a[] is the flatten result of g(m)
 ).length // (e.g. [[1,2],[3,4]] -> [[1,2],[4,3]] -> [1,2,4,3])
 ) // end of outer map()
 ) // end of call to g

05AB1E, 16 bytes

εNFR]˜²._¹gäεNFR

Try it online!

Thanks to Emigna for -5. Unfortunately, I can't see how to golf the redundant part out. :(

Charcoal, 36 bytes

ＦＥθ⎇﹪κ²⮌ιιＦι⊞υκＩＥ⪪Ｅυ§υ⁻κηＬ§θ⁰⎇﹪κ²⮌ιι

Try it online! Link is to verbose version of code. Explanation:

Ｅθ⎇﹪κ²⮌ιι

Reverse alternate rows of the input.

Ｆ...Ｆι⊞υκ

Flatten the array.

Ｅυ§υ⁻κη

Rotate the flattened array.

⪪...Ｌ§θ⁰

Split the array back into rows.

Ｅ...⎇﹪κ²⮌ιι

Reverse alternate rows.

Ｉ...

Convert each entry to string and output in the default output format which is one number per line with rows double-spaced. (Formatting with a separator would cost the length of the separator.)

Pyth, 20 bytes

L.e_W%k2bbyclQ.>syQE

Try it online here.

Japt, 28 bytes

mÏ%2©XÔªX
c éV òUÎl
W©UªßV1V

Try it

Port of Arnauld's answer. The biggest challenge was creating a reusable function. In particular, there is a helper function to reverse every other row. The approach that I am taking is to make a recursive call and depending on whether a variable is set.

Transpiled JS:

// U: first input argument (matrix)
// m: map it through a function
U = U.m(function(X, Y, Z) 
 // if the row index is even, don't alter it
 // if the row index is odd, reverse it (w)
 return Y % 2 && X.w() );
V = U
 // flatten the matrix
 .c()
 // shift by the amount specified in second argument
 .é(V)
 // partition back to matrix
 .ò(
 // the number of columns should be the same as input
 U.g().l()
 );
// if W is specified, return the result from the first line
W && U ||
 // otherwise, make a recursive call with the shifted matrix
 rp(V, 1, V)

Python 3, 94 bytes

lambda m,n:g(roll(g(m),n))
g=lambda b:[b[i][::(-1)**i]for i in r_[:len(b)]]
from numpy import*

Try it online!

Used the odd-row-reversal from Jonathan Allan's answer.

lambda m,n:g(roll(g(m),n)) #reverse odd rows, shift elements, then reverse odd rows again.
g=lambda b:[b[i][::(-1)**i] #reverse odd rows
 for i in r_[:len(b)]] #r_[:x] = range(x)
from numpy import* #roll() and r_[]

APL (Dyalog Classic), 20 bytes

↑∘t⊢∘⍴⍴⌽∘∊∘(t←⊢∘⌽↓)

Try it online!

C# (Visual C# Interactive Compiler), 141 bytes

a=>n=>for(dynamic l=a.Length,w=a.GetLength(1),i=l,j,b=a.Clone();i-->0;)a[(j=(i+n%l+l)%l)/w,j/w%2<1?j%w:w-j%w-1]=b[i/w,i/w%2<1?i%w:w-i%w-1];

Try it online!

-5 bytes total thanks to @someone!

Anonymous function that performs an in-place modification to the input matrix.

An single loop iterates over the cells. You can scan from top to bottom and left to right using the following formulas:

• row=i/w


• col=i%w

Where i is a loop counter and w is the number of columns. This is varies slightly when scanning in a snake pattern.

• row=i/w


• 
  col=i%w (0th, 2nd, 4th, etc. row)


• 
  col=w-i%w-1 (1st, 3nd, 5th, etc. row)

Another thing to note is that the % in C# does not convert to a positive value like it does in some other languages. A couple extra bytes are needed to account for this.

// a: input matrix
// n: number of cells to rotate
a=>n=>
 for(
 // l: total number of cells
 // w: number of columns
 // i: loop index
 // j: offset index
 // b: copy of input matrix
 dynamic
 l=a.Length,
 w=a.GetLength(1),
 i=l,j,
 b=a.Clone();
 // iterate from i down to 0
 i-->0;
 )
 // calculate the offset `j` and use
 // the above formulas to index
 // into `a` for setting a value
 a[
 (j=(i+n%l+l)%l)/w,
 j/w%2<1?j%w:w-j%w-1
 ]=
 // use the un-offset index `i` and
 // the above formulas to read a
 // value from the input matrix
 b[
 i/w,
 i/w%2<1?i%w:w-i%w-1
 ];